Add mql check in EMF and EMFA unit test and handle empty set or full set in range queries.

Author: WaVEV

django_mongodb_backend/base.py

@@ -2,7 +2,8 @@
 import logging
 import os
 
-from django.core.exceptions import ImproperlyConfigured
+from bson import Decimal128
+from django.core.exceptions import EmptyResultSet, FullResultSet, ImproperlyConfigured
 from django.db import DEFAULT_DB_ALIAS
 from django.db.backends.base.base import BaseDatabaseWrapper
 from django.db.backends.utils import debug_transaction
@@ -143,14 +144,21 @@ def _isnull_operator_match(a, b):
     }
 
     def range_match(a, b):
-        ## TODO: MAKE A TEST TO TEST WHEN BOTH ENDS ARE NONE. WHAT SHALL I RETURN?
         conditions = []
-        if b[0] is not None:
+        start, end = b
+        if start is not None:
             conditions.append({a: {"$gte": b[0]}})
-        if b[1] is not None:
+        if end is not None:
             conditions.append({a: {"$lte": b[1]}})
         if not conditions:
-            return {"$literal": True}
+            raise FullResultSet
+        if start is not None and end is not None:
+            if isinstance(start, Decimal128):
+                start = start.to_decimal()
+            if isinstance(end, Decimal128):
+                end = end.to_decimal()
+            if start > end:
+                raise EmptyResultSet
         return {"$and": conditions}
 
     # match, path, find? don't know which name use.

django_mongodb_backend/fields/json.py

@@ -175,13 +175,7 @@ def key_transform_is_null_expr(self, compiler, connection):
 
 def key_transform_is_null_path(self, compiler, connection):
     """
-    Return MQL to check the nullability of a key.
-
-    If `isnull=True`, the query matches objects where the key is missing or the
-    root column is null. If `isnull=False`, the query negates the result to
-    match objects where the key exists.
-
-    Reference: https://code.djangoproject.com/ticket/32252
+    Return MQL to check the nullability of a key using the operator $exists.
     """
     lhs_mql = process_lhs(self, compiler, connection, as_path=True)
     rhs_mql = process_rhs(self, compiler, connection, as_path=True)

django_mongodb_backend/test.py

@@ -1,6 +1,6 @@
 """Not a public API."""
 
-from bson import SON, ObjectId
+from bson import SON, Decimal128, ObjectId
 
 
 class MongoTestCaseMixin:
@@ -16,6 +16,6 @@ def assertAggregateQuery(self, query, expected_collection, expected_pipeline):
         self.assertEqual(operator, "aggregate")
         self.assertEqual(collection, expected_collection)
         self.assertEqual(
-            eval(pipeline[:-1], {"SON": SON, "ObjectId": ObjectId}, {}),  # noqa: S307
+            eval(pipeline[:-1], {"SON": SON, "ObjectId": ObjectId, "Decimal128": Decimal128}, {}),  # noqa: S307
             expected_pipeline,
         )

tests/lookup_/tests.py

@@ -1,23 +1,38 @@
+from bson import SON
 from django.test import TestCase
 
 from django_mongodb_backend.test import MongoTestCaseMixin
 
 from .models import Book, Number
 
 
-class NumericLookupTests(TestCase):
+class NumericLookupTests(MongoTestCaseMixin, TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.objs = Number.objects.bulk_create(Number(num=x) for x in range(5))
         # Null values should be excluded in less than queries.
-        Number.objects.create()
+        cls.null_number = Number.objects.create()
 
     def test_lt(self):
         self.assertQuerySetEqual(Number.objects.filter(num__lt=3), self.objs[:3])
 
     def test_lte(self):
         self.assertQuerySetEqual(Number.objects.filter(num__lte=3), self.objs[:4])
 
+    def test_empty_range(self):
+        with self.assertNumQueries(0):
+            self.assertQuerySetEqual(Number.objects.filter(num__range=[3, 1]), [])
+
+    def test_full_range(self):
+        with self.assertNumQueries(1) as ctx:
+            self.assertQuerySetEqual(
+                Number.objects.filter(num__range=[None, None]), [self.null_number, *self.objs]
+            )
+        query = ctx.captured_queries[0]["sql"]
+        self.assertAggregateQuery(
+            query, "lookup__number", [{"$addFields": {"num": "$num"}}, {"$sort": SON([("num", 1)])}]
+        )
+
 
 class RegexTests(MongoTestCaseMixin, TestCase):
     def test_mql(self):

tests/model_fields_/test_embedded_model.py

@@ -10,13 +10,14 @@
     Max,
     OuterRef,
     Sum,
+    Value,
 )
-from django.db.models.expressions import Value
 from django.test import SimpleTestCase, TestCase
 from django.test.utils import isolate_apps
 
 from django_mongodb_backend.fields import EmbeddedModelField
 from django_mongodb_backend.models import EmbeddedModel
+from django_mongodb_backend.test import MongoTestCaseMixin
 
 from .models import (
     Address,
@@ -131,7 +132,7 @@ def test_embedded_model_field_respects_db_column(self):
         self.assertEqual(query[0]["data"]["integer_"], 5)
 
 
-class QueryingTests(TestCase):
+class QueryingTests(MongoTestCaseMixin, TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.objs = [
@@ -585,14 +586,16 @@ def test_nested(self):
         )
         self.assertCountEqual(Book.objects.filter(author__address__city="NYC"), [obj])
 
-    def test_annotate(self):
+    def test_filter_by_simple_annotate(self):
         obj = Book.objects.create(
             author=Author(name="Shakespeare", age=55, address=Address(city="NYC", state="NY"))
         )
-        book_from_ny = (
-            Book.objects.annotate(city=F("author__address__city")).filter(city="NYC").first()
-        )
-        self.assertCountEqual(book_from_ny.city, obj.author.address.city)
+        with self.assertNumQueries(1) as ctx:
+            book_from_ny = (
+                Book.objects.annotate(city=F("author__address__city")).filter(city="NYC").first()
+            )
+            self.assertCountEqual(book_from_ny.city, obj.author.address.city)
+        self.assertIn("{'$match': {'author.address.city': 'NYC'}}", ctx.captured_queries[0]["sql"])
 
 
 class ArrayFieldTests(TestCase):

tests/model_fields_/test_embedded_model_array.py

@@ -11,6 +11,7 @@
 
 from django_mongodb_backend.fields import ArrayField, EmbeddedModelArrayField
 from django_mongodb_backend.models import EmbeddedModel
+from django_mongodb_backend.test import MongoTestCaseMixin
 
 from .models import Artifact, Audit, Exhibit, Movie, Restoration, Review, Section, Tour
 
@@ -85,7 +86,7 @@ def test_embedded_model_field_respects_db_column(self):
         self.assertEqual(query[0]["reviews"][0]["title_"], "Awesome")
 
 
-class QueryingTests(TestCase):
+class QueryingTests(MongoTestCaseMixin, TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.egypt = Exhibit.objects.create(
@@ -178,15 +179,55 @@ def setUpTestData(cls):
         cls.audit_2 = Audit.objects.create(section_number=2, reviewed=True)
         cls.audit_3 = Audit.objects.create(section_number=5, reviewed=False)
 
-    def test_exact(self):
-        self.assertCountEqual(
-            Exhibit.objects.filter(sections__number=1), [self.egypt, self.wonders]
+    def test_exact_expr(self):
+        with self.assertNumQueries(1) as ctx:
+            self.assertCountEqual(
+                Exhibit.objects.filter(sections__number=Value(2) - 1), [self.egypt, self.wonders]
+            )
+        query = ctx.captured_queries[0]["sql"]
+        self.assertAggregateQuery(
+            query,
+            "model_fields__exhibit",
+            [
+                {
+                    "$match": {
+                        "$expr": {
+                            "$anyElementTrue": {
+                                "$ifNull": [
+                                    {
+                                        "$map": {
+                                            "input": "$sections",
+                                            "as": "item",
+                                            "in": {
+                                                "$eq": [
+                                                    "$$item.number",
+                                                    {
+                                                        "$subtract": [
+                                                            {"$literal": 2},
+                                                            {"$literal": 1},
+                                                        ]
+                                                    },
+                                                ]
+                                            },
+                                        }
+                                    },
+                                    [],
+                                ]
+                            }
+                        }
+                    }
+                }
+            ],
         )
 
-    def test_array_index(self):
-        self.assertCountEqual(
-            Exhibit.objects.filter(sections__0__number=1),
-            [self.egypt, self.wonders],
+    def test_exact_path(self):
+        with self.assertNumQueries(1) as ctx:
+            self.assertCountEqual(
+                Exhibit.objects.filter(sections__number=1), [self.egypt, self.wonders]
+            )
+        query = ctx.captured_queries[0]["sql"]
+        self.assertAggregateQuery(
+            query, "model_fields__exhibit", [{"$match": {"sections.number": 1}}]
         )
 
     def test_array_index_expr(self):
@@ -316,8 +357,20 @@ def test_filter_unsupported_lookups_in_json(self):
             kwargs = {f"main_section__artifacts__metadata__origin__{lookup}": ["Pergamon", "Egypt"]}
             with CaptureQueriesContext(connection) as captured_queries:
                 self.assertCountEqual(Exhibit.objects.filter(**kwargs), [])
-            self.assertIn(
-                f"'main_section.artifacts.metadata.origin.{lookup}':", captured_queries[0]["sql"]
+            query = captured_queries[0]["sql"]
+            self.assertAggregateQuery(
+                query,
+                "model_fields__exhibit",
+                [
+                    {
+                        "$match": {
+                            f"main_section.artifacts.metadata.origin.{lookup}": [
+                                "Pergamon",
+                                "Egypt",
+                            ]
+                        }
+                    }
+                ],
             )
 
     def test_len(self):
@@ -421,10 +474,12 @@ def test_nested_lookup(self):
         with self.assertRaisesMessage(ValueError, msg):
             Exhibit.objects.filter(sections__artifacts__name="")
 
-    def test_foreign_field_exact(self):
+    def test_foreign_field_exact_path(self):
         """Querying from a foreign key to an EmbeddedModelArrayField."""
-        qs = Tour.objects.filter(exhibit__sections__number=1)
-        self.assertCountEqual(qs, [self.egypt_tour, self.wonders_tour])
+        with self.assertNumQueries(1) as ctx:
+            qs = Tour.objects.filter(exhibit__sections__number=1)
+            self.assertCountEqual(qs, [self.egypt_tour, self.wonders_tour])
+        self.assertNotIn("anyElementTrue", ctx.captured_queries[0]["sql"])
 
     def test_foreign_field_exact_expr(self):
         """Querying from a foreign key to an EmbeddedModelArrayField."""