Ticket #7270: reverse_select_related.diff

django/db/models/fields/related.py

@@ -188 +188 @@
     # SingleRelatedObjectDescriptor instance.
     def __init__(self, related):
         self.related = related
-        self.cache_name = '_%s_cache' % related.get_accessor_name()
+        self.cache_name = related.get_accessor_cache()
 
     def __get__(self, instance, instance_type=None):
         if instance is None:
@@ -307 +307 @@
             # 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()
+                cache_name = self.field.related.get_accessor_cache()
                 try:
                     delattr(related, cache_name)
                 except AttributeError:

django/db/models/query.py

@@ -1147 +1147 @@
             rel_obj, index_end = cached_row
             if obj is not None:
                 setattr(obj, f.get_cache_name(), rel_obj)
+            if f.unique:
+                setattr(rel_obj, f.related.get_accessor_cache(), obj)
+
+    if restricted:
+        related_fields = [(o.field, o.model) for o in klass._meta.get_all_related_objects()
+            if o.field.unique and o.field.related_query_name() in requested]
+        for f, model in related_fields:
+            next = requested.get(f.related_query_name(), {})
+            cached_row = get_cached_row(model, row, index_end, max_depth,
+                cur_depth+1, next)
+            if cached_row:
+                rel_obj, index_end = cached_row
+                if obj is not None:
+                    setattr(obj, f.related.get_accessor_cache(), rel_obj)
+                if rel_obj is not None:
+                    setattr(rel_obj, f.get_cache_name(), obj)
+
+
     return obj, index_end
 
 def delete_objects(seen_objs, using):

django/db/models/related.py

@@ -45 +45 @@
             return self.field.rel.related_name or (self.opts.object_name.lower() + '_set')
         else:
             return self.field.rel.related_name or (self.opts.object_name.lower())
+
+    def get_accessor_cache(self):
+        return "_%s_cache" % self.get_accessor_name()

django/db/models/sql/compiler.py

@@ -520 +520 @@
 
         # Setup for the case when only particular related fields should be
         # included in the related selection.
-        if requested is None and restricted is not False:
+        if requested is None:
             if isinstance(self.query.select_related, dict):
                 requested = self.query.select_related
                 restricted = True
@@ -600 +600 @@
             self.fill_related_selections(f.rel.to._meta, alias, cur_depth + 1,
                     used, next, restricted, new_nullable, dupe_set, avoid)
 
+        if restricted and requested is not None:
+            related_fields = [(o.field, o.model) for o in opts.get_all_related_objects()
+                if o.field.unique and o.field.related_query_name() in requested
+            ]
+            for f, model in related_fields:
+                table = model._meta.db_table
+                int_opts = opts
+                alias = root_alias
+                alias_chain = []
+                chain = opts.get_base_chain(f.rel.to)
+                avoid = avoid_set.copy()
+                if chain is not None:
+                    for int_model in chain:
+                        if not int_opts.parents[int_model]:
+                            int_opts = int_model._meta
+                            continue
+                        lhs_col = int_opts.parents[int_model].column
+                        dedupe = lhs_col in opts.duplicate_targets
+                        if dedupe:
+                            avoid.update(self.query.dupe_avoidance.get(id(opts), lhs_col), ())
+                            dupe_set.add((opts, lhs_col))
+                        int_opts = int_model._meta
+                        alias = self.query.join(
+                            (alias, int_opts.db_table, lhs_col, int_opts.pk.column),
+                            exclusions=used, promote=True, reuse=used
+                        )
+                        alias_chain.append(alias)
+                        for dupe_opts, dupe_col in dupe_set:
+                            self.query.update_dupe_avoidance(dupe_opts, dupe_col, alias)
+                    dedupe = f.column in opts.duplicate_targets
+                    if dupe_set or dedupe:
+                        avoid.update(self.query.dupe_avoidance.get((id(opts), f.column), ()))
+                        if dedupe:
+                            dupe_set.add((opts, f.column))
+                alias = self.query.join(
+                    (alias, table, f.rel.get_related_field().column, f.column),
+                    exclusions=used.union(avoid),
+                    promote=True
+                )
+                used.add(alias)
+                columns, aliases = self.get_default_columns(start_alias=alias,
+                    opts=model._meta, as_pairs=True)
+                self.query.related_select_cols.extend(columns)
+                self.query.related_select_fields.extend(model._meta.fields)
+
+                next = requested.get(f.related_query_name(), {})
+                new_nullable = f.null or None
+
+                self.fill_related_selections(model._meta, table, cur_depth+1,
+                    used, next, restricted, new_nullable)
+
     def deferred_to_columns(self):
         """
         Converts the self.deferred_loading data structure to mapping of table

new file tests/regressiontests/select_related_onetoone/models.py

@@ +1 @@
+from django.db import models
+
+
+class User(models.Model):
+    username = models.CharField(max_length=100)
+    email = models.EmailField()
+
+    def __unicode__(self):
+        return self.username
+
+
+class UserProfile(models.Model):
+    user = models.OneToOneField(User)
+    city = models.CharField(max_length=100)
+    state = models.CharField(max_length=2)
+
+    def __unicode__(self):
+        return "%s, %s" % (self.city, self.state)
+
+
+class UserStatResult(models.Model):
+    results = models.CharField(max_length=50)
+
+    def __unicode__(self):
+        return 'UserStatResults, results = %s' % (self.results,)
+    
+
+class UserStat(models.Model):
+    user = models.OneToOneField(User, primary_key=True)
+    posts = models.IntegerField()
+    results = models.ForeignKey(UserStatResult)
+
+    def __unicode__(self):
+        return 'UserStat, posts = %s' % (self.posts,)
+
+class StatDetails(models.Model):
+    base_stats = models.OneToOneField(UserStat)
+    comments = models.IntegerField()
+
+    def __unicode__(self):
+        return 'StatDetails, comments = %s' % (self.comments,)
+
+class AdvancedUserStat(UserStat):
+    pass

new file tests/regressiontests/select_related_onetoone/tests.py

@@ +1 @@
+from django import db
+from django.conf import settings
+from django.test import TestCase
+
+from models import User, UserProfile, UserStat, UserStatResult, StatDetails, AdvancedUserStat
+
+class ReverseSelectRelatedTestCase(TestCase):
+    def setUp(self):
+        self.old_debug = settings.DEBUG
+        settings.DEBUG = True
+
+        user = User.objects.create(username="test")
+        userprofile = UserProfile.objects.create(user=user, state="KS",
+                                                 city="Lawrence")
+        results = UserStatResult.objects.create(results='first results')
+        userstat = UserStat.objects.create(user=user, posts=150,
+                                           results=results)
+        details = StatDetails.objects.create(base_stats=userstat, comments=259)
+
+        user2 = User.objects.create(username="bob")
+        results2 = UserStatResult.objects.create(results='moar results')
+        advstat = AdvancedUserStat.objects.create(user=user2, posts=200,
+                                                  results=results2)
+        StatDetails.objects.create(base_stats=advstat, comments=250)
+
+        db.reset_queries()
+
+    def assertQueries(self, queries):
+        self.assertEqual(len(db.connection.queries), queries)
+
+    def tearDown(self):
+        settings.DEBUG = self.old_debug
+
+    def test_basic(self):
+        u = User.objects.select_related("userprofile").get(username="test")
+        self.assertEqual(u.userprofile.state, "KS")
+        self.assertQueries(1)
+
+    def test_follow_next_level(self):
+        u = User.objects.select_related("userstat__results").get(username="test")
+        self.assertEqual(u.userstat.posts, 150)
+        self.assertEqual(u.userstat.results.results, 'first results')
+        self.assertQueries(1)
+
+    def test_follow_two(self):
+        u = User.objects.select_related("userprofile", "userstat").get(username="test")
+        self.assertEqual(u.userprofile.state, "KS")
+        self.assertEqual(u.userstat.posts, 150)
+        self.assertQueries(1)
+
+    def test_follow_two_next_level(self):
+        u = User.objects.select_related("userstat__results", "userstat__statdetails").get(username="test")
+        self.assertEqual(u.userstat.results.results, 'first results')
+        self.assertEqual(u.userstat.statdetails.comments, 259)
+        self.assertQueries(1)
+
+    def test_forward_and_back(self):
+        stat = UserStat.objects.select_related("user__userprofile").get(user__username="test")
+        self.assertEqual(stat.user.userprofile.state, 'KS')
+        self.assertEqual(stat.user.userstat.posts, 150)
+        self.assertQueries(1)
+
+    def test_back_and_forward(self):
+        u = User.objects.select_related("userstat").get(username="test")
+        self.assertEqual(u.userstat.user.username, 'test')
+        self.assertQueries(1)
+
+    def test_not_followed_by_default(self):
+        u = User.objects.select_related().get(username="test")
+        self.assertEqual(u.userstat.posts, 150)
+        self.assertQueries(2)
+
+    def test_follow_from_child_class(self):
+        stat = AdvancedUserStat.objects.select_related("statdetails").get(posts=200)
+        self.assertEqual(stat.statdetails.comments, 250)
+        self.assertQueries(1)
+
+    def test_follow_inheritance(self):
+        stat = UserStat.objects.select_related('advanceduserstat').get(posts=200)
+        self.assertEqual(stat.advanceduserstat.posts, 200)
+        self.assertQueries(1)