WIP.

Author: WaVEV

django_mongodb_backend/base.py

@@ -123,7 +123,7 @@ def _isnull_operator_match(a, b):
         "lte": lambda a, b: {
             "$and": [{"$lte": [a, b]}, DatabaseWrapper._isnull_operator(a, False)]
         },
-        "in": lambda a, b: {"$in": [a, b]},
+        "in": lambda a, b: {"$in": (a, b)},
         "isnull": _isnull_operator,
         "range": lambda a, b: {
             "$and": [
@@ -165,7 +165,7 @@ def range_match(a, b):
         "lte": lambda a, b: {
             "$and": [{a: {"$lte": b}}, DatabaseWrapper._isnull_operator_match(a, False)]
         },
-        "in": lambda a, b: {a: {"$in": list(b)}},
+        "in": lambda a, b: {a: {"$in": tuple(b)}},
         "isnull": _isnull_operator_match,
         "range": range_match,
         "iexact": lambda a, b: regex_match(a, f"^{b}$", insensitive=True),

django_mongodb_backend/expressions/builtins.py

@@ -203,9 +203,7 @@ def when(self, compiler, connection, **extra):
 
 def value(self, compiler, connection, as_path=False):  # noqa: ARG001
     value = self.value
-    if as_path:
-        return value
-    if isinstance(value, (list, int)):
+    if isinstance(value, (list, int)) and not as_path:
         # Wrap lists & numbers in $literal to prevent ambiguity when Value
         # appears in $project.
         return {"$literal": value}

django_mongodb_backend/features.py

@@ -90,9 +90,6 @@ class DatabaseFeatures(GISFeatures, BaseDatabaseFeatures):
         "auth_tests.test_views.LoginTest.test_login_session_without_hash_session_key",
         # GenericRelation.value_to_string() assumes integer pk.
         "contenttypes_tests.test_fields.GenericRelationTests.test_value_to_string",
-        # icontains doesn't work on ArrayField:
-        # Unsupported conversion from array to string in $convert
-        "model_fields_.test_arrayfield.QueryingTests.test_icontains",
         # ArrayField's contained_by lookup crashes with Exists: "both operands "
         # of $setIsSubset must be arrays. Second argument is of type: null"
         # https://jira.mongodb.org/browse/SERVER-99186

django_mongodb_backend/fields/array.py

@@ -231,8 +231,11 @@ def formfield(self, **kwargs):
 
 
 class Array(Func):
-    def as_mql(self, compiler, connection):
-        return [expr.as_mql(compiler, connection) for expr in self.get_source_expressions()]
+    def as_mql(self, compiler, connection, as_path=False):
+        return [
+            expr.as_mql(compiler, connection, as_path=as_path)
+            for expr in self.get_source_expressions()
+        ]
 
 
 class ArrayRHSMixin:
@@ -253,6 +256,12 @@ class ArrayContains(ArrayRHSMixin, FieldGetDbPrepValueMixin, Lookup):
     lookup_name = "contains"
 
     def as_mql(self, compiler, connection, as_path=False):
+        if as_path and is_simple_column(self.lhs) and is_constant_value(self.rhs):
+            lhs_mql = process_lhs(self, compiler, connection, as_path=as_path)
+            value = process_rhs(self, compiler, connection, as_path=as_path)
+            if value is None:
+                return False
+            return {lhs_mql: {"$all": value}}
         lhs_mql = process_lhs(self, compiler, connection, as_path=False)
         value = process_rhs(self, compiler, connection, as_path=False)
         return {
@@ -271,25 +280,16 @@ class ArrayContainedBy(ArrayRHSMixin, FieldGetDbPrepValueMixin, Lookup):
     lookup_name = "contained_by"
 
     def as_mql(self, compiler, connection, as_path=False):
-        if as_path and is_simple_column(self.lhs) and is_constant_value(self.rhs):
-            lhs_mql = process_lhs(self, compiler, connection, as_path=as_path)
-            value = process_rhs(self, compiler, connection, as_path=as_path)
-            return {
-                "$and": [
-                    # {lhs_mql: {"$ne": None}},
-                    {value: {"$ne": None}},
-                    {lhs_mql: {"$all": value}},
-                ]
-            }
-
         lhs_mql = process_lhs(self, compiler, connection, as_path=False)
         value = process_rhs(self, compiler, connection, as_path=False)
         return {
-            "$and": [
-                {"$ne": [lhs_mql, None]},
-                {"$ne": [value, None]},
-                {"$setIsSubset": [lhs_mql, value]},
-            ]
+            "$expr": {
+                "$and": [
+                    {"$ne": [lhs_mql, None]},
+                    {"$ne": [value, None]},
+                    {"$setIsSubset": [lhs_mql, value]},
+                ]
+            }
         }
 
 
@@ -337,11 +337,21 @@ def get_subquery_wrapping_pipeline(self, compiler, connection, field_name, expr)
             },
         ]
 
-    def as_mql(self, compiler, connection):
-        lhs_mql = process_lhs(self, compiler, connection)
-        value = process_rhs(self, compiler, connection)
+    def as_mql(self, compiler, connection, as_path=False):
+        if as_path and is_simple_column(self.lhs) and is_constant_value(self.rhs):
+            lhs_mql = process_lhs(self, compiler, connection, as_path=True)
+            value = process_rhs(self, compiler, connection, as_path=True)
+            return {lhs_mql: {"$in": value}}
+
+        lhs_mql = process_lhs(self, compiler, connection, as_path=False)
+        value = process_rhs(self, compiler, connection, as_path=False)
         return {
-            "$and": [{"$ne": [lhs_mql, None]}, {"$size": {"$setIntersection": [value, lhs_mql]}}]
+            "$expr": {
+                "$and": [
+                    {"$ne": [lhs_mql, None]},
+                    {"$size": {"$setIntersection": [value, lhs_mql]}},
+                ]
+            }
         }
 
 
@@ -350,8 +360,8 @@ class ArrayLenTransform(Transform):
     lookup_name = "len"
     output_field = IntegerField()
 
-    def as_mql(self, compiler, connection):
-        lhs_mql = process_lhs(self, compiler, connection)
+    def as_mql(self, compiler, connection, as_path=False):
+        lhs_mql = process_lhs(self, compiler, connection, as_path=False)
         return {"$cond": {"if": {"$isArray": lhs_mql}, "then": {"$size": lhs_mql}, "else": None}}
 
 
@@ -377,8 +387,10 @@ def __init__(self, index, base_field, *args, **kwargs):
         self.index = index
         self.base_field = base_field
 
-    def as_mql(self, compiler, connection):
-        lhs_mql = process_lhs(self, compiler, connection)
+    def as_mql(self, compiler, connection, as_path=False):
+        lhs_mql = process_lhs(self, compiler, connection, as_path=as_path)
+        if as_path:
+            return f"{lhs_mql}.{self.index}"
         return {"$arrayElemAt": [lhs_mql, self.index]}
 
     @property
@@ -401,7 +413,7 @@ def __init__(self, start, end, *args, **kwargs):
         self.start = start
         self.end = end
 
-    def as_mql(self, compiler, connection):
+    def as_mql(self, compiler, connection, as_path=False):
         lhs_mql = process_lhs(self, compiler, connection)
         return {"$slice": [lhs_mql, self.start, self.end]}
 

django_mongodb_backend/fields/embedded_model_array.py

@@ -75,7 +75,7 @@ def _get_lookup(self, lookup_name):
             return lookup
 
         class EmbeddedModelArrayFieldLookups(Lookup):
-            def as_mql(self, compiler, connection):
+            def as_mql(self, compiler, connection, as_path=False):
                 raise ValueError(
                     "Lookups aren't supported on EmbeddedModelArrayField. "
                     "Try querying one of its embedded fields instead."
@@ -114,7 +114,7 @@ def get_lookup(self, name):
 
 
 class EmbeddedModelArrayFieldBuiltinLookup(Lookup):
-    def process_rhs(self, compiler, connection):
+    def process_rhs(self, compiler, connection, as_path=False):
         value = self.rhs
         if not self.get_db_prep_lookup_value_is_iterable:
             value = [value]
@@ -128,17 +128,17 @@ def process_rhs(self, compiler, connection):
             for v in value
         ]
 
-    def as_mql(self, compiler, connection):
+    def as_mql(self, compiler, connection, as_path=False):
         # Querying a subfield within the array elements (via nested
         # KeyTransform). Replicate MongoDB's implicit ANY-match by mapping over
         # the array and applying $in on the subfield.
         lhs_mql = process_lhs(self, compiler, connection)
         inner_lhs_mql = lhs_mql["$ifNull"][0]["$map"]["in"]
         values = process_rhs(self, compiler, connection)
-        lhs_mql["$ifNull"][0]["$map"]["in"] = connection.mongo_operators[self.lookup_name](
+        lhs_mql["$ifNull"][0]["$map"]["in"] = connection.mongo_operators_expr[self.lookup_name](
             inner_lhs_mql, values
         )
-        return {"$anyElementTrue": lhs_mql}
+        return {"$expr": {"$anyElementTrue": lhs_mql}}
 
 
 @_EmbeddedModelArrayOutputField.register_lookup
@@ -275,7 +275,11 @@ def get_transform(self, name):
             f"{suggestion}"
         )
 
-    def as_mql(self, compiler, connection):
+    def as_mql(self, compiler, connection, as_path=False):
+        if as_path:
+            inner_lhs_mql = self._lhs.as_mql(compiler, connection, as_path=True)
+            lhs_mql = process_lhs(self, compiler, connection, as_path=True)
+            return f"{inner_lhs_mql}.{lhs_mql}"
         inner_lhs_mql = self._lhs.as_mql(compiler, connection)
         lhs_mql = process_lhs(self, compiler, connection)
         return {

django_mongodb_backend/fields/polymorphic_embedded_model_array.py

@@ -70,7 +70,7 @@ def _get_lookup(self, lookup_name):
             return lookup
 
         class EmbeddedModelArrayFieldLookups(Lookup):
-            def as_mql(self, compiler, connection):
+            def as_mql(self, compiler, connection, as_path=False):
                 raise ValueError(
                     "Lookups aren't supported on PolymorphicEmbeddedModelArrayField. "
                     "Try querying one of its embedded fields instead."

django_mongodb_backend/functions.py

@@ -39,6 +39,7 @@
     Upper,
 )
 
+from .lookups import is_constant_value
 from .query_utils import process_lhs
 
 MONGO_OPERATORS = {
@@ -84,18 +85,18 @@ def cast(self, compiler, connection, **extra):  # noqa: ARG001
     return lhs_mql
 
 
-def concat(self, compiler, connection):
-    return self.get_source_expressions()[0].as_mql(compiler, connection)
+def concat(self, compiler, connection, as_path=False):
+    return self.get_source_expressions()[0].as_mql(compiler, connection, as_path=as_path)
 
 
-def concat_pair(self, compiler, connection):
+def concat_pair(self, compiler, connection, as_path=False):  # noqa: ARG001
     # null on either side results in null for expression, wrap with coalesce.
     coalesced = self.coalesce()
-    return super(ConcatPair, coalesced).as_mql(compiler, connection)
+    return super(ConcatPair, coalesced).as_mql(compiler, connection, as_path=False)
 
 
-def cot(self, compiler, connection):
-    lhs_mql = process_lhs(self, compiler, connection)
+def cot(self, compiler, connection, as_path=False):  # noqa: ARG001
+    lhs_mql = process_lhs(self, compiler, connection, as_path=False)
     return {"$divide": [1, {"$tan": lhs_mql}]}
 
 
@@ -117,8 +118,8 @@ def func(self, compiler, connection, **extra):  # noqa: ARG001
     return {f"${operator}": lhs_mql}
 
 
-def left(self, compiler, connection):
-    return self.get_substr().as_mql(compiler, connection)
+def left(self, compiler, connection, as_path=False):  # noqa: ARG001
+    return self.get_substr().as_mql(compiler, connection, as_path=False)
 
 
 def length(self, compiler, connection, as_path=False):  # noqa: ARG001
@@ -127,28 +128,35 @@ def length(self, compiler, connection, as_path=False):  # noqa: ARG001
     return {"$cond": {"if": {"$eq": [lhs_mql, None]}, "then": None, "else": {"$strLenCP": lhs_mql}}}
 
 
-def log(self, compiler, connection):
+def log(self, compiler, connection, as_path=False):  # noqa: ARG001
     # This function is usually log(base, num) but on MongoDB it's log(num, base).
     clone = self.copy()
     clone.set_source_expressions(self.get_source_expressions()[::-1])
     return func(clone, compiler, connection)
 
 
-def now(self, compiler, connection):  # noqa: ARG001
+def now(self, compiler, connection, as_path=False):  # noqa: ARG001
     return "$$NOW"
 
 
-def null_if(self, compiler, connection):
+def null_if(self, compiler, connection, as_path=False):  # noqa: ARG001
     """Return None if expr1==expr2 else expr1."""
-    expr1, expr2 = (expr.as_mql(compiler, connection) for expr in self.get_source_expressions())
+    expr1, expr2 = (
+        expr.as_mql(compiler, connection, as_path=False) for expr in self.get_source_expressions()
+    )
     return {"$cond": {"if": {"$eq": [expr1, expr2]}, "then": None, "else": expr1}}
 
 
 def preserve_null(operator):
     # If the argument is null, the function should return null, not
     # $toLower/Upper's behavior of returning an empty string.
-    def wrapped(self, compiler, connection):
-        lhs_mql = process_lhs(self, compiler, connection)
+    def wrapped(self, compiler, connection, as_path=False):
+        if is_constant_value(self.lhs) and as_path:
+            if self.lhs is None:
+                return None
+            lhs_mql = process_lhs(self, compiler, connection, as_path=True)
+            return lhs_mql.upper()
+        lhs_mql = process_lhs(self, compiler, connection, as_path=False)
         return {
             "$expr": {
                 "$cond": {
@@ -162,24 +170,29 @@ def wrapped(self, compiler, connection):
     return wrapped
 
 
-def replace(self, compiler, connection):
-    expression, text, replacement = process_lhs(self, compiler, connection)
+def replace(self, compiler, connection, as_path=False):
+    expression, text, replacement = process_lhs(self, compiler, connection, as_path=as_path)
     return {"$replaceAll": {"input": expression, "find": text, "replacement": replacement}}
 
 
-def round_(self, compiler, connection):
+def round_(self, compiler, connection, as_path=False):  # noqa: ARG001
     # Round needs its own function because it's a special case that inherits
     # from Transform but has two arguments.
-    return {"$round": [expr.as_mql(compiler, connection) for expr in self.get_source_expressions()]}
+    return {
+        "$round": [
+            expr.as_mql(compiler, connection, as_path=False)
+            for expr in self.get_source_expressions()
+        ]
+    }
 
 
-def str_index(self, compiler, connection):
+def str_index(self, compiler, connection, as_path=False):  # noqa: ARG001
     lhs = process_lhs(self, compiler, connection)
     # StrIndex should be 0-indexed (not found) but it's -1-indexed on MongoDB.
     return {"$add": [{"$indexOfCP": lhs}, 1]}
 
 
-def substr(self, compiler, connection, **extra):  # noqa: ARG001
+def substr(self, compiler, connection, as_path=False):  # noqa: ARG001
     lhs = process_lhs(self, compiler, connection)
     # The starting index is zero-indexed on MongoDB rather than one-indexed.
     lhs[1] = {"$add": [lhs[1], -1]}
@@ -191,14 +204,14 @@ def substr(self, compiler, connection, **extra):  # noqa: ARG001
 
 
 def trim(operator):
-    def wrapped(self, compiler, connection):
+    def wrapped(self, compiler, connection, as_path=False):  # noqa: ARG001
         lhs = process_lhs(self, compiler, connection)
         return {f"${operator}": {"input": lhs}}
 
     return wrapped
 
 
-def trunc(self, compiler, connection, **extra):  # noqa: ARG001
+def trunc(self, compiler, connection, as_path=False):  # noqa: ARG001
     lhs_mql = process_lhs(self, compiler, connection)
     lhs_mql = {"date": lhs_mql, "unit": self.kind, "startOfWeek": "mon"}
     if timezone := self.get_tzname():
@@ -257,11 +270,11 @@ def trunc_date(self, compiler, connection, **extra):  # noqa: ARG001
     }
 
 
-def trunc_time(self, compiler, connection):
+def trunc_time(self, compiler, connection, as_path=False):  # noqa: ARG001
     tzname = self.get_tzname()
     if tzname and tzname != "UTC":
         raise NotSupportedError(f"TruncTime with tzinfo ({tzname}) isn't supported on MongoDB.")
-    lhs_mql = process_lhs(self, compiler, connection)
+    lhs_mql = process_lhs(self, compiler, connection, as_path=False)
     return {
         "$dateFromString": {
             "dateString": {