Object-oriented approach solution

Author: WaVEV

django_mongodb_backend/aggregates.py

@@ -8,14 +8,7 @@
 MONGO_AGGREGATIONS = {Count: "sum"}
 
 
-def aggregate(
-    self,
-    compiler,
-    connection,
-    operator=None,
-    resolve_inner_expression=False,
-    **extra_context,  # noqa: ARG001
-):
+def aggregate(self, compiler, connection, operator=None, resolve_inner_expression=False):
     if self.filter:
         node = self.copy()
         node.filter = None
@@ -31,7 +24,7 @@ def aggregate(
     return {f"${operator}": lhs_mql}
 
 
-def count(self, compiler, connection, resolve_inner_expression=False, **extra_context):  # noqa: ARG001
+def count(self, compiler, connection, resolve_inner_expression=False):
     """
     When resolve_inner_expression=True, return the MQL that resolves as a
     value. This is used to count different elements, so the inner values are
@@ -64,16 +57,16 @@ def count(self, compiler, connection, resolve_inner_expression=False, **extra_co
     return {"$add": [{"$size": lhs_mql}, exits_null]}
 
 
-def stddev_variance(self, compiler, connection, **extra_context):
+def stddev_variance(self, compiler, connection):
     if self.function.endswith("_SAMP"):
         operator = "stdDevSamp"
     elif self.function.endswith("_POP"):
         operator = "stdDevPop"
-    return aggregate(self, compiler, connection, operator=operator, **extra_context)
+    return aggregate(self, compiler, connection, operator=operator)
 
 
 def register_aggregates():
-    Aggregate.as_mql = aggregate
-    Count.as_mql = count
-    StdDev.as_mql = stddev_variance
-    Variance.as_mql = stddev_variance
+    Aggregate.as_mql_expr = aggregate
+    Count.as_mql_expr = count
+    StdDev.as_mql_expr = stddev_variance
+    Variance.as_mql_expr = stddev_variance

django_mongodb_backend/compiler.py

@@ -709,7 +709,7 @@ 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_path=False)
+                    else expr.as_mql(self, self.connection)
                 )
             except EmptyResultSet:
                 empty_result_set_value = getattr(expr, "empty_result_set_value", NotImplemented)

django_mongodb_backend/expressions/builtins.py

@@ -14,7 +14,6 @@
     Exists,
     ExpressionList,
     ExpressionWrapper,
-    Func,
     NegatedExpression,
     OrderBy,
     RawSQL,
@@ -25,14 +24,12 @@
     Value,
     When,
 )
-from django.db.models.fields.json import KeyTransform
 from django.db.models.sql import Query
 
-from django_mongodb_backend.fields.array import Array
-from django_mongodb_backend.query_utils import is_direct_value, process_lhs
+from django_mongodb_backend.query_utils import process_lhs
 
 
-def case(self, compiler, connection, as_path=False):
+def case(self, compiler, connection):
     case_parts = []
     for case in self.cases:
         case_mql = {}
@@ -49,16 +46,12 @@ def case(self, compiler, connection, as_path=False):
         default_mql = self.default.as_mql(compiler, connection)
     if not case_parts:
         return default_mql
-    expr = {
+    return {
         "$switch": {
             "branches": case_parts,
             "default": default_mql,
         }
     }
-    if as_path:
-        return {"$expr": expr}
-
-    return expr
 
 
 def col(self, compiler, connection, as_path=False):  # noqa: ARG001
@@ -99,12 +92,12 @@ def combined_expression(self, compiler, connection, as_path=False):
     return connection.ops.combine_expression(self.connector, expressions)
 
 
-def expression_wrapper(self, compiler, connection, as_path=False):
-    return self.expression.as_mql(compiler, connection, as_path=as_path)
+def expression_wrapper_expr(self, compiler, connection):
+    return self.expression.as_mql(compiler, connection, as_path=False)
 
 
-def negated_expression(self, compiler, connection, as_path=False):
-    return {"$not": expression_wrapper(self, compiler, connection, as_path=as_path)}
+def negated_expression_expr(self, compiler, connection):
+    return {"$not": expression_wrapper_expr(self, compiler, connection)}
 
 
 def order_by(self, compiler, connection):
@@ -177,32 +170,26 @@ def ref(self, compiler, connection, as_path=False):  # noqa: ARG001
     return f"{prefix}{refs}"
 
 
-def star(self, compiler, connection, **extra):  # noqa: ARG001
+@property
+def ref_is_simple_column(self):
+    return isinstance(self.source, Col) and self.source.alias is not None
+
+
+def star(self, compiler, connection, as_path=False):  # noqa: ARG001
     return {"$literal": True}
 
 
-def subquery(self, compiler, connection, get_wrapping_pipeline=None, as_path=False):
-    expr = self.query.as_mql(
+def subquery(self, compiler, connection, get_wrapping_pipeline=None):
+    return self.query.as_mql(
         compiler, connection, get_wrapping_pipeline=get_wrapping_pipeline, as_path=False
     )
-    if as_path:
-        return {"$expr": expr}
-    return expr
 
 
-def exists(self, compiler, connection, get_wrapping_pipeline=None, as_path=False):
+def exists(self, compiler, connection, get_wrapping_pipeline=None):
     try:
-        lhs_mql = subquery(
-            self,
-            compiler,
-            connection,
-            get_wrapping_pipeline=get_wrapping_pipeline,
-            as_path=as_path,
-        )
+        lhs_mql = subquery(self, compiler, connection, get_wrapping_pipeline=get_wrapping_pipeline)
     except EmptyResultSet:
         return Value(False).as_mql(compiler, connection)
-    if as_path:
-        return {"$expr": connection.mongo_operators_match["isnull"](lhs_mql, False)}
     return connection.mongo_operators_expr["isnull"](lhs_mql, False)
 
 
@@ -234,54 +221,37 @@ def value(self, compiler, connection, as_path=False):  # noqa: ARG001
     return value
 
 
-@staticmethod
-def _is_constant_value(value):
-    if isinstance(value, list | Array):
-        iterable = value.get_source_expressions() if isinstance(value, Array) else value
-        return all(_is_constant_value(e) for e in iterable)
-    if is_direct_value(value):
-        return True
-    return isinstance(value, Func | Value) and not (
-        value.contains_aggregate
-        or value.contains_over_clause
-        or value.contains_column_references
-        or value.contains_subquery
-    )
-
-
-@staticmethod
-def _is_simple_column(lhs):
-    while isinstance(lhs, KeyTransform):
-        if "." in getattr(lhs, "key_name", ""):
-            return False
-        lhs = lhs.lhs
-    col = lhs.source if isinstance(lhs, Ref) else lhs
-    # Foreign columns from parent cannot be addressed as single match
-    return isinstance(col, Col) and col.alias is not None
-
+def base_expression(self, compiler, connection, as_path=False, **extra):
+    if (
+        as_path
+        and hasattr(self, "as_mql_path")
+        and getattr(self, "is_simple_expression", lambda: False)()
+    ):
+        return self.as_mql_path(compiler, connection, **extra)
 
-def _is_simple_expression(self):
-    return self.is_simple_column(self.lhs) and self.is_constant_value(self.rhs)
+    expr = self.as_mql_expr(compiler, connection, **extra)
+    return {"$expr": expr} if as_path else expr
 
 
 def register_expressions():
-    Case.as_mql = case
+    BaseExpression.as_mql = base_expression
+    BaseExpression.is_simple_column = False
+    Case.as_mql_expr = case
     Col.as_mql = col
+    Col.is_simple_column = True
     ColPairs.as_mql = col_pairs
-    CombinedExpression.as_mql = combined_expression
-    Exists.as_mql = exists
+    CombinedExpression.as_mql_expr = combined_expression
+    Exists.as_mql_expr = exists
     ExpressionList.as_mql = process_lhs
-    ExpressionWrapper.as_mql = expression_wrapper
-    NegatedExpression.as_mql = negated_expression
-    OrderBy.as_mql = order_by
+    ExpressionWrapper.as_mql_expr = expression_wrapper_expr
+    NegatedExpression.as_mql_expr = negated_expression_expr
+    OrderBy.as_mql_expr = order_by
     Query.as_mql = query
     RawSQL.as_mql = raw_sql
     Ref.as_mql = ref
+    Ref.is_simple_column = ref_is_simple_column
     ResolvedOuterRef.as_mql = ResolvedOuterRef.as_sql
     Star.as_mql = star
-    Subquery.as_mql = subquery
+    Subquery.as_mql_expr = subquery
     When.as_mql = when
     Value.as_mql = value
-    BaseExpression.is_simple_expression = _is_simple_expression
-    BaseExpression.is_simple_column = _is_simple_column
-    BaseExpression.is_constant_value = _is_constant_value

django_mongodb_backend/expressions/search.py

@@ -933,12 +933,15 @@ def __str__(self):
     def __repr__(self):
         return f"SearchText({self.lhs}, {self.rhs})"
 
-    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]}}
+    def as_mql_expr(self, compiler, connection):
+        lhs_mql = process_lhs(self, compiler, connection, as_path=False)
+        value = process_rhs(self, compiler, connection, as_path=False)
+        return {"$gte": [lhs_mql, value]}
+
+    def as_mql_path(self, compiler, connection):
+        lhs_mql = process_lhs(self, compiler, connection, as_path=True)
+        value = process_rhs(self, compiler, connection, as_path=True)
+        return {lhs_mql: {"$gte": value}}
 
 
 CharField.register_lookup(SearchTextLookup)