Change operators for expression in lookups.

Author: WaVEV

django_mongodb/base.py

@@ -12,7 +12,7 @@
 from .features import DatabaseFeatures
 from .introspection import DatabaseIntrospection
 from .operations import DatabaseOperations
-from .query_utils import safe_regex
+from .query_utils import regex_match_expression
 from .schema import DatabaseSchemaEditor
 from .utils import CollectionDebugWrapper
 
@@ -74,30 +74,23 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         "iendswith": "LIKE UPPER(%s)",
     }
     mongo_operators = {
-        "exact": lambda val: val,
-        "gt": lambda val: {"$gt": val},
-        "gte": lambda val: {"$gte": val},
-        "lt": lambda val: {"$lt": val},
-        "lte": lambda val: {"$lte": val},
-        "in": lambda val: {"$in": val},
-        "range": lambda val: {"$gte": val[0], "$lte": val[1]},
-        "isnull": lambda val: None if val else {"$ne": None},
-        "iexact": safe_regex("^%s$", re.IGNORECASE),
-        "startswith": safe_regex("^%s"),
-        "istartswith": safe_regex("^%s", re.IGNORECASE),
-        "endswith": safe_regex("%s$"),
-        "iendswith": safe_regex("%s$", re.IGNORECASE),
-        "contains": safe_regex("%s"),
-        "icontains": safe_regex("%s", re.IGNORECASE),
-        "regex": lambda val: re.compile(val),
-        "iregex": lambda val: re.compile(val, re.IGNORECASE),
-    }
-    mongo_aggregations = {
         "exact": lambda a, b: {"$eq": [a, b]},
         "gt": lambda a, b: {"$gt": [a, b]},
         "gte": lambda a, b: {"$gte": [a, b]},
         "lt": lambda a, b: {"$lt": [a, b]},
         "lte": lambda a, b: {"$lte": [a, b]},
+        "in": lambda a, b: {"$in": [a, b]},
+        "isnull": lambda a, b: {"$eq" if b else "$ne": [a, None]},
+        "range": lambda a, b: {"$and": [{"$gte": [a, b[0]]}, {"$lte": [a, b[1]]}]},
+        "iexact": lambda a, b: regex_match_expression(a, b, "^%s$", re.IGNORECASE),
+        "startswith": lambda a, b: regex_match_expression(a, b, "^%s"),
+        "istartswith": lambda a, b: regex_match_expression(a, b, "^%s", re.IGNORECASE),
+        "endswith": lambda a, b: regex_match_expression(a, b, "%s$"),
+        "iendswith": lambda a, b: regex_match_expression(a, b, "%s$", re.IGNORECASE),
+        "contains": lambda a, b: regex_match_expression(a, b, "%s"),
+        "icontains": lambda a, b: regex_match_expression(a, b, "%s", re.IGNORECASE),
+        "regex": lambda a, b: regex_match_expression(a, "", f"{b}%s"),
+        "iregex": lambda a, b: regex_match_expression(a, "", f"{b}%s", re.IGNORECASE),
     }
 
     display_name = "MongoDB"

django_mongodb/compiler.py

@@ -138,7 +138,7 @@ def build_query(self, columns=None):
         self.setup_query()
         query = self.query_class(self, columns)
         try:
-            query.mongo_query = self.query.where.as_mql(self, self.connection)
+            query.mongo_query = {"$expr": self.query.where.as_mql(self, self.connection)}
         except FullResultSet:
             query.mongo_query = {}
         query.order_by(self._get_ordering())

django_mongodb/expressions.py

@@ -6,14 +6,9 @@ def col(self, compiler, connection):  # noqa: ARG001
 
 
 def value(self, compiler, connection):  # noqa: ARG001
-    return self.value
-
-
-def value_agg(self, compiler, connection):  # noqa: ARG001
     return {"$literal": self.value}
 
 
 def register_expressions():
     Col.as_mql = col
     Value.as_mql = value
-    Value.as_mql_agg = value_agg

django_mongodb/features.py

@@ -21,8 +21,6 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         # Database defaults not supported: bson.errors.InvalidDocument:
         # cannot encode object: <django.db.models.expressions.DatabaseDefault
         "basic.tests.ModelInstanceCreationTests.test_save_primary_with_db_default",
-        # Query for chained lookups not generated correctly.
-        "lookup.tests.LookupTests.test_chain_date_time_lookups",
         # 'NulledTransform' object has no attribute 'as_mql'.
         "lookup.tests.LookupTests.test_exact_none_transform",
         # "Save with update_fields did not affect any rows."
@@ -58,8 +56,6 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         "db_functions.datetime.test_extract_trunc.DateFunctionWithTimeZoneTests.test_trunc_timezone_applied_before_truncation",
         # Coalesce() with expressions doesn't generate correct query.
         "db_functions.comparison.test_coalesce.CoalesceTests.test_mixed_values",
-        # $and must be an array
-        "db_functions.tests.FunctionTests.test_function_as_filter",
         # pk__in=queryset doesn't work because subqueries aren't a thing in
         # MongoDB.
         "annotations.tests.NonAggregateAnnotationTestCase.test_annotation_and_alias_filter_in_subquery",
@@ -165,20 +161,16 @@ class DatabaseFeatures(BaseDatabaseFeatures):
             "annotations.tests.NonAggregateAnnotationTestCase.test_annotation_exists_none_query",
             "lookup.tests.LookupTests.test_exact_exists",
             "lookup.tests.LookupTests.test_nested_outerref_lhs",
-            "lookup.tests.LookupQueryingTests.test_filter_exists_lhs",
-            # QuerySet.alias(greater=GreaterThan(F("year"), 1910)).filter(greater=True)
-            # generates incorrect an incorrect query:
-            # {'$expr': {'$eq': [{'year': {'$gt': 1910}}, True]}}}
-            "lookup.tests.LookupQueryingTests.test_alias",
+            # QuerySet.alias() doesn't work.
+            "annotations.tests.AliasTests.test_basic_alias_f_transform_annotation",
+            "annotations.tests.NonAggregateAnnotationTestCase.test_annotation_and_alias_filter_in_subquery",
             # annotate() with combined expressions doesn't work:
             # 'WhereNode' object has no attribute 'field'
             "lookup.tests.LookupQueryingTests.test_combined_annotated_lookups_in_filter",
             "lookup.tests.LookupQueryingTests.test_combined_annotated_lookups_in_filter_false",
             "lookup.tests.LookupQueryingTests.test_combined_lookups",
             # Case not supported.
             "lookup.tests.LookupQueryingTests.test_conditional_expression",
-            # Using expression in filter() doesn't work.
-            "lookup.tests.LookupQueryingTests.test_filter_lookup_lhs",
             # Subquery not supported.
             "annotations.tests.NonAggregateAnnotationTestCase.test_empty_queryset_annotation",
             "db_functions.comparison.test_coalesce.CoalesceTests.test_empty_queryset",

django_mongodb/lookups.py

@@ -1,27 +1,14 @@
 from django.db import NotSupportedError
 from django.db.models.fields.related_lookups import In, MultiColSource, RelatedIn
-from django.db.models.lookups import BuiltinLookup, Exact, IsNull, UUIDTextMixin
+from django.db.models.lookups import BuiltinLookup, IsNull, UUIDTextMixin
 
 from .query_utils import process_lhs, process_rhs
 
 
 def builtin_lookup(self, compiler, connection):
-    lhs_mql = process_lhs(self, compiler, connection, bare_column_ref=True)
-    value = process_rhs(self, compiler, connection)
-    rhs_mql = connection.mongo_operators[self.lookup_name](value)
-    return {lhs_mql: rhs_mql}
-
-
-def builtin_lookup_agg(self, compiler, connection):
-    lhs_mql = process_lhs(self, compiler, connection)
-    value = process_rhs(self, compiler, connection)
-    return connection.mongo_aggregations[self.lookup_name](lhs_mql, value)
-
-
-def exact(self, compiler, connection):
     lhs_mql = process_lhs(self, compiler, connection)
     value = process_rhs(self, compiler, connection)
-    return {"$expr": {"$eq": [lhs_mql, value]}}
+    return connection.mongo_operators[self.lookup_name](lhs_mql, value)
 
 
 def in_(self, compiler, connection):
@@ -33,9 +20,8 @@ def in_(self, compiler, connection):
 def is_null(self, compiler, connection):
     if not isinstance(self.rhs, bool):
         raise ValueError("The QuerySet value for an isnull lookup must be True or False.")
-    lhs_mql = process_lhs(self, compiler, connection, bare_column_ref=True)
-    rhs_mql = connection.mongo_operators["isnull"](self.rhs)
-    return {lhs_mql: rhs_mql}
+    lhs_mql = process_lhs(self, compiler, connection)
+    return connection.mongo_operators["isnull"](lhs_mql, self.rhs)
 
 
 def uuid_text_mixin(self, compiler, connection):  # noqa: ARG001
@@ -44,8 +30,6 @@ def uuid_text_mixin(self, compiler, connection):  # noqa: ARG001
 
 def register_lookups():
     BuiltinLookup.as_mql = builtin_lookup
-    BuiltinLookup.as_mql_agg = builtin_lookup_agg
-    Exact.as_mql = exact
     In.as_mql = RelatedIn.as_mql = in_
     IsNull.as_mql = is_null
     UUIDTextMixin.as_mql = uuid_text_mixin

django_mongodb/query.py

@@ -91,8 +91,7 @@ def get_cursor(self):
                 column = expr.target.column
             except AttributeError:
                 # Generate the MQL for an annotation.
-                method = "as_mql_agg" if hasattr(expr, "as_mql_agg") else "as_mql"
-                fields[name] = getattr(expr, method)(self.compiler, self.connection)
+                fields[name] = expr.as_mql(self.compiler, self.connection)
             else:
                 # If name != column, then this is an annotatation referencing
                 # another column.
@@ -155,8 +154,7 @@ def where_node(self, compiler, connection):
         raise FullResultSet
 
     if self.negated and mql:
-        lhs, rhs = next(iter(mql.items()))
-        mql = {lhs: {"$not": rhs}}
+        mql = {"$eq": [mql, {"$literal": False}]}
 
     return mql
 

django_mongodb/query_utils.py

@@ -55,3 +55,17 @@ def wrapper(value):
 
     wrapper.__name__ = "safe_regex (%r)" % regex
     return wrapper
+
+
+def regex_match_expression(field, value, regex, *re_args, **re_kwargs):
+    regex = safe_regex(regex, *re_args, **re_kwargs)(value)
+    options = ""
+    if regex.flags & re.I:
+        options += "i"
+    if regex.flags & re.M:
+        options += "m"
+    if regex.flags & re.S:
+        options += "s"
+    # if regex.flags & re.U:
+    #     options += "u"
+    return {"$regexMatch": {"input": field, "regex": regex.pattern, "options": options}}