Ticket #10955: 10955_proxy_select_related_r10697.diff

django/db/models/sql/query.py

@@ -778 +778 @@
         qn2 = self.connection.ops.quote_name
         aliases = set()
         only_load = self.deferred_to_columns()
-        proxied_model = opts.proxy and opts.proxy_for_model or 0
+        # Skip all proxy to the root proxied model
+        int_opts = opts
+        proxied_model = None
+        while int_opts.proxy:
+            proxied_model = int_opts.proxy_for_model
+            int_opts = proxied_model._meta
+
         if start_alias:
             seen = {None: start_alias}
         for field, model in opts.get_fields_with_model():
@@ -1301 +1307 @@
         opts = self.model._meta
         root_alias = self.tables[0]
         seen = {None: root_alias}
-        proxied_model = opts.proxy and opts.proxy_for_model or 0
+        
+        # Skip all proxy to the root proxied model
+        int_opts = opts
+        proxied_model = None
+        while int_opts.proxy:
+            proxied_model = int_opts.proxy_for_model
+            int_opts = proxied_model._meta
+
         for field, model in opts.get_fields_with_model():
             if model not in seen:
                 if model is proxied_model:
@@ -1376 +1389 @@
                 alias = root_alias
                 alias_chain = []
                 for int_model in opts.get_base_chain(model):
+                    # Proxy model have elements in base chain
+                    # with no parents, assign the new options
+                    # object and skip to the next base in that
+                    # case
+                    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:
@@ -1720 +1740 @@
                 raise MultiJoin(pos + 1)
             if model:
                 # The field lives on a base class of the current model.
-                proxied_model = opts.proxy and opts.proxy_for_model or 0
+                # Skip the chain of proxy to the concrete proxied model                
+                int_opts = opts
+                proxied_model = None
+                while int_opts.proxy:
+                    proxied_model = int_opts.proxy_for_model
+                    int_opts = proxied_model._meta
+
                 for int_model in opts.get_base_chain(model):
                     if int_model is proxied_model:
                         opts = int_model._meta

django/db/models/base.py

@@ -138 +138 @@
                                      'with field of similar name from '
                                      'base class %r' %
                                         (field.name, name, base.__name__))
+
+            # Stores real base (before skipping proxy classes)
+            # for managers inheritance. Managers should be inherited
+            # from concrete and abstract managers of immediate bases
+            base_orig = base
             if not base._meta.abstract:
                 # Concrete classes...
                 while base._meta.proxy:
@@ -162 +167 @@
                 new_class._meta.parents.update(base._meta.parents)
 
             # Inherit managers from the abstract base classes.
-            new_class.copy_managers(base._meta.abstract_managers)
+            new_class.copy_managers(base_orig._meta.abstract_managers)
 
             # Proxy models inherit the non-abstract managers from their base,
             # unless they have redefined any of them.
             if is_proxy:
-                new_class.copy_managers(base._meta.concrete_managers)
+                new_class.copy_managers(base_orig._meta.concrete_managers)
 
             # Inherit virtual fields (like GenericForeignKey) from the parent
             # class

django/db/models/options.py

@@ -461 +461 @@
         if ancestor in self.parents:
             return self.parents[ancestor]
         for parent in self.parents:
-            if parent._meta.get_ancestor_link(ancestor):
-                return self.parents[parent]
+            # Tries to get a link field from the immediate parent
+            parent_link = parent._meta.get_ancestor_link(ancestor)
+            if parent_link:
+                # In case of a proxied model, the first link
+                # of the chain to the ancestor is that parent
+                # links
+                return self.parents[parent] or parent_link
 
     def get_ordered_objects(self):
         "Returns a list of Options objects that are ordered with respect to this object."

tests/modeltests/proxy_models/models.py

@@ -82 +82 @@
 class LowerStatusPerson(MyPersonProxy):
     status = models.CharField(max_length=80)
 
+# We can still use `select_related()` to include related models in our querysets.
+class Country(models.Model):
+        name = models.CharField(max_length=50)
+
+class State(models.Model):
+        name = models.CharField(max_length=50)
+        country = models.ForeignKey(Country)
+
+        def __unicode__(self):
+                return self.name
+
+class StateProxy(State):
+        class Meta:
+                proxy = True
+
+# Proxy models still works with filters (on related fields)
+# and select_related, even when mixed with model inheritance
+class BaseUser(models.Model):
+    name = models.CharField(max_length=255)
+
+class TrackerUser(BaseUser):
+    status = models.CharField(max_length=50)
+
+class ProxyTrackerUser(TrackerUser):
+    class Meta:
+        proxy = True
+
+
+class Issue(models.Model):
+    summary = models.CharField(max_length=255)
+    assignee = models.ForeignKey(TrackerUser)
+
+    def __unicode__(self):
+        return ':'.join((self.__class__.__name__,self.summary,))
+
+class Bug(Issue):
+    version = models.CharField(max_length=50)
+    reporter = models.ForeignKey(BaseUser)
+
+class ProxyBug(Bug):
+    """
+    Proxy of an inherited class
+    """
+    class Meta:
+        proxy = True
+
+
+class ProxyProxyBug(ProxyBug):
+    """
+    A proxy of proxy model with related field
+    """
+    class Meta:
+        proxy = True
+
+class Improvement(Issue):
+    """
+    A model that has relation to a proxy model
+    or to a proxy of proxy model
+    """
+    version = models.CharField(max_length=50)
+    reporter = models.ForeignKey(ProxyTrackerUser)
+    associated_bug = models.ForeignKey(ProxyProxyBug)
+    
+class ProxyImprovement(Improvement):
+    class Meta:
+        proxy = True
+
 __test__ = {'API_TESTS' : """
 # The MyPerson model should be generating the same database queries as the
 # Person model (when the same manager is used in each case).
@@ -119 +186 @@
 >>> LowerStatusPerson.objects.all()
 [<LowerStatusPerson: homer>]
 
+# Correct type when querying a proxy of proxy
+
+>>> MyPersonProxy.objects.all()
+[<MyPersonProxy: Bazza del Frob>, <MyPersonProxy: Foo McBar>, <MyPersonProxy: homer>]
+
 # And now for some things that shouldn't work...
 #
 # All base classes must be non-abstract
@@ -178 +250 @@
 >>> ctype = ContentType.objects.get_for_model
 >>> ctype(Person) is ctype(OtherPerson)
 True
-"""}
 
+# We can still use `select_related()` to include related models in our querysets.
+>>> country = Country.objects.create(name='Australia')
+>>> state = State.objects.create(name='New South Wales', country=country)
 
+>>> State.objects.select_related()
+[<State: New South Wales>]
+>>> StateProxy.objects.select_related()
+[<StateProxy: New South Wales>]
+>>> StateProxy.objects.get(name='New South Wales')
+<StateProxy: New South Wales>
+>>> StateProxy.objects.select_related().get(name='New South Wales')
+<StateProxy: New South Wales>
+
+>>> contributor = TrackerUser.objects.create(name='Contributor',status='contrib')
+>>> someone = BaseUser.objects.create(name='Someone')
+>>> _ = Bug.objects.create(summary='fix this', version='1.1beta',
+...                        assignee=contributor, reporter=someone)
+>>> pcontributor = ProxyTrackerUser.objects.create(name='OtherContributor',
+...                                                status='proxy')
+>>> _ = Improvement.objects.create(summary='improve that', version='1.1beta',
+...                                assignee=contributor, reporter=pcontributor,
+...                                associated_bug=ProxyProxyBug.objects.all()[0])
+
+# Related field filter on proxy
+>>> ProxyBug.objects.get(version__icontains='beta')
+<ProxyBug: ProxyBug:fix this>
+
+# Select related + filter on proxy
+>>> ProxyBug.objects.select_related().get(version__icontains='beta')
+<ProxyBug: ProxyBug:fix this>
+
+# Proxy of proxy, select_related + filter
+>>> ProxyProxyBug.objects.select_related().get(version__icontains='beta')
+<ProxyProxyBug: ProxyProxyBug:fix this>
+
+# Select related + filter on a related proxy field
+>>> ProxyImprovement.objects.select_related().get(reporter__name__icontains='butor')
+<ProxyImprovement: ProxyImprovement:improve that>
+
+# Select related + filter on a related proxy of proxy field
+>>> ProxyImprovement.objects.select_related().get(associated_bug__summary__icontains='fix')
+<ProxyImprovement: ProxyImprovement:improve that>
+"""}