SQLAlchemy ORMによる一括挿入

個々のオブジェクトを挿入するのではなく、SQLAlchemyに一括挿入を実行させる方法はありますか？つまり、

行う：

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

のではなく：

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

生のSQLではなくsqlalchemyを使用するようにいくつかのコードを変換しました。これで作業するのがはるかに良くなりましたが、現在は遅くなっています（最大で10倍）。これが理由かどうか疑問に思います。

セッションをより効率的に使用して状況を改善できるかもしれません。現時点ではautoCommit=False、session.commit()いくつかの要素を追加した後、追加しています。新しいクエリを実行しても、DBが他の場所で変更されると、データが古くなるように見えますが、古い結果が返されますか？

ご協力いただきありがとうございます！

SQLAlchemyはそれをバージョンで導入しました1.0.0：

一括操作-SQLAlchemyドキュメント

これらの操作により、一括挿入または更新を実行できるようになりました。

たとえば、次のことができます。

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

ここでは、一括挿入が行われます。

SQLAlchemyのドキュメントを有するWRITEUPバルク挿入のために使用することができる様々な技術の性能にします。

ORMは基本的に高性能の一括挿入を目的としたものではありません。これが、SQLAlchemyがORMに加えてコアをファーストクラスのコンポーネントとして提供する理由です。

高速一括挿入の使用例では、ORMがその上に構築するSQL生成および実行システムはコアの一部です。このシステムを直接使用することで、生のデータベースAPIを直接使用することと競合するINSERTを生成できます。

あるいは、SQLAlchemy ORMは、一括操作スイートのメソッドを提供します。これは、ORMベースの自動化をわずかに使用してコアレベルのINSERTおよびUPDATE構造を発行するために、作業単位プロセスのサブセクションにフックを提供します。

以下の例は、行を挿入するいくつかの異なる方法の時間ベースのテストを示しています。cPython 2.7では、観察されたランタイム：

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

脚本：

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)

私の知る限り、ORMに一括挿入を発行させる方法はありません。根本的な理由は、SQLAlchemyが各オブジェクトのID（つまり、新しい主キー）を追跡する必要があり、一括挿入がそれを妨害するためだと思います。たとえば、fooテーブルにid列が含まれ、Fooクラスにマップされているとします。

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

SQLAlchemyはx.id別のクエリを発行せずに値を取得したため、INSERTステートメントから直接値を取得したと推測できます。同じインスタンスを介して作成されたオブジェクトに後でアクセスする必要がない場合は、挿入のORMレイヤーをスキップできます。

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

SQLAlchemyはこれらの新しい行を既存のオブジェクトと一致させることができないため、後続の操作のためにそれらを新たにクエリする必要があります。

古いデータに関する限り、セッションには、データベースがセッション外で変更された時期を知る方法が組み込まれていないことを覚えておくと役に立ちます。既存のインスタンスを介して外部で変更されたデータにアクセスするには、インスタンスに期限切れのマークを付ける必要があります。これはデフォルトではsession.commit()で発生しますが、session.expire_all()またはを呼び出すことで手動で実行できますsession.expire(instance)。例（SQLは省略）：

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()が期限切れxになるため、最初のprintステートメントは暗黙的に新しいトランザクションを開き、xの属性を再クエリします。最初の印刷ステートメントをコメントアウトすると、新しいクエリが更新されるまで発行されないため、2番目のステートメントが正しい値を取得するようになります。

これは、トランザクションの分離という観点からは理にかなっています。トランザクション間の外部の変更のみを取得する必要があります。これにより問題が発生する場合は、すぐにに到達するのではなく、アプリケーションのトランザクション境界を明確にするか、再考することをお勧めしますsession.expire_all()。

通常はを使用して行い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()

バージョン0.8以降、SQLAlchemyに直接サポートが追加されました

あたりとしてドキュメント、connection.execute(table.insert().values(data))トリックを行う必要があります。（これは、への呼び出しを介して多くの個々の行が挿入される結果と同じではないことに注意してください）。ローカル接続以外では、パフォーマンスの違いは非常に大きくなる可能性があります。connection.execute(table.insert(), data)executemany

SQLAlchemyはそれをバージョンで導入しました1.0.0：

一括操作-SQLAlchemyドキュメント

これらの操作により、一括挿入または更新を実行できるようになりました。

たとえば（単純なテーブルINSERTのオーバーヘッドを最小限にしたい場合）、次のように使用できます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()

または、必要に応じて、loadmeタプルをスキップして辞書に直接書き込みdictsます（ただし、データからすべての単語を除外して、ループ内の辞書のリストをロードする方が簡単です）。

Piereの答えは正しいですが、問題がある場合bulk_save_objects、デフォルトではオブジェクトの主キーが返されないという問題があります。に設定return_defaultsしTrueて、この動作を取得します。

ドキュメントはこちらです。

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

すべての道路はローマに通じていますが、一部は山を横切り、フェリーが必要ですが、そこにすばやく行きたい場合は高速道路を利用してください。

この場合、高速道路はpsycopg2のexecute_batch（）機能を使用します。ドキュメントはそれが最高だと言っています：

の現在の実装executemany()は、（非常に慈善的な控えめな表現を使用して）特に実行されていません。これらの関数を使用して、一連のパラメーターに対するステートメントの繰り返し実行を高速化できます。サーバーの往復回数を減らすことで、パフォーマンスはを使用するよりも桁違いに向上しexecutemany()ます。

私自身のテストでexecute_batch()は、の約2倍の速さでexecutemany()、さらに調整するためにpage_sizeを構成するオプションが提供されます（ドライバーからパフォーマンスの最後の2〜3％を絞りたい場合）。

SQLAlchemyを使用しuse_batch_mode=Trueている場合は、エンジンをインスタンス化するときにパラメーターとして設定することにより、同じ機能を簡単に有効にすることができます。create_engine()

これは方法です：

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

これは次のように挿入されます：

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

参照：SQLAlchemy FAQには、さまざまなcommitメソッドのベンチマークが含まれています。

これまでに見つけた最良の答えは、sqlalchemyのドキュメントにありました。

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

可能なソリューションのベンチマークの完全な例があります。

ドキュメントに示されているように：

bulk_save_objectsは最適なソリューションではありませんが、パフォーマンスは適切です。

読みやすさの点で2番目に優れた実装は、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)]
    )

この関数のコンテキストは、ドキュメントの記事に記載されています。