Ticket #16458: 16458.2.diff

django/db/models/base.py

@@ -382 +382 @@
         return '%s object' % self.__class__.__name__
 
     def __eq__(self, other):
-        return isinstance(other, self.__class__) and self._get_pk_val() == other._get_pk_val()
+        return isinstance(other, Model) and \
+               self._meta.proxy_for_model == other._meta.proxy_for_model and \
+               self._get_pk_val() == other._get_pk_val()
 
     def __ne__(self, other):
         return not self.__eq__(other)

django/db/models/options.py

@@ -64 +64 @@
         self.object_name = cls.__name__
         self.module_name = self.object_name.lower()
         self.verbose_name = get_verbose_name(self.object_name)
+        # Note: for convenience we set that every concrete class and abstract class
+        # is proxy of itself. This helps in __eq__ checks for example.
+        self.proxy_for_model = cls
 
         # Next, apply any overridden values from 'class Meta'.
         if self.meta:

docs/topics/db/models.txt

@@ -795 +795 @@
     without changing the models fields in any way, you can use
     :ref:`proxy-models`.
 
+A note about model instance equality operator
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When comparing the equality of model instances, Django uses the following
+rules. Two instances are considered equal if:
+
+  1. The primary keys are equal. Note that if both instances have primary key value of None, they are considered equal.
+  2. The instances are of same class. For this rule, proxy models are considered instances of the class they are proxying. Multi-table inheriting instance is not considered to be of same class with its base class.
+
 .. _abstract-base-classes:
 
 Abstract base classes

tests/modeltests/defer/tests.py

@@ -23 +23 @@
         p1 = Primary.objects.create(name="p1", value="xx", related=s1)
 
         qs = Primary.objects.all()
-
         self.assert_delayed(qs.defer("name")[0], 1)
         self.assert_delayed(qs.only("name")[0], 2)
         self.assert_delayed(qs.defer("related__first")[0], 0)
+        
+        # deferred instances are equal to their non-deferred counterpart
+        deferred_p1 = qs.defer("name")[0]
+        self.assertTrue(deferred_p1==p1)
+        # The __eq__ operator is symmetric as well as the == operator
+        self.assertTrue(p1==deferred_p1)
+        self.assertTrue(deferred_p1.__eq__(p1))
+        self.assertTrue(p1.__eq__(deferred_p1))
+
 
         obj = qs.select_related().only("related__first")[0]
         self.assert_delayed(obj, 2)

tests/modeltests/model_inheritance/tests.py

@@ -69 +69 @@
             StudentWorker.objects.get, pk__lt=sw2.pk + 100
         )
 
+        # A multi-table inherited instance is never cosidered equal to
+        # its base class instances.
+        w = Worker(pk=1)
+        sw = StudentWorker(pk=1)
+        self.assertFalse(w==sw)
+        # The __eq__ operator is symmetric as well as the '==' operator
+        self.assertFalse(sw==w)
+        self.assertFalse(w.__eq__(sw))
+        self.assertFalse(sw.__eq__(w))
+
     def test_multiple_table(self):
         post = Post.objects.create(title="Lorem Ipsum")
         # The Post model has distinct accessors for the Comment and Link models.

tests/modeltests/proxy_models/tests.py

@@ -45 +45 @@
         self.assertEqual(MyPerson.objects.get(name="Foo McBar").id, person.id)
         self.assertFalse(MyPerson.objects.get(id=person.id).has_special_name())
 
+    def test_proxy_eq(self):
+        """
+        Proxied models are considered equal to their concrete base class.
+        """
+        p = Person(pk=1)
+        mp = MyPerson(pk=1)
+        self.assertTrue(p==mp)
+        # the __eq__ operator is symmetric as well as the == operator
+        self.assertTrue(mp==p)
+        self.assertTrue(p.__eq__(mp))
+        self.assertTrue(mp.__eq__(p))
+
     def test_no_proxy(self):
         """
         Person is not proxied by StatusPerson subclass.