Finished implementation of NestedAutoRQLFilterClass

maxipavlovic · maxipavlovic · commit d452bb364216 · 2021-07-15T22:22:53.000+03:00
* refactored NestedAutoRQLFilterClass._get_init_filters to reduce complexity
* added support for automatic queryset optimization
* wrote the minimum number of needed tests (max depth=3)
diff --git a/dj_rql/filter_cls.py b/dj_rql/filter_cls.py
@@ -28,11 +28,12 @@
 from dj_rql.exceptions import RQLFilterLookupError, RQLFilterParsingError, RQLFilterValueError
 from dj_rql.openapi import RQLFilterClassSpecification
 from dj_rql.parser import RQLParser
-from dj_rql.qs import Annotation
+from dj_rql.qs import Annotation, NPR, NSR
 from dj_rql.transformer import RQLToDjangoORMTransformer
 
-from django.db.models import Model, Q
+from django.db.models import ForeignKey, ManyToManyField, Model, OneToOneField, OneToOneRel, Q
 from django.utils.dateparse import parse_date, parse_datetime
+from django.utils.functional import cached_property
 
 from lark.exceptions import LarkError
 
@@ -1040,8 +1041,7 @@ class AutoRQLFilterClass(RQLFilterClass):
     """This class will collect all simple model fields except the ones in this field."""
 
     def _get_init_filters(self):
-        described_filters = tuple(self.FILTERS) if self.FILTERS else ()
-
+        described_filters = self._described_filters
         filters = tuple(
             {
                 'filter': f.name,
@@ -1058,6 +1058,10 @@ def _get_init_filters(self):
 
         return described_filters + filters
 
+    @cached_property
+    def _described_filters(self):
+        return tuple(self.FILTERS) if self.FILTERS else ()
+
 
 class NestedAutoRQLFilterClass(AutoRQLFilterClass):
     """
@@ -1076,37 +1080,90 @@ def _get_init_filters(self):
         if self.DEPTH == 0:
             return super()._get_init_filters()
 
-        described_filters = tuple(self.FILTERS) if self.FILTERS else ()
-        filters = []
-
         depth = 0
-        models = [(self.MODEL, None)]
-
-        while depth <= self.DEPTH and models:
-            related_models = []
-            for model, prefix in models:
-                for field in model._meta.get_fields():
-                    field_name = field.name
-                    if prefix:
-                        rel_f_name = '.'.join((prefix, field_name))
-                    else:
-                        rel_f_name = field_name
-
-                    if rel_f_name in self.EXCLUDE_FILTERS or rel_f_name in described_filters:
-                        continue
-
-                    if field.is_relation:
-                        related_models.append((field.related_model, rel_f_name))
-                        continue
-
-                    if isinstance(field, SUPPORTED_FIELD_TYPES):
-                        filters.append({
-                            'filter': rel_f_name,
-                            'ordering': True,
-                            'search': FilterTypes.field_filter_type(field) == FilterTypes.STRING,
-                        })
+        global_namespace = []
+        iterator = [(self.MODEL, global_namespace, None, None)]
 
+        while depth <= self.DEPTH and iterator:
+            iterator = self._iter_models_to_get_filters(depth, iterator)
             depth += 1
-            models = related_models
 
-        return filters
+        return self._described_filters + tuple(global_namespace)
+
+    def _iter_models_to_get_filters(self, depth, iterator):
+        related_models = []
+
+        for model_data in iterator:
+            related_models.extend(self._iter_model_to_get_filters(depth, model_data))
+
+        return related_models
+
+    def _iter_model_to_get_filters(self, depth, model_data):
+        model, namespace, circular_related_name, prefix = model_data
+        through_models = set()
+        model_related_models = []
+
+        for field in model._meta.get_fields():
+            rel_f_name = self._get_relative_field_name(field, circular_related_name, prefix)
+            if not rel_f_name:
+                continue
+
+            if field.is_relation:
+                if self._is_through_field(field):
+                    through_models.add(field.through)
+
+                relation_data = self._add_relation_to_iterated_models(depth, field, namespace)
+                model_related_models.append(relation_data + (rel_f_name,))
+                continue
+
+            if isinstance(field, SUPPORTED_FIELD_TYPES):
+                namespace.append({
+                    'filter': field.name,
+                    'ordering': True,
+                    'search': FilterTypes.field_filter_type(field) == FilterTypes.STRING,
+                })
+
+        return [i for i in model_related_models if i[0] not in through_models]
+
+    def _add_relation_to_iterated_models(self, depth, field, namespace):
+        if isinstance(field, (ForeignKey, ManyToManyField)):
+            circular_related_name = field.remote_field.name
+        else:
+            circular_related_name = field.field.name
+
+        field_name = field.name
+        qs = None
+        if isinstance(field, (ForeignKey, OneToOneField, OneToOneRel)):
+            qs = NSR(field_name)
+        elif not self._is_through_field(field):
+            qs = NPR(field_name)
+
+        namespace_filters = []
+        if depth < self.DEPTH:
+            namespace.append({
+                'namespace': field_name,
+                'filters': namespace_filters,
+                'qs': qs,
+            })
+
+        return field.related_model, namespace_filters, circular_related_name
+
+    def _get_relative_field_name(self, field, circular_related_name, prefix):
+        field_name = field.name
+        if circular_related_name and field_name == circular_related_name:
+            # This is needed to avoid circular dependencies
+            return
+
+        if prefix:
+            rel_f_name = '.'.join((prefix, field_name))
+        else:
+            rel_f_name = field_name
+
+        if rel_f_name in self.EXCLUDE_FILTERS or rel_f_name in self._described_filters:
+            return
+
+        return rel_f_name
+
+    @staticmethod
+    def _is_through_field(field):
+        return getattr(field, 'through', None)
diff --git a/tests/dj_rf/models.py b/tests/dj_rf/models.py
@@ -83,7 +83,7 @@ class FKRelated1(models.Model):
 
 
 class FKRelated2(models.Model):
-    related21 = models.ForeignKey(FKRelated1, null=True, on_delete=models.PROTECT)
+    related21 = models.ForeignKey(FKRelated1, null=True, on_delete=models.PROTECT, related_name='r')
 
 
 class OneTOneRelated(models.Model):
@@ -123,7 +123,7 @@ class ReverseManyToManyRelated(models.Model):
 
 class ReverseManyToManyTroughRelated(models.Model):
     auto = models.ManyToManyField(
-        AutoMain, through='Through', through_fields=('mtm', 'auto'), related_name='reverse_MtM'
+        AutoMain, through='Through', through_fields=('mtm', 'auto'), related_name='reverse_MtM',
     )
 
 
diff --git a/tests/test_filter_cls/test_initialization.py b/tests/test_filter_cls/test_initialization.py
@@ -14,7 +14,6 @@
 from tests.dj_rf.filters import AUTHOR_FILTERS, BooksFilterClass
 from tests.dj_rf.models import Author, AutoMain, Book
 
-
 empty_qs = Author.objects.none()
 
 
@@ -388,10 +387,146 @@ class Cls(AutoRQLFilterClass):
     )
 
 
-def test_nested_auto_building_filters():
+def test_nested_auto_building_filters_depth_0():
+    class Cls(NestedAutoRQLFilterClass):
+        MODEL = AutoMain
+        DEPTH = 0
+
+    assert set(Cls(AutoMain.objects.all()).filters.keys()) == {'id', 'common_int', 'common_str'}
+
+
+def test_nested_auto_building_filters_depth_1_check_structure():
+    class Cls(NestedAutoRQLFilterClass):
+        MODEL = AutoMain
+
+    assert set(Cls(AutoMain.objects.all()).filters.keys()) == {
+        'id',
+        'common_int',
+        'common_str',
+        'parent.id',
+        'parent.common_int',
+        'parent.common_str',
+        'self.id',
+        'self.common_int',
+        'self.common_str',
+        'related1.id',
+        'related2.id',
+        'one_to_one.id',
+        'many_to_many.id',
+        'reverse_OtM.id',
+        'reverse_OtO.id',
+        'reverse_MtM.id',
+    }
+
+
+@pytest.mark.django_db
+def test_nested_auto_building_filters_depth_2_check_select():
     class Cls(NestedAutoRQLFilterClass):
         MODEL = AutoMain
-        DEPTH = 5
+        DEPTH = 2
+
+    filter_cls = Cls(AutoMain.objects.all())
+    assert set(filter_cls.filters.keys()) == {
+        'common_int',
+        'common_str',
+        'id',
+        'many_to_many.id',
+        'one_to_one.id',
+        'parent.common_int',
+        'parent.common_str',
+        'parent.id',
+        'parent.many_to_many.id',
+        'parent.one_to_one.id',
+        'parent.parent.common_int',
+        'parent.parent.common_str',
+        'parent.parent.id',
+        'parent.related1.id',
+        'parent.related2.id',
+        'parent.reverse_MtM.id',
+        'parent.reverse_OtM.id',
+        'parent.reverse_OtO.id',
+        'related1.r.id',
+        'related1.id',
+        'related2.id',
+        'related2.related21.id',
+        'reverse_MtM.id',
+        'reverse_MtM.through.common_int',
+        'reverse_MtM.through.id',
+        'reverse_OtM.auto2.common_int',
+        'reverse_OtM.auto2.common_str',
+        'reverse_OtM.auto2.id',
+        'reverse_OtM.id',
+        'reverse_OtO.id',
+        'self.common_int',
+        'self.common_str',
+        'self.id',
+        'self.many_to_many.id',
+        'self.one_to_one.id',
+        'self.related1.id',
+        'self.related2.id',
+        'self.reverse_MtM.id',
+        'self.reverse_OtM.id',
+        'self.reverse_OtO.id',
+        'self.self.common_int',
+        'self.self.common_str',
+        'self.self.id',
+    }
 
-    result = Cls(AutoMain.objects.all())
-    print(1)
+    _, qs = filter_cls.apply_filters('')
+    assert qs.query.select_related == {
+        'reverse_OtO': {},
+        'self': {
+            'reverse_OtO': {},
+            'self': {},
+            'related1': {},
+            'related2': {},
+            'one_to_one': {},
+        },
+        'related1': {},
+        'related2': {
+            'related21': {},
+        },
+        'one_to_one': {},
+    }
+    assert set(qs._prefetch_related_lookups) == {
+        'parent',
+        'parent__parent',
+        'parent__reverse_OtM',
+        'parent__reverse_OtO',
+        'parent__through',
+        'parent__related1',
+        'parent__related2',
+        'parent__one_to_one',
+        'parent__many_to_many',
+        'reverse_OtM',
+        'reverse_OtM__auto2',
+        'through',
+        'self__reverse_OtM',
+        'self__through',
+        'self__many_to_many',
+        'related1__r',
+        'many_to_many',
+    }
+    assert list(qs.all()) == []
+
+
+def test_nested_auto_building_filters_depth_3_described_and_exclusions():
+    class Cls(NestedAutoRQLFilterClass):
+        MODEL = AutoMain
+        DEPTH = 3
+        EXCLUDE_FILTERS = ('common_int', 'parent.parent', 'related1')
+        FILTERS = ({
+            'filter': 'random',
+            'source': 'id',
+        },)
+
+    filter_set = set(Cls(AutoMain.objects.all()).filters.keys())
+
+    assert {
+        'random',
+        'common_str',
+        'self.self.self.common_int',
+        'self.self.self.common_str',
+        'self.self.self.id',
+    }.issubset(filter_set)
+    assert {'parent.parent.id', 'related1.id', 'common_int'}.isdisjoint(filter_set)
