память-эффективный встроенный итератор/генератор SqlAlchemy?

Я изучал эффективный обход / подкачку с помощью SQLAlchemy и хотел бы обновить этот ответ.

Я думаю, что вы можете использовать вызов slice, чтобы правильно ограничить область запроса, и вы можете эффективно использовать его.

пример:

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 things is None:
            break
        for thing in things:
            yield(thing)
        start += WINDOW_SIZE

AFAIK, первый вариант по-прежнему получает все кортежи из таблицы (с одним SQL-запросом), но строит представление ORM для каждой сущности при итерации. Таким образом, это более эффективно, чем создание списка всех сущностей перед итерацией, но вам все равно нужно извлечь все (необработанные) данные в память.

таким образом, использование LIMIT на огромных столах звучит как хорошая идея для меня.

использование LIMIT / OFFSET плохо, потому что вам нужно найти все столбцы {OFFSET} раньше, поэтому чем больше смещение - тем больше запрос вы получаете. Использование оконного запроса для меня также дает плохие результаты на большой таблице с большим количеством данных (вы слишком долго ждете первых результатов, что в моем случае не очень хорошо для фрагментированного веб-ответа).

лучший подход, приведенный здесь https://stackoverflow.com/a/27169302/450103. в моем случае я решил проблему просто с помощью индекса на datetime поле и выборка следующего запроса с datetime>=previous_datetime. Глупо, потому что я использовал этот индекс в разных случаях раньше, но думал, что для извлечения всех данных оконный запрос будет лучше. В моем случае я ошибался.

Я не эксперт по базам данных, но при использовании SQLAlchemy в качестве простого слоя абстракции Python (т. е. не используя объект запроса ORM) я придумал удовлетворительное решение для запроса таблицы 300M-row без использования взрывной памяти...

вот фиктивный пример:

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)

тогда я использую SQLAlchemy fetchmany() метод для итерации по результатам в while петли:

empty = False
while not empty:
    batch = proxy.fetchmany(100000)  # 100,000 rows at a time

    if batch == []:
        empty = True

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

proxy.close()

этот метод позволил мне сделать все виды агрегации данных без каких-либо опасные память.

NOTEthe stream_results работает с Postgres и pyscopg2 адаптер, но я думаю, что он не будет работать ни с DBAPI, ни с любым драйвером базы данных...

есть интересный usecase в этом блоге это вдохновило меня выше метод.