WIP.

Author: WaVEV

django_mongodb_backend/base.py

@@ -142,6 +142,17 @@ def _isnull_operator_match(a, b):
         "iregex": lambda a, b: regex_expr(a, b, insensitive=True),
     }
 
+    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:
+            conditions.append({a: {"$gte": b[0]}})
+        if b[1] is not None:
+            conditions.append({a: {"$lte": b[1]}})
+        if not conditions:
+            return {"$literal": True}
+        return {"$and": conditions}
+
     mongo_operators_match = {
         "exact": lambda a, b: {a: b},
         "gt": lambda a, b: {a: {"$gt": b}},
@@ -156,12 +167,7 @@ def _isnull_operator_match(a, b):
         },
         "in": lambda a, b: {a: {"$in": list(b)}},
         "isnull": _isnull_operator_match,
-        "range": lambda a, b: {
-            "$and": [
-                {"$or": [DatabaseWrapper._isnull_operator_match(b[0], True), {a: {"$gte": b[0]}}]},
-                {"$or": [DatabaseWrapper._isnull_operator_match(b[1], True), {a: {"$lte": b[1]}}]},
-            ]
-        },
+        "range": range_match,
         "iexact": lambda a, b: regex_match(a, f"^{b}$", insensitive=True),
         "startswith": lambda a, b: regex_match(a, f"^{b}"),
         "istartswith": lambda a, b: regex_match(a, f"^{b}", insensitive=True),

django_mongodb_backend/compiler.py

@@ -707,16 +707,16 @@ def get_project_fields(self, columns=None, ordering=None, force_expression=False
                     # For brevity/simplicity, project {"field_name": 1}
                     # instead of {"field_name": "$field_name"}.
                     if isinstance(expr, Col) and name == expr.target.column and not force_expression
-                    else expr.as_mql(self, self.connection, as_expr=force_expression)
+                    else expr.as_mql(self, self.connection, as_path=False)
                 )
             except EmptyResultSet:
                 empty_result_set_value = getattr(expr, "empty_result_set_value", NotImplemented)
                 value = (
                     False if empty_result_set_value is NotImplemented else empty_result_set_value
                 )
-                fields[collection][name] = Value(value).as_mql(self, self.connection)
+                fields[collection][name] = Value(value).as_mql(self, self.connection, as_path=False)
             except FullResultSet:
-                fields[collection][name] = Value(True).as_mql(self, self.connection)
+                fields[collection][name] = Value(True).as_mql(self, self.connection, as_path=False)
         # Annotations (stored in None) and the main collection's fields
         # should appear in the top-level of the fields dict.
         fields.update(fields.pop(None, {}))

django_mongodb_backend/expressions/builtins.py

@@ -34,7 +34,7 @@ def case(self, compiler, connection, **extra):  # noqa: ARG001
     for case in self.cases:
         case_mql = {}
         try:
-            case_mql["case"] = case.as_mql(compiler, connection, as_expr=True)
+            case_mql["case"] = case.as_mql(compiler, connection, as_path=False)
         except EmptyResultSet:
             continue
         except FullResultSet:
@@ -54,7 +54,7 @@ def case(self, compiler, connection, **extra):  # noqa: ARG001
     }
 
 
-def col(self, compiler, connection, as_path=False, as_expr=None):  # noqa: ARG001
+def col(self, compiler, connection, as_path=False):  # noqa: ARG001
     # If the column is part of a subquery and belongs to one of the parent
     # queries, it will be stored for reference using $let in a $lookup stage.
     # If the query is built with `alias_cols=False`, treat the column as
@@ -72,16 +72,16 @@ def col(self, compiler, connection, as_path=False, as_expr=None):  # noqa: ARG00
     # Add the column's collection's alias for columns in joined collections.
     has_alias = self.alias and self.alias != compiler.collection_name
     prefix = f"{self.alias}." if has_alias else ""
-    if not as_path or as_expr:
+    if not as_path:
         prefix = f"${prefix}"
     return f"{prefix}{self.target.column}"
 
 
-def col_pairs(self, compiler, connection):
+def col_pairs(self, compiler, connection, as_path=False):
     cols = self.get_cols()
     if len(cols) > 1:
         raise NotSupportedError("ColPairs is not supported.")
-    return cols[0].as_mql(compiler, connection)
+    return cols[0].as_mql(compiler, connection, as_path=as_path)
 
 
 def combined_expression(self, compiler, connection, **extra):
@@ -96,15 +96,15 @@ def expression_wrapper(self, compiler, connection, **extra):
     return self.expression.as_mql(compiler, connection, **extra)
 
 
-def negated_expression(self, compiler, connection):
-    return {"$not": expression_wrapper(self, compiler, connection)}
+def negated_expression(self, compiler, connection, **extra):
+    return {"$not": expression_wrapper(self, compiler, connection, **extra)}
 
 
 def order_by(self, compiler, connection):
     return self.expression.as_mql(compiler, connection)
 
 
-def query(self, compiler, connection, get_wrapping_pipeline=None, as_path=False, as_expr=None):
+def query(self, compiler, connection, get_wrapping_pipeline=None, as_path=False):
     subquery_compiler = self.get_compiler(connection=connection)
     subquery_compiler.pre_sql_setup(with_col_aliases=False)
     field_name, expr = subquery_compiler.columns[0]
@@ -146,7 +146,7 @@ def query(self, compiler, connection, get_wrapping_pipeline=None, as_path=False,
         # Erase project_fields since the required value is projected above.
         subquery.project_fields = None
     compiler.subqueries.append(subquery)
-    if as_path and not as_expr:
+    if as_path:
         return f"{table_output}.{field_name}"
     return f"${table_output}.{field_name}"
 
@@ -201,8 +201,10 @@ def when(self, compiler, connection, **extra):
     return self.condition.as_mql(compiler, connection, **extra)
 
 
-def value(self, compiler, connection, **extra):  # noqa: ARG001
+def value(self, compiler, connection, as_path=False):  # noqa: ARG001
     value = self.value
+    if as_path:
+        return value
     if isinstance(value, (list, int)):
         # Wrap lists & numbers in $literal to prevent ambiguity when Value
         # appears in $project.

django_mongodb_backend/expressions/search.py

@@ -933,10 +933,12 @@ def __str__(self):
     def __repr__(self):
         return f"SearchText({self.lhs}, {self.rhs})"
 
-    def as_mql(self, compiler, connection):
-        lhs_mql = process_lhs(self, compiler, connection)
-        value = process_rhs(self, compiler, connection)
-        return {"$gte": [lhs_mql, value]}
+    def as_mql(self, compiler, connection, as_path=False):
+        lhs_mql = process_lhs(self, compiler, connection, as_path=as_path)
+        value = process_rhs(self, compiler, connection, as_path=as_path)
+        if as_path:
+            return {lhs_mql: {"$gte": value}}
+        return {"$expr": {"$gte": [lhs_mql, value]}}
 
 
 CharField.register_lookup(SearchTextLookup)

django_mongodb_backend/fields/array.py

@@ -7,6 +7,7 @@
 from django.utils.translation import gettext_lazy as _
 
 from ..forms import SimpleArrayField
+from ..lookups import is_constant_value, is_simple_column
 from ..query_utils import process_lhs, process_rhs
 from ..utils import prefix_validation_error
 from ..validators import ArrayMaxLengthValidator, LengthValidator
@@ -251,25 +252,38 @@ def __init__(self, lhs, rhs):
 class ArrayContains(ArrayRHSMixin, FieldGetDbPrepValueMixin, Lookup):
     lookup_name = "contains"
 
-    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):
+        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": [value, lhs_mql]},
-            ]
+            "$expr": {
+                "$and": [
+                    {"$ne": [lhs_mql, None]},
+                    {"$ne": [value, None]},
+                    {"$setIsSubset": [value, lhs_mql]},
+                ]
+            }
         }
 
 
 @ArrayField.register_lookup
 class ArrayContainedBy(ArrayRHSMixin, FieldGetDbPrepValueMixin, Lookup):
     lookup_name = "contained_by"
 
-    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=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]},