Ticket #4102: update_fields_django-1.5-2.patch

File update_fields_django-1.5-2.patch, 16.7 KB (added by niwi, 3 years ago)
  • django/db/models/base.py

    diff --git a/django/db/models/base.py b/django/db/models/base.py
    index 7df4f6d..8bd49f1 100644
    a b import copy 
    22import sys
    33from functools import update_wrapper
    44from itertools import izip
     5from sets import ImmutableSet
    56
    67import django.db.models.manager     # Imported to register signal handler.
    78from django.conf import settings
    from django.core import validators 
    1112from django.db.models.fields import AutoField, FieldDoesNotExist
    1213from django.db.models.fields.related import (ManyToOneRel,
    1314    OneToOneField, add_lazy_relation)
    14 from django.db import (connections, router, transaction, DatabaseError,
     15from django.db import (router, transaction, DatabaseError,
    1516    DEFAULT_DB_ALIAS)
    1617from django.db.models.query import Q
    1718from django.db.models.query_utils import DeferredAttribute
    class Model(object): 
    449450            return getattr(self, field_name)
    450451        return getattr(self, field.attname)
    451452
    452     def save(self, force_insert=False, force_update=False, using=None):
     453    def save(self, force_insert=False, force_update=False, using=None, update_fields=None):
    453454        """
    454455        Saves the current instance. Override this in a subclass if you want to
    455456        control the saving process.
    class Model(object): 
    458459        that the "save" must be an SQL insert or update (or equivalent for
    459460        non-SQL backends), respectively. Normally, they should not be set.
    460461        """
    461         if force_insert and force_update:
     462        if force_insert and (force_update or update_fields):
    462463            raise ValueError("Cannot force both insert and updating in model saving.")
    463         self.save_base(using=using, force_insert=force_insert, force_update=force_update)
    464464
     465        if update_fields is not None:
     466            # If update_fields is empty, skip the save. We do also check for
     467            # no-op saves later on for inheritance cases. This bailout is
     468            # still needed for skipping signal sending.
     469            if len(update_fields) == 0:
     470                return
     471            update_fields = ImmutableSet(update_fields)
     472
     473            field_names = set(self._meta.get_all_field_names())
     474            not_model_fields = update_fields.difference(field_names)
     475            if not_model_fields:
     476                raise ValueError("The following fields do not exist in this model: %s"
     477                                 % ', '.join(not_model_fields))
     478
     479        self.save_base(using=using, force_insert=force_insert,
     480                       force_update=force_update, update_fields=update_fields)
    465481    save.alters_data = True
    466482
    467483    def save_base(self, raw=False, cls=None, origin=None, force_insert=False,
    468             force_update=False, using=None):
     484                  force_update=False, using=None, update_fields=None):
    469485        """
    470486        Does the heavy-lifting involved in saving. Subclasses shouldn't need to
    471487        override this method. It's separate from save() in order to hide the
    class Model(object): 
    473489        ('raw', 'cls', and 'origin').
    474490        """
    475491        using = using or router.db_for_write(self.__class__, instance=self)
    476         assert not (force_insert and force_update)
     492        assert not (force_insert and (force_update or update_fields))
     493        assert not update_fields or len(update_fields) > 0
    477494        if cls is None:
    478495            cls = self.__class__
    479496            meta = cls._meta
    class Model(object): 
    483500            meta = cls._meta
    484501
    485502        if origin and not meta.auto_created:
    486             signals.pre_save.send(sender=origin, instance=self, raw=raw, using=using)
     503            signals.pre_save.send(sender=origin, instance=self, raw=raw, using=using,
     504                                  update_fields=update_fields)
    487505
    488506        # If we are in a raw save, save the object exactly as presented.
    489507        # That means that we don't try to be smart about saving attributes
    class Model(object): 
    503521                if field and getattr(self, parent._meta.pk.attname) is None and getattr(self, field.attname) is not None:
    504522                    setattr(self, parent._meta.pk.attname, getattr(self, field.attname))
    505523
    506                 self.save_base(cls=parent, origin=org, using=using)
     524                self.save_base(cls=parent, origin=org, using=using, update_fields=update_fields)
    507525
    508526                if field:
    509527                    setattr(self, field.attname, self._get_pk_val(parent._meta))
    class Model(object): 
    513531        if not meta.proxy:
    514532            non_pks = [f for f in meta.local_fields if not f.primary_key]
    515533
     534            if update_fields:
     535                non_pks = [f for f in non_pks if f.name in update_fields]
     536
    516537            # First, try an UPDATE. If that doesn't update anything, do an INSERT.
    517538            pk_val = self._get_pk_val(meta)
    518539            pk_set = pk_val is not None
    class Model(object): 
    520541            manager = cls._base_manager
    521542            if pk_set:
    522543                # Determine whether a record with the primary key already exists.
    523                 if (force_update or (not force_insert and
     544                if ((force_update or update_fields) or (not force_insert and
    524545                        manager.using(using).filter(pk=pk_val).exists())):
    525546                    # It does already exist, so do an UPDATE.
    526547                    if force_update or non_pks:
    class Model(object): 
    529550                            rows = manager.using(using).filter(pk=pk_val)._update(values)
    530551                            if force_update and not rows:
    531552                                raise DatabaseError("Forced update did not affect any rows.")
     553                            if update_fields and not rows:
     554                                raise DatabaseError("Save with update_fields did not affect any rows.")
    532555                else:
    533556                    record_exists = False
    534557            if not pk_set or not record_exists:
    class Model(object): 
    541564
    542565                fields = meta.local_fields
    543566                if not pk_set:
    544                     if force_update:
     567                    if force_update or update_fields:
    545568                        raise ValueError("Cannot force an update in save() with no primary key.")
    546569                    fields = [f for f in fields if not isinstance(f, AutoField)]
    547570
    class Model(object): 
    561584
    562585        # Signal that the save is complete
    563586        if origin and not meta.auto_created:
    564             signals.post_save.send(sender=origin, instance=self,
    565                 created=(not record_exists), raw=raw, using=using)
     587            signals.post_save.send(sender=origin, instance=self, created=(not record_exists),
     588                                   update_fields=update_fields, raw=raw, using=using)
    566589
    567590
    568591    save_base.alters_data = True
  • django/db/models/signals.py

    diff --git a/django/db/models/signals.py b/django/db/models/signals.py
    index 48872e7..4666169 100644
    a b class_prepared = Signal(providing_args=["class"]) 
    55pre_init = Signal(providing_args=["instance", "args", "kwargs"])
    66post_init = Signal(providing_args=["instance"])
    77
    8 pre_save = Signal(providing_args=["instance", "raw", "using"])
    9 post_save = Signal(providing_args=["instance", "raw", "created", "using"])
     8pre_save = Signal(providing_args=["instance", "raw", "using", "update_fields"])
     9post_save = Signal(providing_args=["instance", "raw", "created", "using", "update_fields"])
    1010
    1111pre_delete = Signal(providing_args=["instance", "using"])
    1212post_delete = Signal(providing_args=["instance", "using"])
  • docs/ref/models/instances.txt

    diff --git a/docs/ref/models/instances.txt b/docs/ref/models/instances.txt
    index 3c84be5..c934977 100644
    a b Saving objects 
    135135
    136136To save an object back to the database, call ``save()``:
    137137
    138 .. method:: Model.save([force_insert=False, force_update=False, using=DEFAULT_DB_ALIAS])
     138.. method:: Model.save([force_insert=False, force_update=False, using=DEFAULT_DB_ALIAS, update_fields=None])
    139139
    140140.. versionadded:: 1.2
    141141   The ``using`` argument was added.
    For more details, see the documentation on :ref:`F() expressions 
    334334<query-expressions>` and their :ref:`use in update queries
    335335<topics-db-queries-update>`.
    336336
     337Specifying which fields to save
     338-------------------------------
     339
     340.. versionadded:: 1.5
     341
     342If ``save()`` is passed a list of field names as keyword argument
     343``update_fields``, only the fields named in that list will be saved to the
     344database. This may be desirable if you want to update just one or a few fields
     345on an object, as there will be a slight performance benefit from preventing
     346all of the model fields from being updated in the database. For example:
     347
     348    product.name = 'Name changed again'
     349    product.save(update_fields=['name'])
     350
     351
     352The ``update_fields`` argument can be any iterable containing strings. An
     353not None, but empty ``update_fields`` skips the save completely (no signals
     354sent). Specifying ``update_fields`` will force an update.
     355
    337356Deleting objects
    338357================
    339358
  • docs/ref/signals.txt

    diff --git a/docs/ref/signals.txt b/docs/ref/signals.txt
    index 3917b52..e047d17 100644
    a b Arguments sent with this signal: 
    123123``using``
    124124    The database alias being used.
    125125
     126``update_fields``
     127    List or tuple of fields to update explicitly specified in the ``save()`` method.
     128    ``None`` if you do not use this parameter when you call ``save()``.
     129
    126130post_save
    127131---------
    128132
    Arguments sent with this signal: 
    154158``using``
    155159    The database alias being used.
    156160
     161``update_fields``
     162    List or tuple of fields to update explicitly specified in the ``save()`` method.
     163    ``None`` if you do not use this parameter when you call ``save()``.
     164
    157165pre_delete
    158166----------
    159167
  • docs/releases/1.5.txt

    diff --git a/docs/releases/1.5.txt b/docs/releases/1.5.txt
    index 5a92e7d..82e13b9 100644
    a b Django 1.5 also includes several smaller improvements worth noting: 
    4444* :mod:`django.utils.timezone` provides a helper for converting aware
    4545  datetimes between time zones. See :func:`~django.utils.timezone.localtime`.
    4646
     47* :meth:`Model.save() <django.db.models.Model.save()>` has a new argument
     48  ``update_fields``. Using this argument allows restricting the set of fields
     49  to update when saving model instances.
     50
    4751Backwards incompatible changes in 1.5
    4852=====================================
    4953
  • new file tests/modeltests/update_only_fields/models.py

    diff --git a/tests/modeltests/update_only_fields/__init__.py b/tests/modeltests/update_only_fields/__init__.py
    new file mode 100644
    index 0000000..e69de29
    diff --git a/tests/modeltests/update_only_fields/models.py b/tests/modeltests/update_only_fields/models.py
    new file mode 100644
    index 0000000..7993ed3
    - +  
     1
     2from django.db import models
     3
     4GENDER_CHOICES = (
     5    ('M', 'Male'),
     6    ('F', 'Female'),
     7)
     8
     9class Person(models.Model):
     10    name = models.CharField(max_length=20)
     11    gender = models.CharField(max_length=1, choices=GENDER_CHOICES)
     12
     13    def __unicode__(self):
     14        return self.name
     15
     16class Employee(Person):
     17    employee_num = models.IntegerField(default=0)
     18    profile = models.ForeignKey('Profile', related_name='profiles', null=True)
     19
     20
     21class Profile(models.Model):
     22    name = models.CharField(max_length=200)
     23    salary = models.FloatField(default=1000.0)
     24
     25    def __unicode__(self):
     26        return self.name
     27
     28
     29class ProxyEmployee(Employee):
     30    class Meta:
     31        proxy = True
  • new file tests/modeltests/update_only_fields/tests.py

    diff --git a/tests/modeltests/update_only_fields/tests.py b/tests/modeltests/update_only_fields/tests.py
    new file mode 100644
    index 0000000..9d1258b
    - +  
     1from __future__ import absolute_import
     2
     3from django.test import TestCase
     4from django.db.models.signals import pre_save, post_save
     5from .models import Person, Employee, ProxyEmployee, Profile
     6
     7class UpdateOnlyFieldsTests(TestCase):
     8    def test_update_fields_basic(self):
     9        s = Person.objects.create(name='Sara', gender='F')
     10        self.assertEqual(s.gender, 'F')
     11
     12        s.gender = 'M'
     13        s.name = 'Ian'
     14        s.save(update_fields=['name'])
     15
     16        s = Person.objects.get(pk=s.pk)
     17        self.assertEqual(s.gender, 'F')
     18        self.assertEqual(s.name, 'Ian')
     19
     20    def test_update_fields_inheritance(self):
     21        profile_boss = Profile.objects.create(name='Boss', salary=3000)
     22        profile_receptionist = Profile.objects.create(name='Receptionist', salary=1000)
     23
     24        e1 = Employee.objects.create(name='Sara', gender='F',
     25            employee_num=1, profile=profile_boss)
     26
     27        e1.name = 'Ian'
     28        e1.gender = 'M'
     29        e1.save(update_fields=['name'])
     30
     31        e2 = Employee.objects.get(pk=e1.pk)
     32        self.assertEqual(e2.name, 'Ian')
     33        self.assertEqual(e2.gender, 'F')
     34        self.assertEqual(e2.profile, profile_boss)
     35
     36        e2.profile = profile_receptionist
     37        e2.name = 'Sara'
     38        e2.save(update_fields=['profile'])
     39
     40        e3 = Employee.objects.get(pk=e1.pk)
     41        self.assertEqual(e3.name, 'Ian')
     42        self.assertEqual(e3.profile, profile_receptionist)
     43
     44    def test_update_fields_inheritance_with_proxy_model(self):
     45        profile_boss = Profile.objects.create(name='Boss', salary=3000)
     46        profile_receptionist = Profile.objects.create(name='Receptionist', salary=1000)
     47
     48        e1 = ProxyEmployee.objects.create(name='Sara', gender='F',
     49            employee_num=1, profile=profile_boss)
     50
     51        e1.name = 'Ian'
     52        e1.gender = 'M'
     53        e1.save(update_fields=['name'])
     54
     55        e2 = ProxyEmployee.objects.get(pk=e1.pk)
     56        self.assertEqual(e2.name, 'Ian')
     57        self.assertEqual(e2.gender, 'F')
     58        self.assertEqual(e2.profile, profile_boss)
     59
     60        e2.profile = profile_receptionist
     61        e2.name = 'Sara'
     62        e2.save(update_fields=['profile'])
     63
     64        e3 = ProxyEmployee.objects.get(pk=e1.pk)
     65        self.assertEqual(e3.name, 'Ian')
     66        self.assertEqual(e3.profile, profile_receptionist)
     67
     68    def test_update_fields_signals(self):
     69        p = Person.objects.create(name='Sara', gender='F')
     70        pre_save_data = []
     71        def pre_save_receiver(**kwargs):
     72            pre_save_data.append(kwargs['update_fields'])
     73        pre_save.connect(pre_save_receiver)
     74        post_save_data = []
     75        def post_save_receiver(**kwargs):
     76            post_save_data.append(kwargs['update_fields'])
     77        post_save.connect(post_save_receiver)
     78        p.save(update_fields=['name'])
     79        self.assertEqual(len(pre_save_data), 1)
     80        self.assertEqual(len(pre_save_data[0]), 1)
     81        self.assertTrue('name' in pre_save_data[0])
     82        self.assertEqual(len(post_save_data), 1)
     83        self.assertEqual(len(post_save_data[0]), 1)
     84        self.assertTrue('name' in post_save_data[0])
     85
     86    def test_update_fields_incorrect_params(self):
     87        s = Person.objects.create(name='Sara', gender='F')
     88
     89        with self.assertRaises(ValueError):
     90            s.save(update_fields=['first_name'])
     91
     92        with self.assertRaises(ValueError):
     93            s.save(update_fields="name")
     94
     95    def test_empty_update_fields(self):
     96        s = Person.objects.create(name='Sara', gender='F')
     97        pre_save_data = []
     98        def pre_save_receiver(**kwargs):
     99            pre_save_data.append(kwargs['update_fields'])
     100        pre_save.connect(pre_save_receiver)
     101        post_save_data = []
     102        def post_save_receiver(**kwargs):
     103            post_save_data.append(kwargs['update_fields'])
     104        post_save.connect(post_save_receiver)
     105        # Save is skipped.
     106        with self.assertNumQueries(0):
     107            s.save(update_fields=[])
     108        # Signals were skipped, too...
     109        self.assertEqual(len(pre_save_data), 0)
     110        self.assertEqual(len(post_save_data), 0)
     111
     112    def test_num_queries_inheritance(self):
     113        s = Employee.objects.create(name='Sara', gender='F')
     114        s.employee_num = 1
     115        s.name = 'Emily'
     116        with self.assertNumQueries(1):
     117            s.save(update_fields=['employee_num'])
     118        s = Employee.objects.get(pk=s.pk)
     119        self.assertEqual(s.employee_num, 1)
     120        self.assertEqual(s.name, 'Sara')
     121        s.employee_num = 2
     122        s.name = 'Emily'
     123        with self.assertNumQueries(1):
     124            s.save(update_fields=['name'])
     125        s = Employee.objects.get(pk=s.pk)
     126        self.assertEqual(s.name, 'Emily')
     127        self.assertEqual(s.employee_num, 1)
     128        # A little sanity check that we actually did updates...
     129        self.assertEqual(Employee.objects.count(), 1)
     130        self.assertEqual(Person.objects.count(), 1)
     131        with self.assertNumQueries(2):
     132            s.save(update_fields=['name', 'employee_num'])
Back to Top