แทรกจำนวนมากด้วย 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)

ฉันเพิ่งแปลงรหัสบางส่วนเพื่อใช้ sqlalchemy แทนที่จะเป็น raw sql และแม้ว่าตอนนี้จะทำงานได้ดีกว่ามาก แต่ดูเหมือนว่าจะช้าลงในตอนนี้ (มากถึง 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 มีการเขียนเกี่ยวกับประสิทธิภาพของเทคนิคต่างๆที่สามารถใช้สำหรับการแทรกจำนวนมาก:

โดยทั่วไปแล้ว ORM ไม่ได้มีไว้สำหรับการแทรกจำนวนมากที่มีประสิทธิภาพสูง - นี่คือเหตุผลทั้งหมดที่ SQLAlchemy เสนอ Core นอกเหนือจาก ORM เป็นส่วนประกอบชั้นหนึ่ง

สำหรับกรณีการใช้งานของการแทรกจำนวนมากอย่างรวดเร็วการสร้าง SQL และระบบการดำเนินการที่ ORM สร้างขึ้นด้านบนเป็นส่วนหนึ่งของ Core เมื่อใช้ระบบนี้โดยตรงเราสามารถสร้าง INSERT ที่แข่งขันได้โดยใช้ API ฐานข้อมูลดิบโดยตรง

หรืออีกวิธีหนึ่ง SQLAlchemy ORM นำเสนอชุดวิธีการดำเนินการจำนวนมากซึ่งจัดเตรียม hooks ไว้ในส่วนย่อยของหน่วยของกระบวนการทำงานเพื่อที่จะปล่อยโครงสร้าง INSERT และ UPDATE ระดับแกนกลางด้วยระบบอัตโนมัติแบบ ORM ในระดับเล็กน้อย

ตัวอย่างด้านล่างนี้แสดงให้เห็นถึงการทดสอบตามเวลาสำหรับวิธีการต่างๆในการแทรกแถวโดยเริ่มจากแบบอัตโนมัติที่สุดไปหาน้อยที่สุด ด้วย 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 จำเป็นต้องติดตามข้อมูลประจำตัวของแต่ละออบเจ็กต์ (เช่นคีย์หลักใหม่) และส่วนแทรกจำนวนมากเข้าไปยุ่งเกี่ยวกับสิ่งนั้น ตัวอย่างเช่นสมมติว่า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ดังนั้นคำสั่งการพิมพ์ครั้งแรกจะเปิดธุรกรรมใหม่โดยปริยายและxแอตทริบิวต์ของการสืบค้นใหม่ หากคุณแสดงความคิดเห็นในใบแจ้งยอดการพิมพ์ครั้งแรกคุณจะสังเกตเห็นว่าคำสั่งที่สองรับค่าที่ถูกต้องแล้วเนื่องจากแบบสอบถามใหม่จะไม่ถูกปล่อยออกมาจนกว่าจะมีการอัปเดต

สิ่งนี้สมเหตุสมผลจากมุมมองของการแยกธุรกรรม - คุณควรเลือกเฉพาะการแก้ไขภายนอกระหว่างธุรกรรมเท่านั้น 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()

เพิ่มการสนับสนุนโดยตรงใน SQLAlchemy ในเวอร์ชัน 0.8

ตามเอกสาร , connection.execute(table.insert().values(data))ควรทำเคล็ดลับ (โปรดทราบว่าสิ่งนี้ไม่เหมือนกับconnection.execute(table.insert(), data)ที่ส่งผลให้มีการแทรกแถวแต่ละแถวผ่านการเรียกไปยังexecutemany) ในทุกอย่างยกเว้นการเชื่อมต่อในพื้นที่ความแตกต่างของประสิทธิภาพอาจเป็นเรื่องใหญ่

SQLAlchemy เปิดตัวในเวอร์ชัน1.0.0:

การดำเนินการจำนวนมาก - เอกสาร SQLAlchemy

ด้วยการดำเนินการเหล่านี้คุณสามารถทำการแทรกหรืออัปเดตจำนวนมากได้แล้ว!

ตัวอย่างเช่น (หากคุณต้องการค่าโสหุ้ยต่ำสุดสำหรับการแทรกตารางธรรมดา) คุณสามารถใช้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()

หรือถ้าคุณต้องการให้ข้ามloadmetuples และเขียนพจนานุกรมลงในโดยตรง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()

ถนนทุกสายมุ่งสู่กรุงโรมแต่ถนนบางสายข้ามภูเขาต้องใช้เรือข้ามฟาก แต่ถ้าคุณต้องการไปที่นั่นอย่างรวดเร็วให้ใช้มอเตอร์เวย์

ในกรณีนี้มอเตอร์เวย์คือการใช้execute_batch ()คุณสมบัติของpsycopg2 เอกสารระบุว่าดีที่สุด:

การใช้งานปัจจุบันของ executemany()คือ (โดยใช้คำพูดที่เป็นกุศลอย่างยิ่ง) ไม่ได้ดำเนินการโดยเฉพาะ ฟังก์ชันเหล่านี้สามารถใช้เพื่อเร่งความเร็วในการดำเนินการคำสั่งซ้ำ ๆ กับชุดพารามิเตอร์ executemany()โดยการลดจำนวนถกเซิร์ฟเวอร์ประสิทธิภาพการทำงานที่สามารถเป็นคำสั่งของขนาดดีกว่าการใช้

ในการทดสอบของฉันเองexecute_batch()นั้นเร็วกว่าประมาณสองเท่า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 มีการวัดประสิทธิภาพสำหรับวิธีการคอมมิตต่างๆ

คำตอบที่ดีที่สุดที่ฉันพบคือในเอกสาร 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 ไม่ใช่วิธีแก้ปัญหาที่ดีที่สุด แต่ประสิทธิภาพถูกต้อง

การใช้งานที่ดีที่สุดอันดับสองในแง่ของความสามารถในการอ่านฉันคิดว่ามาพร้อมกับ 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)]
    )

บริบทของฟังก์ชันนี้มีให้ในบทความเอกสารประกอบ