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,
@@ -128,7 +129,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 = [
@@ -582,14 +583,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."""