Question

我目前正在使用SQLAlchemy编写一个Web应用程序（Flask）（在GAE上，连接到Google的云MySQL），并且需要对表进行批量更新。简而言之，进行了许多计算，导致需要在1000个对象上更新单个值。目前我在一个交易中完成所有操作，但最后，刷新/提交需要很长时间。

该表在id上有一个索引，这都是在一个事务中执行的。所以我相信我已经避免了常见的错误，但仍然很慢。

INFO     2017-01-26 00:45:46,412 log.py:109] UPDATE wallet SET balance=%(balance)s WHERE wallet.id = %(wallet_id)s
2017-01-26 00:45:46,418 INFO sqlalchemy.engine.base.Engine ({'wallet_id': u'3c291a05-e2ed-11e6-9b55-19626d8c7624', 'balance': 1.8711760000000002}, {'wallet_id': u'3c352035-e2ed-11e6-a64c-19626d8c7624', 'balance': 1.5875759999999999}, {'wallet_id': u'3c52c047-e2ed-11e6-a903-19626d8c7624', 'balance': 1.441656}

根据我的理解，实际上没有办法在SQL中进行批量更新，上面的语句最终会被发送到服务器的多个UPDATE语句。

我尝试使用Session.bulk_update_mappings()，但似乎并没有真正做任何事情:(不确定原因，但更新从未真正发生。我无法看到任何示例实际使用此方法（包括在性能套件中），因此不确定是否打算使用它。

One technique I've seen discussed正在对另一个表进行批量插入，然后执行UPDATE JOIN。我给它做了一个测试，如下所示，它似乎要快得多。

wallets = db_session.query(Wallet).all()
ledgers = [ Ledger(id=w.id, amount=w._balance) for w in wallets ]
db_session.bulk_save_objects(ledgers)
db_session.execute('UPDATE wallet w JOIN ledger l on w.id = l.id SET w.balance = l.amount')
db_session.execute('TRUNCATE ledger')

但现在的问题是如何构建我的代码。我正在使用ORM，我需要以某种方式不要“弄脏”＃39;原始的Wallet个对象，以便他们不会以旧方式提交。我可以创建这些Ledger对象并保留它们的列表，然后在批量操作结束时手动插入它们。但这几乎闻起来像是我复制了ORM机制的一些工作。

有更聪明的方法吗？到目前为止，我的大脑正在下降：

class Wallet(Base):
    ...
    _balance = Column(Float)
    ...

@property
def balance(self):
    # first check if we have a ledger of the same id
    # and return the amount in that, otherwise...
    return self._balance

@balance.setter
def balance(self, amount):
    l = Ledger(id=self.id, amount=amount)
    # add l to a list somewhere then process later

# At the end of the transaction, do a bulk insert of Ledgers
# and then do an UPDATE JOIN and TRUNCATE

正如我所说，这一切似乎都在与我（可能）拥有的工具作斗争。有没有更好的方法来处理这个？我可以利用ORM机制来做这件事吗？或者是否有更好的方法来进行批量更新？

编辑：或者有什么事情和会议能够巧妙吗？也许before_flush？

编辑2：所以我试图利用事件机制，现在有了这个：

@event.listens_for(SignallingSession, 'before_flush')
def before_flush(session, flush_context, instances):
    ledgers = []

    if session.dirty:
        for elem in session.dirty:
            if ( session.is_modified(elem, include_collections=False) ):
                if isinstance(elem, Wallet):
                    session.expunge(elem)
                    ledgers.append(Ledger(id=elem.id, amount=elem.balance))

    if ledgers:
        session.bulk_save_objects(ledgers)
        session.execute('UPDATE wallet w JOIN ledger l on w.id = l.id SET w.balance = l.amount')
        session.execute('TRUNCATE ledger')

这对我来说似乎很邪恶和邪恶，但似乎工作正常。任何陷阱，或更好的方法？

-Matt

Answer 1

您实际上正在做的是绕过ORM以优化性能。因此，不要惊讶于你“复制ORM正在做的工作”，因为这正是你需要做的。

除非你有很多地方需要像这样进行批量更新，否则我建议不要采用神奇的事件方法;简单地编写显式查询就更简单了。

我建议使用SQLAlchemy Core而不是ORM来进行更新：

ledger = Table("ledger", db.metadata,
    Column("wallet_id", Integer, primary_key=True),
    Column("new_balance", Float),
    prefixes=["TEMPORARY"],
)


wallets = db_session.query(Wallet).all()

# figure out new balances
balance_map = {}
for w in wallets:
    balance_map[w.id] = calculate_new_balance(w)

# create temp table with balances we need to update
ledger.create(bind=db.session.get_bind())

# insert update data
db.session.execute(ledger.insert().values([{"wallet_id": k, "new_balance": v}
                                           for k, v in balance_map.items()])

# perform update
db.session.execute(Wallet.__table__
                         .update()
                         .values(balance=ledger.c.new_balance)
                         .where(Wallet.__table__.c.id == ledger.c.wallet_id))

# drop temp table
ledger.drop(bind=db.session.get_bind())

# commit changes
db.session.commit()

Answer 2

通常，需要频繁更新数千行的架构设计很差。除此之外......

计划A：编写生成

的ORM代码

START TRANSACTION;
UPDATE wallet SET balance = ... WHERE id = ...;
UPDATE wallet SET balance = ... WHERE id = ...;
UPDATE wallet SET balance = ... WHERE id = ...;
...
COMMIT;

计划B：编写生成

的ORM代码

CREATE TEMPORARY TABLE ToDo (
    id ...,
    new_balance ...
);
INSERT INTO ToDo -- either one row at a time, or a bulk insert
UPDATE wallet
    JOIN ToDo USING(id)
    SET wallet.balance = ToDo.new_balance;  -- bulk update

（检查语法;测试;等等）

SQLAlchemy批量更新策略

2 个答案: