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：
これらの操作により、一括挿入または一括更新を実行できるようになりました！
たとえば、次のことができます。
s = Session()
objects = [
User(name="u1"),
User(name="u2"),
User(name="u3")
]
s.bulk_save_objects(objects)
s.commit()
ここで、一括挿入が行われます。
私の知る限り、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ステートメントから直接値を取得したと推測できます。 sameインスタンスを使用して、作成されたオブジェクトに後でアクセスする必要がない場合は、挿入のためにORMレイヤーをスキップできます。
_Foo.__table__.insert().execute([{'bar': 1}, {'bar': 2}, {'bar': 3}])
# INSERT INTO foo (bar) VALUES ((1,), (2,), (3,))
_SQLAlchemyは、これらの新しい行を既存のオブジェクトと一致させることはできません。したがって、後続の操作のためにそれらを新たにクエリする必要があります。
古いデータに関する限り、セッション外にデータベースが変更されたときを知るための組み込みの方法がセッションにないことを覚えておくと役立ちます。既存のインスタンスを介して外部で変更されたデータにアクセスするには、インスタンスにexpiredのマークを付ける必要があります。これは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の属性を再クエリします。最初のprintステートメントをコメントアウトすると、新しいクエリは更新後まで発行されないため、2番目のステートメントが正しい値を取得することに気付くでしょう。
これは、トランザクション分離の観点から理にかなっています-トランザクション間の外部変更のみをピックアップする必要があります。これが問題を引き起こしている場合、すぐにsession.expire_all()に到達するのではなく、アプリケーションのトランザクション境界を明確にするか、再考することをお勧めします。
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): __table= "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 __== '__main__': test_sqlalchemy_orm(100000) test_sqlalchemy_orm_pk_given(100000) test_sqlalchemy_orm_bulk_insert(100000) test_sqlalchemy_core(100000) test_sqlite3(100000)
私は通常 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に直接サポートが追加されました。
docs に従って、connection.execute(table.insert().values(data))がトリックを行う必要があります。 （これはnotではないことに注意してくださいconnection.execute(table.insert(), data)と同じです。これにより、executemanyへの呼び出しを介して多くの個別の行が挿入されます。 ）。ローカル接続以外では、パフォーマンスの違いは非常に大きくなる可能性があります。
SQLAlchemyはバージョン_1.0.0_でそれを導入しました：
これらの操作により、一括挿入または一括更新を実行できるようになりました！
たとえば（単純なテーブルINSERTで最小のオーバーヘッドが必要な場合）、 Session.bulk_insert_mappings() を使用できます。
_loadme = [
(1, 'a')
, (2, 'b')
, (3, 'c')
]
dicts = []
for i in range(len(loadme)):
dicts.append(dict(bar=loadme[i][0], fly=loadme[i][1]))
s = Session()
s.bulk_insert_mappings(Foo, dicts)
s.commit()
_または、必要に応じて、loadmeタプルをスキップし、辞書をdictsに直接書き込みます（ただし、データからすべての冗長性を残し、辞書のリストをロードする方が簡単ですループ）。
Piereの答えは正しいが、1つの問題はbulk_save_objectsは、デフォルトではオブジェクトの主キーを返します（それが懸念される場合）。セットする return_defaultsをTrueに変更して、この動作を取得します。
ドキュメントは here です。
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()
これは方法です：
values = [1, 2, 3]
Foo.__table__.insert().execute([{'bar': x} for x in values])
これにより、次のように挿入されます。
INSERT INTO `foo` (`bar`) VALUES (1), (2), (3)
参照：SQLAlchemy [〜＃〜] faq [〜＃〜] には、さまざまなコミットメソッドのベンチマークが含まれています。
すべての道路はローマに通じていますが、それらの一部は山を越えており、フェリーが必要ですが、すぐに行きたい場合は高速道路を利用してください。
この場合、高速道路は psycuteg2 の execute_batch（） 機能を使用します。ドキュメンテーションはそれを最高と言っています：
executemany()の現在の実装は（非常に慈善的な控えめな表現を使用して）特に実行されていません。これらの関数を使用して、一連のパラメーターに対するステートメントの繰り返し実行を高速化できます。サーバーの往復回数を減らすことで、パフォーマンスはexecutemany()を使用するよりも桁違いに良くなります。
私のテストでは、execute_batch()はexecutemany()の約2倍の速さであり、さらに微調整するためのpage_size（ドライバーのパフォーマンスの最後の2〜3％を絞り出す場合）。
create_engine()を使用してエンジンをインスタンス化するときにパラメーターとしてuse_batch_mode=Trueを設定することにより、SQLAlchemyを使用している場合、同じ機能を簡単に有効にできます。
私がこれまでに見つけた最良の答えは、sqlalchemyのドキュメントにありました。
可能なソリューションのベンチマークの完全な例があります。
ドキュメントに示されているように：
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)]
)
この関数のコンテキストは、ドキュメントの記事に記載されています。