Handle empty set or full set in range queries.

Author: WaVEV

django_mongodb_backend/base.py

@@ -2,7 +2,7 @@
 import logging
 import os
 
-from django.core.exceptions import ImproperlyConfigured
+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 +143,16 @@ 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 start is not None and end is not None and start > end:
+            raise EmptyResultSet
         if not conditions:
-            return {"$literal": True}
+            raise FullResultSet
         return {"$and": conditions}
 
     # match, path, find? don't know which name use.

django_mongodb_backend/fields/json.py

@@ -183,6 +183,15 @@ def key_transform_in_path(self, compiler, connection):
 
 
 def key_transform_is_null_expr(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
+    """
     previous = self.lhs
     while isinstance(previous, KeyTransform):
         previous = previous.lhs
@@ -194,13 +203,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)

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

@@ -225,14 +225,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

@@ -286,10 +286,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."""