bellek açısından verimli yerleşik SqlAlchemy yineleyici / oluşturucu?

SqlAlchemy kullanarak arabirim oluşturduğum bir ~ 10M kayıt MySQL tablom var. Bu tablonun büyük alt kümelerindeki sorguların, veri kümesinin bit büyüklüğünde parçalarını akıllıca getiren yerleşik bir jeneratör kullandığımı düşünmeme rağmen çok fazla bellek tüketeceğini buldum:

for thing in session.query(Things):
    analyze(thing)

Bundan kaçınmak için, parçalar halinde ısıran kendi yineleyicimi oluşturmam gerektiğini anlıyorum:

lastThingID = None
while True:
    things = query.filter(Thing.id < lastThingID).limit(querySize).all()
    if not rows or len(rows) == 0: 
        break
    for thing in things:
        lastThingID = row.id
        analyze(thing)

Bu normal mi yoksa SA yerleşik jeneratörleriyle ilgili eksik olduğum bir şey mi var?

Cevabı bu soruya bellek tüketimi beklenen olmadığını belirtmek gibi görünüyor.

Çoğu DBAPI uygulaması, getirilirken satırları tam olarak arabelleğe alır - bu nedenle genellikle, SQLAlchemy ORM bir sonucu tutmadan önce, tüm sonuç kümesi bellekte bulunur.

Ancak daha sonra, Querysize nesnelerinize dönmeden önce varsayılan olarak verilen sonuç kümesini tamamen yüklemesinin yolu çalışır. Buradaki mantık, basit SELECT ifadelerinden daha fazlası olan sorgularla ilgilidir. Örneğin, aynı nesne kimliğini bir sonuç kümesinde birden çok kez döndürebilen diğer tablolarla birleştirmelerde (istekli yüklemeyle ortaktır), tüm satır kümesinin bellekte olması gerekir, böylece doğru sonuçlar, aksi takdirde koleksiyonlar ve benzeri döndürülebilir. yalnızca kısmen nüfuslu olabilir.

Bu nedenle Query, bu davranışı değiştirme seçeneği sunar yield_per(). Bu çağrı Query, toplu iş boyutunu verdiğiniz toplu işlerde satırlar vermesine neden olacaktır . Dokümanların belirttiği gibi, bu yalnızca herhangi bir istekli koleksiyon yüklemesi yapmıyorsanız uygundur, bu nedenle temelde ne yaptığınızı gerçekten biliyorsanız. Ayrıca, temeldeki DBAPI satırları önceden tamponlarsa, yine de bu bellek yükü olacaktır, bu nedenle yaklaşım, kullanmamaktan biraz daha iyi ölçeklenir.

Neredeyse hiç kullanmıyorum yield_per(); bunun yerine, pencere işlevlerini kullanarak yukarıda önerdiğiniz LIMIT yaklaşımının daha iyi bir sürümünü kullanıyorum. LIMIT ve OFFSET, çok büyük OFFSET değerlerinin sorgunun daha yavaş ve daha yavaş olmasına neden olduğu büyük bir soruna sahiptir, çünkü N'nin OFFSET'i N satırdan geçmesine neden olur - aynı sorguyu bir yerine elli kez yapmak, her seferinde a daha büyük ve daha fazla sayıda satır. Pencere işlevi yaklaşımıyla, seçmek istediğim tablonun parçalarına atıfta bulunan bir dizi "pencere" değerini önceden getiriyorum. Daha sonra, her biri bir seferde bu pencerelerin birinden çekilen ayrı SELECT ifadeleri yayınlıyorum.

Pencere işlevi yaklaşımı wiki'de ve onu büyük bir başarıyla kullanıyorum.

Ayrıca, tüm veritabanları pencere işlevlerini desteklemez; Postgresql, Oracle veya SQL Server'a ihtiyacınız var. En azından Postgresql kullanan IMHO kesinlikle buna değer - ilişkisel bir veritabanı kullanıyorsanız, en iyisini kullanabilirsiniz.

Ben bir veritabanı uzmanı değilim, ancak SQLAlchemy'yi basit bir Python soyutlama katmanı olarak kullanırken (yani, ORM Sorgu nesnesini kullanmadan), bellek kullanımını patlatmadan 300M satırlık bir tabloyu sorgulamak için tatmin edici bir çözüm buldum ...

İşte sahte bir örnek:

from sqlalchemy import create_engine, select

conn = create_engine("DB URL...").connect()
q = select([huge_table])

proxy = conn.execution_options(stream_results=True).execute(q)

Ardından, fetchmany()sonuçları sonsuz bir whiledöngüde yinelemek için SQLAlchemy yöntemini kullanıyorum :

while 'batch not empty':  # equivalent of 'while True', but clearer
    batch = proxy.fetchmany(100000)  # 100,000 rows at a time

    if not batch:
        break

    for row in batch:
        # Do your stuff here...

proxy.close()

Bu yöntem, herhangi bir tehlikeli bellek ek yükü olmadan her türlü veri toplamayı yapmama izin verdi.

NOTE stream_resultsPostgres ve çalışır pyscopg2adaptör, ama olmaz herhangi dbapi ile iş, ne de herhangi bir veritabanı sürücüsü ile galiba ...

Bu blog yazısında yukarıdaki yöntemime ilham veren ilginç bir kullanım alanı var .

SQLAlchemy ile verimli geçiş / sayfalama araştırıyorum ve bu yanıtı güncellemek istiyorum.

Bir sorgunun kapsamını uygun şekilde sınırlandırmak için dilim çağrısını kullanabileceğinizi ve onu verimli bir şekilde yeniden kullanabileceğinizi düşünüyorum.

Misal:

window_size = 10  # or whatever limit you like
window_idx = 0
while True:
    start,stop = window_size*window_idx, window_size*(window_idx+1)
    things = query.slice(start, stop).all()
    if things is None:
        break
    for thing in things:
        analyze(thing)
    if len(things) < window_size:
        break
    window_idx += 1

Joel'in cevabının ruhuna uygun olarak şunu kullanıyorum:

WINDOW_SIZE = 1000
def qgen(query):
    start = 0
    while True:
        stop = start + WINDOW_SIZE
        things = query.slice(start, stop).all()
        if len(things) == 0:
            break
        for thing in things:
            yield thing
        start += WINDOW_SIZE

LIMIT / OFFSET kullanmak kötüdür çünkü daha önce tüm {OFFSET} sütunlarını bulmanız gerekir, bu nedenle ne kadar büyükse OFFSET olur - o kadar uzun istek alırsınız. Benim için pencereli sorgu kullanmak, büyük miktarda veriye sahip büyük tabloda da kötü sonuçlar veriyor (ilk sonuçları çok uzun süre bekliyorsunuz, bu benim durumumda yığınlanmış web yanıtı için iyi değil).

Burada verilen en iyi yaklaşım https://stackoverflow.com/a/27169302/450103 . Benim durumumda sorunu sadece datetime alanındaki indeksi kullanarak ve datetime> = previous_datetime ile sonraki sorguyu getirerek çözdüm. Aptalca, çünkü bu dizini daha önce farklı durumlarda kullandım, ancak pencereli tüm verileri getirmek için sorgunun daha iyi olacağını düşündüm. Benim durumumda yanılmışım.

AFAIK, ilk varyant hala tablodan (tek bir SQL sorgusuyla) tüm tupl'leri alır, ancak yineleme sırasında her varlık için ORM sunumunu oluşturur. Bu nedenle, yinelemeden önce tüm varlıkların bir listesini oluşturmaktan daha etkilidir, ancak yine de tüm (ham) verileri belleğe almanız gerekir.

Bu nedenle, LIMIT'i büyük masalarda kullanmak bana iyi bir fikir gibi geliyor.