Ticket #17014: prefetch_recursion_trunk.diff

django/db/models/query.py

@@ -23 +23 @@
 # Pull into this namespace for backwards compatibility.
 EmptyResultSet = sql.EmptyResultSet
 
+# Maximum amount of prefetch related queries to be done when evaluating
+# a single queryset.
+MAX_PREFETCH_PER_QUERY = 100
+
 class QuerySet(object):
     """
     Represents a lazy database lookup for a set of objects.
@@ -1578 +1582 @@
 
     # We may expand related_lookups, so need a loop that allows for that
     for lookup in related_lookups:
+        if len(done_queries) > MAX_PREFETCH_PER_QUERY:
+            raise ValueError(
+                'Over %s prefetch_related lookups in one query. '
+                'Likely reason is recursion caused by default managers'
+                % MAX_PREFETCH_PER_QUERY
+            )
         if lookup in done_lookups:
             # We've done exactly this already, skip the whole thing
             continue

tests/modeltests/prefetch_related/models.py

@@ -163 +163 @@
 
     class Meta:
         ordering = ['id']
+
+class RecursiveManager(models.Manager):
+    def get_query_set(self):
+        return (super(RecursiveManager, self).get_query_set()
+                .prefetch_related('recurse_reverse'))
+
+class RecursiveRel(models.Model):
+    val = models.TextField()
+    recursion = models.ForeignKey('self', related_name='recurse_reverse', null=True)
+    objects = RecursiveManager()
+
+"""
+Construct a nasty diamond strucure of models,
+connected by default managers:
+       B
+      / \
+     /   \
+    /     \
+   A <---- D
+    \     /
+     \   /
+      \ /
+       C
+
+Contains two loops:
+A -> C -> D -> A
+A -> B -> D -> A
+
+In addition, C -> D and B -> D have same accessor name, d_set
+"""
+
+class AManager(models.Manager):
+    def get_query_set(self):
+        return super(AManager, self).get_query_set().prefetch_related('b_set', 'c_set')
+
+class BManager(models.Manager):
+    def get_query_set(self):
+        return super(BManager, self).get_query_set().prefetch_related('d_set')
+
+class CManager(models.Manager):
+    def get_query_set(self):
+        return super(CManager, self).get_query_set().prefetch_related('d_set')
+
+class DManager(models.Manager):
+    def get_query_set(self):
+        return super(CManager, self).get_query_set().prefetch_related('a_set')
+
+class DiamondA(models.Model):
+    d = models.ForeignKey('DiamondD', null=True)
+    objects = AManager()
+
+class DiamondB(models.Model):
+    a = models.ForeignKey(DiamondA, null=True)
+    objects = BManager()
+
+class DiamondC(models.Model):
+    a = models.ForeignKey(DiamondA, null=True)
+    objects = CManager()
+
+class DiamondD(models.Model):
+    b = models.ForeignKey(DiamondB, null=True)
+    c = models.ForeignKey(DiamondC, null=True) 
+    objects = DManager()

tests/modeltests/prefetch_related/tests.py

@@ -7 +7 @@
 from models import (Author, Book, Reader, Qualification, Teacher, Department,
                     TaggedItem, Bookmark, AuthorAddress, FavoriteAuthors,
                     AuthorWithAge, BookWithYear, Person, House, Room,
-                    Employee)
+                    Employee, RecursiveRel, DiamondA, DiamondB, DiamondC,
+                    DiamondD)
 
 
 class PrefetchRelatedTests(TestCase):
@@ -416 +417 @@
                         for e in qs2]
 
         self.assertEqual(co_serfs, co_serfs2)
+
+
+class RecursionTest(TestCase):
+    def setUp(self):
+        r1 = RecursiveRel.objects.create(val='foo')
+        r2 = RecursiveRel.objects.create(val='foo', recursion=r1)
+        r1.recursion = r2
+        r1.save()
+
+    def test_recursion(self):
+        RecursiveRel.objects.all()[0]
+
+class DiamondTest(TestCase):
+    def setUp(self):
+        a = DiamondA.objects.create()
+        b = DiamondB.objects.create(a=a)
+        c = DiamondA.objects.create(a=a)
+        d = DiamondA.objects.create(b=b, c=c)
+        a.d = d
+        a.save()
+
+    def test_diamond_recusion(self):
+        DiamondA.objects.all()[0]