SQL(ite) fast retrieval of multiple substrings of larger string (genome)

I have a sql database consisting of a genome, its chromosomes, and "interesting" regions (in BED format). A genome (e.g. 4GB) consists of +/- 20 chromosomes, so each string is around 200MB large. The chromosome in a genome for instance consists of the string:

NNNNATCCAGGAGAATTACAT...ACCGGGAATTCCCGGNNNNN # 200 MB large

Let's say I have around 1.000.000 regions ATAC-seq peaks and I would like to get the sequences of 100 bp of only chromosome 3. My SQL query would look like this:

SELECT substr(Chr.Sequence, Bed.ChromStart + Bed.Peak - 50, 100) FROM Bed Bed
INNER JOIN Chromosome Chr ON Bed.ChromosomeId = Chr.ChromosomeId
WHERE Chr.Chromosome = 'chr3'

The problem with these kind of lookups is that the Chr.Sequence is loaded for every single hit, making the ram usage excessively large, and the lookup really slow. The way I 'fixed' this is only using the SQL database to store the positions of the interesting locations, and then using pyfaidx to quickly get the corresponding sequences out of the chromosome.

I am wondering if a fast lookup is possible in SQL(ite), since the current solution feels a bit ad-hoc to me.

You can break genome string into parts and search for substrings simultaneously using multiprocessing to minimize the single processor usage and faster results.

import sys
import multiprocessing
from multiprocessing import Pool

def SplitGenomeString(start,length):
#where con in sqlconnection to database using as global variable
   cursorObj = con.cursor()


   cursorObj.execute('SELECT substr(Chr.Sequence,{},{}) FROM Chromosome 
                      Chr'.format(str(start),str(length))
   return cursorObj.fetchall()

def getSubSequence(s):
#Write your Queries according to your requirements for finding subsequence s




if __name__ == '__main__':
    length = SplitGenomeString(0,sys.maxint)
    cores = multiprocessing.cpu_count()

    #asumming the subsequence you want to check is 100
    subseq_len = 100

    for i in range(0,length,round(length/cores)):
        ls.append(SplitGenomeString(i,round(length/cores)))

    #this will also include the excluded parts because of splitting geneome string
    temp = []
    for i in range(len(ls) - 1):
        temp.append(ls[i][1 - subseq_len):] + ls[i+1][:subseq_len - 1])

    ls = ls + temp

    with Pool(cores) as p:
        p.map(getSubSequence,ls)

You can see about multiprocessing in this link:
https://docs.python.org/3/library/multiprocessing.html

Edited as told