Question

我正在编写一个Django应用程序，我需要一个函数来更新数据库中的字段。有没有理由做其中一种方法而不是另一种？

def save_db_field(name,field,value):
    obj = MyModel.objects.get(name=name)
    obj.field = value
    obj.save()

def update_db_field(name,field,value):
    MyModel.objects.get(name=name).update(field=value)

似乎第二个更好，因为它在一次数据库调用而不是两次调用中执行。是否有理由提取，然后更新更好？

Answer 1

有几个关键的区别。

update用于查询集，因此可以一次更新多个对象。

正如@FallenAngel所指出的那样，自定义save()方法触发的方式存在差异，但请务必牢记signals和ModelManagers。我已经构建了一个小测试应用程序，以显示一些有价值的差异。我使用的是Python 2.7.5，Django == 1.7.7和SQLite，请注意最终的SQL在不同版本的Django和不同的数据库引擎上可能会有所不同。

好的，这是示例代码。

models.py：

from __future__ import print_function
from django.db import models
from django.db.models import signals
from django.db.models.signals import pre_save, post_save
from django.dispatch import receiver

__author__ = 'sobolevn'

class CustomManager(models.Manager):
    def get_queryset(self):
        super_query = super(models.Manager, self).get_queryset()
        print('Manager is called', super_query)
        return super_query


class ExtraObject(models.Model):
    name = models.CharField(max_length=30)

    def __unicode__(self):
        return self.name


class TestModel(models.Model):

    name = models.CharField(max_length=30)
    key = models.ForeignKey('ExtraObject')
    many = models.ManyToManyField('ExtraObject', related_name='extras')

    objects = CustomManager()

    def save(self, *args, **kwargs):
        print('save() is called.')
        super(TestModel, self).save(*args, **kwargs)

    def __unicode__(self):
        # Never do such things (access by foreing key) in real life,
        # because it hits the database.
        return u'{} {} {}'.format(self.name, self.key.name, self.many.count())


@receiver(pre_save, sender=TestModel)
@receiver(post_save, sender=TestModel)
def reicever(*args, **kwargs):
    print('signal dispatched')

views.py：

def index(request):
    if request and request.method == 'GET':

        from models import ExtraObject, TestModel

        # Create exmple data if table is empty:
        if TestModel.objects.count() == 0:
            for i in range(15):
                extra = ExtraObject.objects.create(name=str(i))
                test = TestModel.objects.create(key=extra, name='test_%d' % i)
                test.many.add(test)
                print test

        to_edit = TestModel.objects.get(id=1)
        to_edit.name = 'edited_test'
        to_edit.key = ExtraObject.objects.create(name='new_for')
        to_edit.save()

        new_key = ExtraObject.objects.create(name='new_for_update')
        to_update = TestModel.objects.filter(id=2).update(name='updated_name', key=new_key)
        # return any kind of HttpResponse

在这些SQL查询中重新填充：

# to_edit = TestModel.objects.get(id=1):
QUERY = u'SELECT "main_testmodel"."id", "main_testmodel"."name", "main_testmodel"."key_id" 
FROM "main_testmodel" 
WHERE "main_testmodel"."id" = %s LIMIT 21' 
- PARAMS = (u'1',)

# to_edit.save():
QUERY = u'UPDATE "main_testmodel" SET "name" = %s, "key_id" = %s 
WHERE "main_testmodel"."id" = %s' 
- PARAMS = (u"'edited_test'", u'2', u'1')

# to_update = TestModel.objects.filter(id=2).update(name='updated_name', key=new_key):
QUERY = u'UPDATE "main_testmodel" SET "name" = %s, "key_id" = %s 
WHERE "main_testmodel"."id" = %s' 
- PARAMS = (u"'updated_name'", u'3', u'2')

我们只有update()的一个查询和save()的两个查询。

接下来，让我们谈谈覆盖save()方法。它显然只对save()方法调用一次。值得一提的是，.objects.create()也调用save()方法。

但update()并未在模型上调用save()。如果save()没有调用update()方法，那么信号也不会被触发。输出：

Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

# TestModel.objects.get(id=1):
Manager is called [<TestModel: edited_test new_for 0>]
Manager is called [<TestModel: edited_test new_for 0>]
save() is called.
signal dispatched
signal dispatched

# to_update = TestModel.objects.filter(id=2).update(name='updated_name', key=new_key):
Manager is called [<TestModel: edited_test new_for 0>]

您可以看到save()触发Manager的{{1}}两次。 get_queryset()只有一次。

分辨率。如果您需要“静默”更新您的值，而未调用update() - 请使用save()。用例：update用户的字段。当您需要正确更新模型时，请使用last_seen。

Answer 2

两者看起来相似，但有一些关键点：

save()将触发任何重写的Model.save()方法，但update()不会触发此方法并在数据库级别进行直接更新。因此，如果您的某些模型具有重写的保存方法，则必须避免使用更新或找到其他方法来执行您在重写的save()方法上执行的任何操作。
obj.save()可能会产生一些副作用。您使用get(...)检索对象，并将所有模型字段值传递给您的对象。当你调用obj.save()时，django会将当前对象状态保存到记录中。因此，如果某个其他进程在get()和save()之间发生了某些更改，那么这些更改将会丢失。使用save(update_fields=[.....])来避免此类问题。
在Django 1.5版之前，Django在SELECT / INSERT之前执行了UPDATE，因此需要执行2次查询。对于1.5版，不推荐使用该方法。

In here，有一个很好的指南或save()和update()方法以及它们的执行方式。

Answer 3

save（）方法可用于插入新记录和更新现有记录，通常用于保存数据库中单个记录（mysql中的行）的实例。

update（）不用于插入记录，可用于更新数据库中的多个记录（mysql中的行）。

Answer 4

更新仅适用于更新查询集。如果要同时更新多个字段，请从单个对象实例的dict中进行更新，您可以执行以下操作：

obj.__dict__.update(your_dict)
obj.save()

请记住，您的词典必须包含正确的映射，其中键需要是您的字段名称，以及您要插入的值的值。

Answer 5

使用多个对象的查询集，更新将为您提供更好的性能，因为它将为每个查询集进行一次数据库调用。

但是保存很有用，因为很容易覆盖模型中的save方法并在那里添加额外的逻辑。例如，在我自己的应用程序中，我更新其他字段更改时的日期。

Class myModel(models.Model): 
    name = models.CharField()
    date_created = models.DateField()

    def save(self):
        if not self.pk :
           ### we have a newly created object, as the db id is not set
           self.date_created = datetime.datetime.now()
        super(myModel , self).save()

Answer 6

直接使用更新更加有效，而且可以防止完整性问题。

摘自官方文档 https://docs.djangoproject.com/en/3.0/ref/models/querysets/#django.db.models.query.QuerySet.update

如果您只是更新记录，而无需执行任何操作模型对象，最有效的方法是调用update（），而不是将模型对象加载到内存中。例如，改为这样做：
e = Entry.objects.get(id=10)
e.comments_on = False
e.save()
…执行此操作：
Entry.objects.filter(id=10).update(comments_on=False)
使用update（）还可以防止出现竞争状况，在加载之间的短时间内更改数据库该对象并调用save（）。

Django：save（）vs update（）来更新数据库？

6 个答案: