Ticket #9023: 9023.diff

django/db/models/fields/related.py

@@ -112 +112 @@
 
     def do_related_class(self, other, cls):
         self.set_attributes_from_rel()
-        related = RelatedObject(other, cls, self)
+        self.related = RelatedObject(other, cls, self)
         if not cls._meta.abstract:
-            self.contribute_to_related_class(other, related)
+            self.contribute_to_related_class(other, self.related)
 
     def get_db_prep_lookup(self, lookup_type, value):
         # If we are doing a lookup on a Related Field, we must be
@@ -271 +271 @@
                                 (value, instance._meta.object_name,
                                  self.field.name, self.field.rel.to._meta.object_name))
 
+        # If we're setting the value of a OneToOneField to None, we need to clear
+        # out the cache on any old related object. Otherwise, deleting the
+        # previously-related object will also cause this object to be deleted,
+        # which is wrong.
+        if value is None:
+            # Look up the previously-related object, which is still available
+            # since we've not year cleared out the related field. This could
+            # raise a DoesNotExist exception, which we need to ignore.
+            try:
+                related = getattr(instance, self.field.name, None)
+            except self.field.rel.to.DoesNotExist:
+                related = None
+
+            # If we've got an old related object, we need to clear out its
+            # cache. This cache also might not exist if the related object
+            # hasn't been accessed yet.
+            if related:
+                cache_name = '_%s_cache' % self.field.related.get_accessor_name()
+                try:
+                    delattr(related, cache_name)
+                except AttributeError:
+                    pass
+
         # Set the value of the related field
         try:
             val = getattr(value, self.field.rel.get_related_field().attname)

new file tests/regressiontests/one_to_one_regress/tests.py

@@ +1 @@
+from django.test import TestCase
+from regressiontests.one_to_one_regress.models import Place, UndergroundBar
+
+class OneToOneDeletionTests(TestCase):
+    def test_reverse_relationship_cache_cascade(self):
+        """
+        Regression test for #9023: accessing the reverse relationship shouldn't
+        result in a cascading delete().
+        """
+        place = Place.objects.create(name="Dempsey's", address="623 Vermont St")
+        bar = UndergroundBar.objects.create(place=place, serves_cocktails=False)
+        
+        # The bug in #9023: if you access the one-to-one relation *before*
+        # setting to None and deleting, the cascade happens anyway.
+        place.undergroundbar
+        bar.place = None
+        bar.save()
+        place.delete()
+        
+        self.assertEqual(Place.objects.all().count(), 0)
+        self.assertEqual(UndergroundBar.objects.all().count(), 1)
+        
+ No newline at end of file