[Django]-Django: save() vs update() to update the database?

Both looks similar, but there are some key points:

1. save() will trigger any overridden Model.save() method, but update() will not trigger this and make a direct update on the database level. So if you have some models with overridden save methods, you must either avoid using update or find another way to do whatever you are doing on that overridden save() methods.

2. obj.save() may have some side effects if you are not careful. You retrieve the object with get(...) and all model field values are passed to your obj. When you call obj.save(), django will save the current object state to record. So if some changes happens between get() and save() by some other process, then those changes will be lost. use save(update_fields=[.....]) for avoiding such problems.

3. Before Django version 1.5, Django was executing a SELECT before INSERT/UPDATE, so it costs 2 query execution. With version 1.5, that method is deprecated.

In here, there is a good guide or save() and update() methods and how they are executed.

save() method can be used to insert new record and update existing record and generally used for saving instance of single record(row in mysql) in database.

update() is not used to insert records and can be used to update multiple records(rows in mysql) in database.

Using update directly is more efficient and could also prevent integrity problems.

From the official documentation https://docs.djangoproject.com/en/3.0/ref/models/querysets/#django.db.models.query.QuerySet.update

If you’re just updating a record and don’t need to do anything with
the model object, the most efficient approach is to call update(),
rather than loading the model object into memory. For example, instead
of doing this:

e = Entry.objects.get(id=10)
e.comments_on = False
e.save()

…do this:

Entry.objects.filter(id=10).update(comments_on=False)

Using update() also prevents a race condition wherein something might
change in your database in the short period of time between loading
the object and calling save().

Update only works on updating querysets. If you want to update multiple fields at the same time, say from a dict for a single object instance you can do something like:

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

Bear in mind that your dictionary will have to contain the correct mapping where the keys need to be your field names and the values the values you want to insert.

Update will give you better performance with a queryset of more than one object, as it will make one database call per queryset.

However save is useful, as it is easy to override the save method in your model and add extra logic there. In my own application for example, I update a dates when other fields are changed.

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()

save():

• can be used with model object but not with QuerySet or Manager objects.
• with select_for_update() can run SELECT FOR UPDATE query.

update()

• can be used with QuerySet or Manager objects but not with model object.
• with select_for_update() cannot run SELECT FOR UPDATE query.

For example, I have Person model as shown below:

# "store/models.py"

from django.db import models

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

    def __str__(self):
        return self.name

Then, you can use save() with Person model object as shown below:

# "store/views.py"

from .models import Person
from django.http import HttpResponse

def test(request):
    person = Person.objects.get(id=1)
    person.name = 'Tom'
    person.save() # Here

    return HttpResponse("Test")

# "store/views.py"

from .models import Person
from django.http import HttpResponse

def test(request):
    person = Person.objects.filter(pk=1).first()
    person.name = 'Tom'
    person.save() # Here

    return HttpResponse("Test")

But, you cannot use save() with QuerySet object as shown below:

# "store/views.py"

from .models import Person
from django.http import HttpResponse

def test(request):
    person = Person.objects.filter(pk=1)
    person.name = 'Tom'
    person.save() # Here

    return HttpResponse("Test")

Then, the error below occurs:

AttributeError: ‘QuerySet’ object has no attribute ‘save’

And, you cannot use save() with Manager object as shown below:

# "store/views.py"

from .models import Person
from django.http import HttpResponse

def test(request):
    person = Person.objects
    person.name = 'Tom'
    person.save() # Here

    return HttpResponse("Test")

Then, the error below occurs:

AttributeError: ‘Manager’ object has no attribute ‘save’

Then, you can use update() with QuerySet object as shown below:

# "store/views.py"

from .models import Person
from django.http import HttpResponse

def test(request):
    person = Person.objects.filter(pk=1)
    person.update(name="Tom") # Here

    return HttpResponse("Test")

And, you can use update() with Manager object as shown below:

# "store/views.py"

from .models import Person
from django.http import HttpResponse

def test(request):
    person = Person.objects
    person.update(name="Tom") # Here

    return HttpResponse("Test")

But, you cannot use update() with Person model object as shown below:

# "store/views.py"

from .models import Person
from django.http import HttpResponse

def test(request):
    person = Person.objects.get(id=1)
    person.update(name="Tom") # Here

    return HttpResponse("Test")

# "store/views.py"

from .models import Person
from django.http import HttpResponse

def test(request):
    person = Person.objects.filter(pk=1).first()    
    person.update(name="Tom") # Here

    return HttpResponse("Test")

Then, the error below occurs:

AttributeError: ‘Person’ object has no attribute ‘update’

Next for example, select_for_update() is used to prevent race condition(lost update or write skew) when updating data in Django.

And, I have test view with save() and select_for_update().filter(pk=1).first() as shown below:

# "store/views.py"

from django.db import transaction
from .models import Person
from django.http import HttpResponse

@transaction.atomic
def test(request):
    person = Person.objects.select_for_update().filter(pk=1).first() # Here
    person.name = 'Tom'
    person.save() # Here

    return HttpResponse("Test")

Then, when I run test view, SELECT FOR UPDATE and UPDATE queries are run as shown below. *I used PostgreSQL and these logs below are the query logs of PostgreSQL and you can check On PostgreSQL, how to log SQL queries with transaction queries such as "BEGIN" and "COMMIT":

Now, I remove first() to use update() as shown below:

# "store/views.py"

from django.db import transaction
from .models import Person
from django.http import HttpResponse

@transaction.atomic
def test(request):
    person = Person.objects.select_for_update().filter(pk=1) # Here
    person.update(name="Tom") # Here

    return HttpResponse("Test")

Then, when I run test view, SELECT FOR UPDATE query is not run and only UPDATE query is run as shown below:

And, I have test view with save() and select_for_update().get(pk=1) as shown below:

# "store/views.py"

from django.db import transaction
from .models import Person
from django.http import HttpResponse

@transaction.atomic
def test(request):
    person = Person.objects.select_for_update().get(pk=1) # Here
    person.name = 'Tom'
    person.save() # Here

    return HttpResponse("Test")

Then, when I run test view, SELECT FOR UPDATE and UPDATE queries are run as shown below:

Now, I remove get() to use update() as shown below:

# "store/views.py"

from django.db import transaction
from .models import Person
from django.http import HttpResponse

@transaction.atomic
def test(request):
    person = Person.objects.select_for_update() # Here
    person.update(name="Tom") # Here

    return HttpResponse("Test")

Then, when I run test view, SELECT FOR UPDATE query is not run and only UPDATE query is run as shown below:

So, save() with select_for_update() can run SELECT FOR UPDATE query while update() with select_for_update() cannot.

Use _state.adding to differentiate update from create https://docs.djangoproject.com/en/3.2/ref/models/instances/

def save(self, *args, **kwargs):
    # Check how the current values differ from ._loaded_values. For example,
    # prevent changing the creator_id of the model. (This example doesn't
    # support cases where 'creator_id' is deferred).
    if not self._state.adding and (
            self.creator_id != self._loaded_values['creator_id']):
        raise ValueError("Updating the value of creator isn't allowed")
    super().save(*args, **kwargs)

one of the differences that might cause a lot of headaches is that save updates, but update does NOT update columns of type DateTimeField(auto_now=True)
or ModificationDateTimeField
These fields automatically (should) set their date when an object is saved to the database.