Ticket #17565: add-1to1-backref-cache.patch

django/db/models/fields/related.py

@@ -220 +220 @@
         return self.rel.related_name or self.opts.object_name.lower()
 
 class SingleRelatedObjectDescriptor(object):
-    # This class provides the functionality that makes the related-object
-    # managers available as attributes on a model class, for fields that have
+    # This class provides the functionality that makes the related objects
+    # (not managers) available as attributes on a model class, for fields that have
     # a single "remote" value, on the class pointed to by a related field.
     # In the example "place.restaurant", the restaurant attribute is a
     # SingleRelatedObjectDescriptor instance.
@@ -254 +254 @@
             params = {'%s__pk' % self.related.field.name: instance._get_pk_val()}
             rel_obj = self.get_query_set(instance=instance).get(**params)
             setattr(instance, self.cache_name, rel_obj)
+            # Also cache a back-reference to me on the related object
+            # (this is only used in one-to-one relations)
+            if rel_obj:
+                cache_name = self.related.field.get_cache_name()
+                if not getattr(rel_obj, cache_name, None):
+                    setattr(rel_obj, cache_name, instance)
             return rel_obj
 
     def __set__(self, instance, value):
@@ -409 +415 @@
         # object you just set.
         setattr(instance, self.field.get_cache_name(), value)
 
+class CachingReverseSingleRelatedObjectDescriptor(ReverseSingleRelatedObjectDescriptor):
+    """
+    This is a variation on ReverseSingleRelatedObjectDescriptor, which makes sure
+    a reverse back-reference (which is a forward reference) is cached on the target
+    of a reverse relation access. This is useful for one-to-one relations, making sure
+    that if
+     
+    class A(model):
+        pass
+    class B(model):
+        a = OneToOneField(A)
+    a1 = A.objects.get(...)
+    
+    then
+    
+    a1.b.a is a1
+    """  
+    def __get__(self, instance, instance_type=None):
+        myclass = CachingReverseSingleRelatedObjectDescriptor # ridiculously long name...
+        rel_obj = super(myclass, self).__get__(instance, instance_type)
+        if rel_obj:
+            cache_name = self.field.related.get_cache_name()
+            if not getattr(rel_obj, cache_name, None):
+                setattr (rel_obj, cache_name, instance)
+        return rel_obj
+    
+
 class ForeignRelatedObjectsDescriptor(object):
     # This class provides the functionality that makes the related-object
     # managers available as attributes on a model class, for fields that have
@@ -1034 +1067 @@
         kwargs['unique'] = True
         super(OneToOneField, self).__init__(to, to_field, OneToOneRel, **kwargs)
 
+    def contribute_to_class(self, cls, name):
+        # Ancestors do all sorts of stuff 
+        super(OneToOneField, self).contribute_to_class(cls, name)
+        # ... but they choose the wrong implementation for the attribute
+        setattr(cls, self.name, CachingReverseSingleRelatedObjectDescriptor(self))
+
     def contribute_to_related_class(self, cls, related):
         setattr(cls, related.get_accessor_name(),
                 SingleRelatedObjectDescriptor(related))