Inserção em massa com SQLAlchemy ORM

Existe alguma maneira de fazer com que o SQLAlchemy faça uma inserção em massa em vez de inserir cada objeto individual. ou seja,

fazendo:

INSERT INTO `foo` (`bar`) VALUES (1), (2), (3)

ao invés de:

INSERT INTO `foo` (`bar`) VALUES (1)
INSERT INTO `foo` (`bar`) VALUES (2)
INSERT INTO `foo` (`bar`) VALUES (3)

Acabei de converter um código para usar sqlalchemy em vez de raw sql e, embora agora seja muito mais agradável trabalhar com ele, parece mais lento agora (até um fator de 10), estou me perguntando se esse é o motivo.

Talvez eu possa melhorar a situação usando as sessões com mais eficiência. No momento eu tenho autoCommit=Falsee faço um session.commit()depois que eu adicionei algumas coisas. Embora isso pareça fazer com que os dados fiquem obsoletos se o banco de dados for alterado em outro lugar, como, mesmo que eu faça uma nova consulta, ainda recupero resultados antigos?

Obrigado pela ajuda!

SQLAlchemy introduziu isso na versão 1.0.0:

Operações em massa - SQLAlchemy docs

Com essas operações, agora você pode fazer inserções ou atualizações em massa!

Por exemplo, você pode fazer:

s = Session()
objects = [
    User(name="u1"),
    User(name="u2"),
    User(name="u3")
]
s.bulk_save_objects(objects)
s.commit()

Aqui, uma inserção em massa será feita.

Os documentos do sqlalchemy têm um resumo do desempenho de várias técnicas que podem ser usadas para inserções em massa:

Os ORMs não se destinam basicamente a pastilhas a granel de alto desempenho - esse é o motivo pelo qual o SQLAlchemy oferece o Core, além do ORM como um componente de primeira classe.

Para o caso de uso de inserções em massa rápidas, o sistema de geração e execução de SQL que o ORM constrói sobre ele faz parte do Core. Usando esse sistema diretamente, podemos produzir um INSERT que seja competitivo com o uso direto da API do banco de dados bruto.

Como alternativa, o SQLAlchemy ORM oferece o conjunto de métodos Bulk Operations, que fornece ganchos nas subseções do processo da unidade de trabalho para emitir construções INSERT e UPDATE no nível do núcleo com um pequeno grau de automação baseada em ORM.

O exemplo abaixo ilustra testes baseados em tempo para vários métodos diferentes de inserção de linhas, passando do mais automatizado para o menos. Com o cPython 2.7, os tempos de execução observados:

classics-MacBook-Pro:sqlalchemy classic$ python test.py
SQLAlchemy ORM: Total time for 100000 records 12.0471920967 secs
SQLAlchemy ORM pk given: Total time for 100000 records 7.06283402443 secs
SQLAlchemy ORM bulk_save_objects(): Total time for 100000 records 0.856323003769 secs
SQLAlchemy Core: Total time for 100000 records 0.485800027847 secs
sqlite3: Total time for 100000 records 0.487842082977 sec

Roteiro:

import time
import sqlite3

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,  create_engine
from sqlalchemy.orm import scoped_session, sessionmaker

Base = declarative_base()
DBSession = scoped_session(sessionmaker())
engine = None


class Customer(Base):
    __tablename__ = "customer"
    id = Column(Integer, primary_key=True)
    name = Column(String(255))


def init_sqlalchemy(dbname='sqlite:///sqlalchemy.db'):
    global engine
    engine = create_engine(dbname, echo=False)
    DBSession.remove()
    DBSession.configure(bind=engine, autoflush=False, expire_on_commit=False)
    Base.metadata.drop_all(engine)
    Base.metadata.create_all(engine)


def test_sqlalchemy_orm(n=100000):
    init_sqlalchemy()
    t0 = time.time()
    for i in xrange(n):
        customer = Customer()
        customer.name = 'NAME ' + str(i)
        DBSession.add(customer)
        if i % 1000 == 0:
            DBSession.flush()
    DBSession.commit()
    print(
        "SQLAlchemy ORM: Total time for " + str(n) +
        " records " + str(time.time() - t0) + " secs")


def test_sqlalchemy_orm_pk_given(n=100000):
    init_sqlalchemy()
    t0 = time.time()
    for i in xrange(n):
        customer = Customer(id=i+1, name="NAME " + str(i))
        DBSession.add(customer)
        if i % 1000 == 0:
            DBSession.flush()
    DBSession.commit()
    print(
        "SQLAlchemy ORM pk given: Total time for " + str(n) +
        " records " + str(time.time() - t0) + " secs")


def test_sqlalchemy_orm_bulk_insert(n=100000):
    init_sqlalchemy()
    t0 = time.time()
    n1 = n
    while n1 > 0:
        n1 = n1 - 10000
        DBSession.bulk_insert_mappings(
            Customer,
            [
                dict(name="NAME " + str(i))
                for i in xrange(min(10000, n1))
            ]
        )
    DBSession.commit()
    print(
        "SQLAlchemy ORM bulk_save_objects(): Total time for " + str(n) +
        " records " + str(time.time() - t0) + " secs")


def test_sqlalchemy_core(n=100000):
    init_sqlalchemy()
    t0 = time.time()
    engine.execute(
        Customer.__table__.insert(),
        [{"name": 'NAME ' + str(i)} for i in xrange(n)]
    )
    print(
        "SQLAlchemy Core: Total time for " + str(n) +
        " records " + str(time.time() - t0) + " secs")


def init_sqlite3(dbname):
    conn = sqlite3.connect(dbname)
    c = conn.cursor()
    c.execute("DROP TABLE IF EXISTS customer")
    c.execute(
        "CREATE TABLE customer (id INTEGER NOT NULL, "
        "name VARCHAR(255), PRIMARY KEY(id))")
    conn.commit()
    return conn


def test_sqlite3(n=100000, dbname='sqlite3.db'):
    conn = init_sqlite3(dbname)
    c = conn.cursor()
    t0 = time.time()
    for i in xrange(n):
        row = ('NAME ' + str(i),)
        c.execute("INSERT INTO customer (name) VALUES (?)", row)
    conn.commit()
    print(
        "sqlite3: Total time for " + str(n) +
        " records " + str(time.time() - t0) + " sec")

if __name__ == '__main__':
    test_sqlalchemy_orm(100000)
    test_sqlalchemy_orm_pk_given(100000)
    test_sqlalchemy_orm_bulk_insert(100000)
    test_sqlalchemy_core(100000)
    test_sqlite3(100000)

Até onde eu sei, não há como fazer com que o ORM emita inserções em massa. Acredito que a razão subjacente é que o SQLAlchemy precisa acompanhar a identidade de cada objeto (ou seja, novas chaves primárias), e inserções em massa interferem nisso. Por exemplo, supondo que sua footabela contenha uma idcoluna e seja mapeada para uma Fooclasse:

x = Foo(bar=1)
print x.id
# None
session.add(x)
session.flush()
# BEGIN
# INSERT INTO foo (bar) VALUES(1)
# COMMIT
print x.id
# 1

Como o SQLAlchemy selecionou o valor x.idsem emitir outra consulta, podemos inferir que ele obteve o valor diretamente da INSERTinstrução Se você não precisar de acesso subseqüente aos objetos criados pelas mesmas instâncias, poderá pular a camada ORM da sua inserção:

Foo.__table__.insert().execute([{'bar': 1}, {'bar': 2}, {'bar': 3}])
# INSERT INTO foo (bar) VALUES ((1,), (2,), (3,))

O SQLAlchemy não pode corresponder essas novas linhas a nenhum objeto existente; portanto, você precisará consultá-las novamente para operações subsequentes.

No que diz respeito aos dados obsoletos, é útil lembrar que a sessão não possui uma maneira integrada de saber quando o banco de dados é alterado fora da sessão. Para acessar dados modificados externamente através de instâncias existentes, as instâncias devem ser marcadas como expiradas . Isso acontece por padrão session.commit(), mas pode ser feito manualmente chamando session.expire_all()ou session.expire(instance). Um exemplo (SQL omitido):

x = Foo(bar=1)
session.add(x)
session.commit()
print x.bar
# 1
foo.update().execute(bar=42)
print x.bar
# 1
session.expire(x)
print x.bar
# 42

session.commit()expira x, então a primeira instrução de impressão abre implicitamente uma nova transação e consulta novamente os xatributos. Se você comentar a primeira declaração de impressão, notará que a segunda agora seleciona o valor correto, porque a nova consulta não é emitida até depois da atualização.

Isso faz sentido do ponto de vista do isolamento transacional - você só deve captar modificações externas entre transações. Se isso estiver causando problemas, sugiro que você esclareça ou repense os limites de transação do aplicativo em vez de procurar imediatamente session.expire_all().

Eu costumo fazer isso usando add_all.

from app import session
from models import User

objects = [User(name="u1"), User(name="u2"), User(name="u3")]
session.add_all(objects)
session.commit()

Suporte direto foi adicionado ao SQLAlchemy a partir da versão 0.8

De acordo com os documentos , connection.execute(table.insert().values(data))deve fazer o truque. (Observe que isso não é o mesmo connection.execute(table.insert(), data)que resulta em muitas inserções de linha individuais por meio de uma chamada para executemany). Em qualquer coisa, exceto em uma conexão local, a diferença de desempenho pode ser enorme.

SQLAlchemy introduziu isso na versão 1.0.0:

Operações em massa - SQLAlchemy docs

Com essas operações, agora você pode fazer inserções ou atualizações em massa!

Por exemplo (se você deseja a menor sobrecarga para INSERTs de tabela simples), pode usar Session.bulk_insert_mappings():

loadme = [(1, 'a'),
          (2, 'b'),
          (3, 'c')]
dicts = [dict(bar=t[0], fly=t[1]) for t in loadme]

s = Session()
s.bulk_insert_mappings(Foo, dicts)
s.commit()

Ou, se desejar, pule as loadmetuplas e escreva os dicionários diretamente dicts(mas acho mais fácil deixar toda a wordiness fora dos dados e carregar uma lista de dicionários em um loop).

A resposta de Piere está correta, mas um problema é que, bulk_save_objectspor padrão, não retorna as chaves primárias dos objetos, se isso lhe interessa. Defina return_defaultscomo Truepara obter esse comportamento.

A documentação está aqui .

foos = [Foo(bar='a',), Foo(bar='b'), Foo(bar='c')]
session.bulk_save_objects(foos, return_defaults=True)
for foo in foos:
    assert foo.id is not None
session.commit()

Todas as estradas levam a Roma , mas algumas atravessam montanhas, exigem balsas, mas se você quiser chegar rapidamente, pegue a rodovia.

Nesse caso, a auto-estrada deve usar o recurso execute_batch () do psycopg2 . A documentação diz o melhor:

A implementação atual de executemany()(usando um eufemismo extremamente caridoso) não está sendo executada particularmente. Essas funções podem ser usadas para acelerar a execução repetida de uma instrução contra um conjunto de parâmetros. Ao reduzir o número de viagens de ida e volta ao servidor, o desempenho pode ser uma ordem de magnitude melhor que o uso executemany().

Em meu próprio teste execute_batch()é aproximadamente duas vezes mais rápido como executemany(), e dá a opção de configurar o page_size para mais ajustes (se você quiser espremer a última 2-3% do desempenho fora do motorista).

O mesmo recurso pode ser facilmente ativado se você estiver usando SQLAlchemy, configurando use_batch_mode=Truecomo um parâmetro ao instanciar o mecanismo comcreate_engine()

Esta é uma maneira:

values = [1, 2, 3]
Foo.__table__.insert().execute([{'bar': x} for x in values])

Isso será inserido assim:

INSERT INTO `foo` (`bar`) VALUES (1), (2), (3)

Referência: as perguntas frequentes do SQLAlchemy incluem referências para vários métodos de confirmação.

A melhor resposta que encontrei até agora foi na documentação do sqlalchemy:

http://docs.sqlalchemy.org/en/latest/faq/performance.html#im-inserting-400-000-rows-with-the-orm-and-it-s-really-slow

Há um exemplo completo de uma referência de possíveis soluções.

Como mostrado na documentação:

bulk_save_objects não é a melhor solução, mas seu desempenho está correto.

A segunda melhor implementação em termos de legibilidade, acho que foi com o SQLAlchemy Core:

def test_sqlalchemy_core(n=100000):
    init_sqlalchemy()
    t0 = time.time()
    engine.execute(
        Customer.__table__.insert(),
            [{"name": 'NAME ' + str(i)} for i in xrange(n)]
    )

O contexto dessa função é fornecido no artigo de documentação.