Ticket #14694: 14694-defer-reverse-relations-r17462.diff

tests/regressiontests/defer_regress/tests.py

@@ -9 +9 @@
 from django.test import TestCase
 
 from .models import (ResolveThis, Item, RelatedItem, Child, Leaf, Proxy,
-    SimpleItem, Feature)
+    SimpleItem, Feature, OneToOneItem)
 
 
 class DeferRegressionTest(TestCase):
@@ -110 +110 @@
                 Feature,
                 Item,
                 Leaf,
+                OneToOneItem,
                 Proxy,
                 RelatedItem,
                 ResolveThis,
@@ -141 +142 @@
                 "Leaf_Deferred_name_value",
                 "Leaf_Deferred_second_child_value",
                 "Leaf_Deferred_value",
+                "OneToOneItem",
                 "Proxy",
                 "RelatedItem",
                 "RelatedItem_Deferred_",
@@ -174 +176 @@
         qs = ResolveThis.objects.defer('num')
         self.assertEqual(1, qs.count())
         self.assertEqual('Foobar', qs[0].name)
+
+    def test_reverse_one_to_one_relations(self):
+        item = Item.objects.create(name="first", value=42)
+        OneToOneItem.objects.create(item=item, name="second")
+        self.assertEqual(len(Item.objects.all()), 1)
+        self.assertEqual(len(Item.objects.defer('one_to_one_item__name')), 1)
+        self.assertEqual(len(Item.objects.select_related('one_to_one_item')), 1)
+        self.assertEqual(len(Item.objects.select_related('one_to_one_item').defer('one_to_one_item__name')), 1)
+        self.assertEqual(len(Item.objects.select_related('one_to_one_item').defer('value')), 1)
+        # make sure that `only()` doesn't break when we pass in a reverse relation, rather than a field on the relation.
+        self.assertEqual(len(Item.objects.only('one_to_one_item')), 1)

tests/regressiontests/defer_regress/models.py

@@ -47 +47 @@
 
 class Feature(models.Model):
     item = models.ForeignKey(SimpleItem)
+
+class OneToOneItem(models.Model):
+    item = models.OneToOneField(Item, related_name="one_to_one_item")
+    name = models.CharField(max_length=15)

django/db/models/sql/query.py

@@ -17 +17 @@
 from django.db.models.expressions import ExpressionNode
 from django.db.models.fields import FieldDoesNotExist
 from django.db.models.query_utils import InvalidQuery
+from django.db.models.related import RelatedObject
 from django.db.models.sql import aggregates as base_aggregates_module
 from django.db.models.sql.constants import *
 from django.db.models.sql.datastructures import EmptyResultSet, Empty, MultiJoin
@@ -586 +587 @@
             for name in parts[:-1]:
                 old_model = cur_model
                 source = opts.get_field_by_name(name)[0]
-                cur_model = opts.get_field_by_name(name)[0].rel.to
+                if isinstance(source, RelatedObject):
+                    cur_model = source.model
+                else:
+                    cur_model = source.rel.to
                 opts = cur_model._meta
                 # Even if we're "just passing through" this model, we must add
                 # both the current model's pk and the related reference field
-                # to the things we select.
-                must_include[old_model].add(source)
+                # (if it's not a reverse relation) to the things we select.
+                if not isinstance(source, RelatedObject):
+                    must_include[old_model].add(source)
                 add_to_dict(must_include, cur_model, opts.pk)
             field, model, _, _ = opts.get_field_by_name(parts[-1])
             if model is None:
                 model = cur_model
-            add_to_dict(seen, model, field)
+            if not isinstance(field, RelatedObject):
+                add_to_dict(seen, model, field)
 
         if defer:
             # We need to load all fields for each model, except those that
@@ -636 +642 @@
             for model, values in seen.iteritems():
                 callback(target, model, values)
 
-
     def deferred_to_columns_cb(self, target, model, fields):
         """
         Callback used by deferred_to_columns(). The "target" parameter should
@@ -648 +653 @@
         for field in fields:
             target[table].add(field.column)
 
-
     def table_alias(self, table_name, create=False):
         """
         Returns a table alias for the given table_name and whether this is a

django/db/models/query.py

@@ -1413 +1413 @@
                 # If the related object exists, populate
                 # the descriptor cache.
                 setattr(rel_obj, f.get_cache_name(), obj)
-                # Now populate all the non-local field values
-                # on the related object
-                for rel_field, rel_model in rel_obj._meta.get_fields_with_model():
+                # Now populate all the non-local field values on the related
+                # object. If this object has deferred fields, we need to use
+                # the opts from the original model to get non-local fields
+                # correctly.
+                opts = rel_obj._meta
+                if getattr(rel_obj, '_deferred'):
+                    opts = opts.proxy_for_model._meta
+                for rel_field, rel_model in opts.get_fields_with_model():
                     if rel_model is not None:
                         setattr(rel_obj, rel_field.attname, getattr(obj, rel_field.attname))
                         # populate the field cache for any related object