ефективний пам’ять вбудований ітератор / генератор SqlAlchemy?

У мене є ~ 10M таблиці записів MySQL, з якою я взаємодію за допомогою SqlAlchemy. Я виявив, що запити у великих підмножинах цієї таблиці будуть споживати занадто багато пам’яті, хоча я думав, що використовую вбудований генератор, який розумно отримує шматки розміру набору даних:

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

Щоб уникнути цього, я вважаю, що мені потрібно створити власний ітератор, який відсікається шматками:

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)

Це нормально чи чогось мені не вистачає щодо вбудованих генераторів SA?

Відповідь на це питання, мабуть, вказує на те, що споживання пам'яті очікувати не варто.

Більшість реалізацій DBAPI повністю буферизують рядки у міру їх отримання - тому, як правило, перш ніж SQLAlchemy ORM навіть отримує один результат, весь набір результатів знаходиться в пам'яті.

Але тоді, як Queryпрацює, це те, що він повністю завантажує заданий результат за замовчуванням, перш ніж повертати вам ваші об’єкти. Обґрунтування тут стосується запитів, які є більше, ніж простими операторами SELECT. Наприклад, при об'єднаннях до інших таблиць, які можуть повертати одну і ту ж ідентичність об'єкта кілька разів в одному наборі результатів (загальне для нетерплячого завантаження), повний набір рядків повинен бути в пам'яті, щоб правильні результати могли бути повернуті в іншому випадку колекції і такі може бути заселено лише частково.

Тож Queryпропонує можливість змінити цю поведінку за допомогою yield_per(). Цей виклик призведе Queryдо отримання рядків рядками, де ви надаєте йому розмір партії. Як зазначається у документах, це доречно лише у тому випадку, якщо ви не робите будь-якого нетерплячого завантаження колекцій, тому в основному, якщо ви дійсно знаєте, що робите. Крім того, якщо базовий DBAPI попередньо буферизує рядки, ця пам'ять все одно залишатиметься, тому підхід лише масштабується трохи краще, ніж не використовувати його.

Я майже ніколи не використовую yield_per(); натомість я використовую кращу версію підходу LIMIT, який ви запропонували вище, використовуючи функції вікна. LIMIT та OFFSET мають величезну проблему, оскільки дуже великі значення OFFSET спричиняють повільніший та повільніший запит, оскільки OFFSET з N змушує його переходити через N рядків - це все одно, що робити один і той же запит п'ятдесят разів замість одного, кожного разу читаючи більша і більша кількість рядів. За допомогою підходу з функцією вікна я попередньо отримую набір значень "вікно", які посилаються на фрагменти таблиці, яку я хочу вибрати. Потім я видаю окремі оператори SELECT, які кожен витягує з одного з цих вікон одночасно.

Підхід до функцій вікна знаходиться у вікі, і я користуюся ним із великим успіхом.

Також зверніть увагу: не всі бази даних підтримують функції вікна; вам потрібен Postgresql, Oracle або SQL Server. IMHO із використанням принаймні Postgresql однозначно варто - якщо ви використовуєте реляційну базу даних, ви можете скористатися найкращим.

Я не фахівець з баз даних, але коли використовую SQLAlchemy як простий рівень абстракції Python (тобто, не використовуючи об'єкт ORM Query), я придумав задовільне рішення для запиту таблиці в 300 мільйонів без вибуху пам'яті ...

Ось фіктивний приклад:

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)

Потім я використовую fetchmany()метод SQLAlchemy для перебору результатів у нескінченному whileциклі:

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()

Цей метод дозволив мені робити всі види агрегування даних без будь-яких небезпечних витрат пам'яті.

NOTE stream_resultsроботи з Postgres і pyscopg2адаптером, але я припускаю , що це не буде працювати з будь-якої DBAPI, ні з яким - або драйвером бази даних ...

У цій публікації в блозі є цікавий варіант використання, який надихнув мій вищезазначений метод.

Я вивчав ефективний обхід / підкачку за допомогою SQLAlchemy і хотів би оновити цю відповідь.

Я думаю, ви можете використовувати виклик зрізу, щоб правильно обмежити обсяг запиту, і ви могли б ефективно використовувати його повторно.

Приклад:

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

У дусі відповіді Джоеля я використовую наступне:

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 - це погано, оскільки вам потрібно було раніше знайти всі стовпці {OFFSET}, тому чим більше значення OFFSET - тим довший запит ви отримуєте. Використання віконного запиту для мене також дає погані результати у великій таблиці з великим обсягом даних (ви чекаєте перших результатів занадто довго, що в моєму випадку це не добре для фрагментованої веб-відповіді).

Найкращий підхід, наведений тут https://stackoverflow.com/a/27169302/450103 . У моєму випадку я вирішив проблему, просто використовуючи індекс у полі datetime та отримуючи наступний запит із datetime> = previous_datetime. Дурний, тому що я раніше використовував цей індекс у різних випадках, але думав, що для отримання всіх віконних запитів даних було б краще. У моєму випадку я помилився.

AFAIK, перший варіант все ще отримує всі кортежі з таблиці (з одним запитом SQL), але створює презентацію ORM для кожної сутності під час ітерації. Отже, це ефективніше, ніж створення списку всіх сутностей перед ітерацією, але вам все одно доведеться отримати всі (необроблені) дані в пам’ять.

Таким чином, використання LIMIT на величезних столах для мене здається гарною ідеєю.