Django 批处理/批量更新或创建？

Question

我在数据库中有需要定期更新的数据。 数据源返回当时可用的所有内容，因此将包括数据库中尚未包含的新数据。

当我遍历源数据时，如果可能的话，我不想进行 1000 次单独的写入。

是否有诸如update_or_create类的东西但可以批量工作？

一种想法是将update_or_create与手动事务结合使用，但我不确定这是否只是将单个写入排队，或者是否会将其全部组合到一个 SQL 插入中？

或者类似地可以在 function 上使用@commit_on_success()并在循环内使用update_or_create ？

除了翻译数据并将其保存到 model 之外，我没有对数据做任何事情。 没有任何东西依赖于循环期间存在的 model

Answer 1

由于 Django 添加了对 bulk_update 的支持，现在这在一定程度上是可能的，尽管您需要每批执行 3 次数据库调用（一次获取、一次批量创建和一次批量更新）。 在这里为通用 function 创建一个良好的接口有点挑战性，因为您希望 function 支持高效查询和更新。 这是我实现的一种方法，专为批量 update_or_create 设计，其中您有许多常见的识别键（可能为空）和一个在批次中变化的识别键。

这是作为基础 model 上的方法实现的，但可以独立使用。 这还假设基础 model 在名为updated_on的 model 上有一个auto_now时间戳； 如果不是这种情况，则假定此情况的代码行已被注释以便于修改。

为了批量使用它，在调用它之前将你的更新分批。 这也是一种绕过数据的方法，这些数据可以具有少量的辅助标识符值之一，而无需更改接口。

class BaseModel(models.Model):
    updated_on = models.DateTimeField(auto_now=True)
    
    @classmethod
    def bulk_update_or_create(cls, common_keys, unique_key_name, unique_key_to_defaults):
        """
        common_keys: {field_name: field_value}
        unique_key_name: field_name
        unique_key_to_defaults: {field_value: {field_name: field_value}}
        
        ex. Event.bulk_update_or_create(
            {"organization": organization}, "external_id", {1234: {"started": True}}
        )
        """
        with transaction.atomic():
            filter_kwargs = dict(common_keys)
            filter_kwargs[f"{unique_key_name}__in"] = unique_key_to_defaults.keys()
            existing_objs = {
                getattr(obj, unique_key_name): obj
                for obj in cls.objects.filter(**filter_kwargs).select_for_update()
            }
            
            create_data = {
                k: v for k, v in unique_key_to_defaults.items() if k not in existing_objs
            }
            for unique_key_value, obj in create_data.items():
                obj[unique_key_name] = unique_key_value
                obj.update(common_keys)
            creates = [cls(**obj_data) for obj_data in create_data.values()]
            if creates:
                cls.objects.bulk_create(creates)

            # This set should contain the name of the `auto_now` field of the model
            update_fields = {"updated_on"}
            updates = []
            for key, obj in existing_objs.items():
                obj.update(unique_key_to_defaults[key], save=False)
                update_fields.update(unique_key_to_defaults[key].keys())
                updates.append(obj)
            if existing_objs:
                cls.objects.bulk_update(updates, update_fields)
        return len(creates), len(updates)

    def update(self, update_dict=None, save=True, **kwargs):
        """ Helper method to update objects """
        if not update_dict:
            update_dict = kwargs
        # This set should contain the name of the `auto_now` field of the model
        update_fields = {"updated_on"}
        for k, v in update_dict.items():
            setattr(self, k, v)
            update_fields.add(k)
        if save:
            self.save(update_fields=update_fields)

示例用法：

class Event(BaseModel):
    organization = models.ForeignKey(Organization)
    external_id = models.IntegerField(unique=True)
    started = models.BooleanField()


organization = Organization.objects.get(...)
updates_by_external_id = {
    1234: {"started": True},
    2345: {"started": True},
    3456: {"started": False},
}
Event.bulk_update_or_create(
    {"organization": organization}, "external_id", updates_by_external_id
)

可能的比赛条件

上面的代码利用事务和 select-for-update 来防止更新的竞争条件。 但是，如果两个线程或进程试图创建具有相同标识符的对象，则插入可能存在竞争条件。

简单的缓解方法是确保您的 common_keys 和您的 unique_key 的组合是数据库强制唯一性约束（这是此函数的预期用途）。 这可以通过 unique_key 引用具有unique=True的字段，或者将 unique_key 与由UniqueConstraint强制为唯一的 common_keys 的子集组合来实现。 使用数据库强制的唯一性保护，如果多个线程试图执行冲突的创建，除了一个线程之外的所有线程都将失败并返回IntegrityError 。 由于封闭事务，失败的线程将不执行任何更改，并且可以安全地重试或忽略（失败的冲突创建可以被视为首先发生然后立即被覆盖的创建）。

如果无法利用唯一性约束，那么您将需要实现自己的并发控制或锁定整个表。

Answer 2

批量更新将是一个upsert命令，就像@imposeren所说，Postgres 9.5为你提供了这种能力。 我认为Mysql 5.7也可以（请参阅http://dev.mysql.com/doc/refman/5.7/en/insert-on-duplicate.html ），具体取决于您的具体需求。 这就是说使用db游标可能最容易。 这没有什么不对的，当ORM还不够的时候就存在。

这些方面的东西应该有效。 它是假的代码，所以不要只是剪切粘贴这个，但是概念就在那里。

class GroupByChunk(object):
    def __init__(self, size):
        self.count = 0
        self.size = size
        self.toggle = False

    def __call__(self, *args, **kwargs):
        if self.count >= self.size:  # Allows for size 0
            self.toggle = not self.toggle
            self.count = 0
        self.count += 1
        return self.toggle

def batch_update(db_results, upsert_sql):
    with transaction.atomic():
        cursor = connection.cursor()   
        for chunk in itertools.groupby(db_results, GroupByChunk(size=1000)):
            cursor.execute_many(upsert_sql, chunk)

这里的假设是：

• db_results是某种结果迭代器，可以是列表或字典
• db_results的结果可以直接输入到原始sql exec语句中
• 如果任何批量更新失败，您将回滚所有批次。 如果要将其移动到每个块，只需将with块向下推一下即可

Answer 3

Django的 django-bulk-update-or-create库可以做到这一点。

Answer 4

我一直在使用@Zags 答案，我认为这是最好的解决方案。 但我想就他的代码中的一个小问题提出建议。

        update_fields = {"updated_on"}
        updates = []
        for key, obj in existing_objs.items():
            obj.update(unique_key_to_defaults[key], save=False)
            update_fields.update(unique_key_to_defaults[key].keys())
            updates.append(obj)
        if existing_objs:
            cls.objects.bulk_update(updates, update_fields)

如果您使用 auto_now=True 字段，如果您使用.update() 或 bulk_update()，它们将不会被更新，这是因为字段“auto_now”使用 a.save() 触发，您可以在文档中阅读。

如果您有一个 auto_now 字段 Fe: updated_on，最好在 unique_key_to_defaults 字典中显式添加它。

"unique_value" : {
        "field1.." : value...,
        "updated_on" : timezone.now()
    }...