Clean ups.

Author: WaVEV

django_mongodb_backend/aggregates.py

@@ -8,7 +8,14 @@
 MONGO_AGGREGATIONS = {Count: "sum"}
 
 
-def aggregate(self, compiler, connection, operator=None, resolve_inner_expression=False):
+def aggregate(
+    self,
+    compiler,
+    connection,
+    operator=None,
+    resolve_inner_expression=False,
+    **extra_context,  # noqa: ARG001
+):
     if self.filter:
         node = self.copy()
         node.filter = None
@@ -24,7 +31,7 @@ def aggregate(self, compiler, connection, operator=None, resolve_inner_expressio
     return {f"${operator}": lhs_mql}
 
 
-def count(self, compiler, connection, resolve_inner_expression=False):
+def count(self, compiler, connection, resolve_inner_expression=False, **extra_context):  # noqa: ARG001
     """
     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
@@ -57,12 +64,12 @@ def count(self, compiler, connection, resolve_inner_expression=False):
     return {"$add": [{"$size": lhs_mql}, exits_null]}
 
 
-def stddev_variance(self, compiler, connection):
+def stddev_variance(self, compiler, connection, **extra_context):
     if self.function.endswith("_SAMP"):
         operator = "stdDevSamp"
     elif self.function.endswith("_POP"):
         operator = "stdDevPop"
-    return aggregate(self, compiler, connection, operator=operator)
+    return aggregate(self, compiler, connection, operator=operator, **extra_context)
 
 
 def register_aggregates():

django_mongodb_backend/base.py

@@ -113,7 +113,7 @@ def _isnull_operator_match(a, b):
             return {"$or": [{a: {"$exists": False}}, {a: None}]}
         return {"$and": [{a: {"$exists": True}}, {a: {"$ne": None}}]}
 
-    mongo_operators_expr = {
+    mongo_expr_operators = {
         "exact": lambda a, b: {"$eq": [a, b]},
         "gt": lambda a, b: {"$gt": [a, b]},
         "gte": lambda a, b: {"$gte": [a, b]},
@@ -153,7 +153,8 @@ def range_match(a, b):
             return {"$literal": True}
         return {"$and": conditions}
 
-    mongo_operators_match = {
+    # match, path, find? don't know which name use.
+    mongo_match_operators = {
         "exact": lambda a, b: {a: b},
         "gt": lambda a, b: {a: {"$gt": b}},
         "gte": lambda a, b: {a: {"$gte": b}},

django_mongodb_backend/compiler.py

@@ -481,11 +481,11 @@ def build_query(self, columns=None):
             query.lookup_pipeline = self.get_lookup_pipeline()
             where = self.get_where()
             try:
-                expr = where.as_mql(self, self.connection, as_path=True) if where else {}
+                match = where.as_mql(self, self.connection, as_path=True) if where else {}
             except FullResultSet:
                 query.match_mql = {}
             else:
-                query.match_mql = expr
+                query.match_mql = match
         if extra_fields:
             query.extra_fields = self.get_project_fields(extra_fields, force_expression=True)
         query.subqueries = self.subqueries
@@ -643,9 +643,7 @@ def get_combinator_queries(self):
             for alias, expr in self.columns:
                 # Unfold foreign fields.
                 if isinstance(expr, Col) and expr.alias != self.collection_name:
-                    ids[expr.alias][expr.target.column] = expr.as_mql(
-                        self, self.connection, as_path=False
-                    )
+                    ids[expr.alias][expr.target.column] = expr.as_mql(self, self.connection)
                 else:
                     ids[alias] = f"${alias}"
             # Convert defaultdict to dict so it doesn't appear as
@@ -716,9 +714,9 @@ def get_project_fields(self, columns=None, ordering=None, force_expression=False
                 value = (
                     False if empty_result_set_value is NotImplemented else empty_result_set_value
                 )
-                fields[collection][name] = Value(value).as_mql(self, self.connection, as_path=False)
+                fields[collection][name] = Value(value).as_mql(self, self.connection)
             except FullResultSet:
-                fields[collection][name] = Value(True).as_mql(self, self.connection, as_path=False)
+                fields[collection][name] = Value(True).as_mql(self, self.connection)
         # 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

@@ -29,12 +29,20 @@
 from django_mongodb_backend.query_utils import process_lhs
 
 
+def base_expression(self, compiler, connection, as_path=False, **extra):
+    if as_path and hasattr(self, "as_mql_path") and getattr(self, "can_use_path", False):
+        return self.as_mql_path(compiler, connection, **extra)
+
+    expr = self.as_mql_expr(compiler, connection, **extra)
+    return {"$expr": expr} if as_path else expr
+
+
 def case(self, compiler, connection):
     case_parts = []
     for case in self.cases:
         case_mql = {}
         try:
-            case_mql["case"] = case.as_mql(compiler, connection, as_path=False)
+            case_mql["case"] = case.as_mql(compiler, connection)
         except EmptyResultSet:
             continue
         except FullResultSet:
@@ -84,20 +92,20 @@ def col_pairs(self, compiler, connection, as_path=False):
     return cols[0].as_mql(compiler, connection, as_path=as_path)
 
 
-def combined_expression(self, compiler, connection, as_path=False):
+def combined_expression(self, compiler, connection):
     expressions = [
-        self.lhs.as_mql(compiler, connection, as_path=as_path),
-        self.rhs.as_mql(compiler, connection, as_path=as_path),
+        self.lhs.as_mql(compiler, connection),
+        self.rhs.as_mql(compiler, connection),
     ]
     return connection.ops.combine_expression(self.connector, expressions)
 
 
-def expression_wrapper_expr(self, compiler, connection):
-    return self.expression.as_mql(compiler, connection, as_path=False)
+def expression_wrapper(self, compiler, connection):
+    return self.expression.as_mql(compiler, connection)
 
 
-def negated_expression_expr(self, compiler, connection):
-    return {"$not": expression_wrapper_expr(self, compiler, connection)}
+def negated_expression(self, compiler, connection):
+    return {"$not": expression_wrapper(self, compiler, connection)}
 
 
 def order_by(self, compiler, connection):
@@ -172,10 +180,10 @@ def ref(self, compiler, connection, as_path=False):  # noqa: ARG001
 
 @property
 def ref_is_simple_column(self):
-    return isinstance(self.source, Col) and self.source.alias is not None
+    return self.source.is_simple_column
 
 
-def star(self, compiler, connection, as_path=False):  # noqa: ARG001
+def star(self, compiler, connection):  # noqa: ARG001
     return {"$literal": True}
 
 
@@ -190,11 +198,11 @@ def exists(self, compiler, connection, get_wrapping_pipeline=None):
         lhs_mql = subquery(self, compiler, connection, get_wrapping_pipeline=get_wrapping_pipeline)
     except EmptyResultSet:
         return Value(False).as_mql(compiler, connection)
-    return connection.mongo_operators_expr["isnull"](lhs_mql, False)
+    return connection.mongo_expr_operators["isnull"](lhs_mql, False)
 
 
-def when(self, compiler, connection, as_path=False):
-    return self.condition.as_mql(compiler, connection, as_path=as_path)
+def when(self, compiler, connection):
+    return self.condition.as_mql(compiler, connection)
 
 
 def value(self, compiler, connection, as_path=False):  # noqa: ARG001
@@ -221,18 +229,6 @@ def value(self, compiler, connection, as_path=False):  # noqa: ARG001
     return value
 
 
-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)
-
-    expr = self.as_mql_expr(compiler, connection, **extra)
-    return {"$expr": expr} if as_path else expr
-
-
 def register_expressions():
     BaseExpression.as_mql = base_expression
     BaseExpression.is_simple_column = False
@@ -243,15 +239,15 @@ def register_expressions():
     CombinedExpression.as_mql_expr = combined_expression
     Exists.as_mql_expr = exists
     ExpressionList.as_mql = process_lhs
-    ExpressionWrapper.as_mql_expr = expression_wrapper_expr
-    NegatedExpression.as_mql_expr = negated_expression_expr
+    ExpressionWrapper.as_mql_expr = expression_wrapper
+    NegatedExpression.as_mql_expr = negated_expression
     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
+    Star.as_mql_expr = star
     Subquery.as_mql_expr = subquery
-    When.as_mql = when
+    When.as_mql_expr = when
     Value.as_mql = value

django_mongodb_backend/fields/array.py

@@ -4,10 +4,11 @@
 from django.db.models import Field, Func, IntegerField, Transform, Value
 from django.db.models.fields.mixins import CheckFieldDefaultMixin
 from django.db.models.lookups import Exact, FieldGetDbPrepValueMixin, In, Lookup
+from django.utils.functional import cached_property
 from django.utils.translation import gettext_lazy as _
 
 from django_mongodb_backend.forms import SimpleArrayField
-from django_mongodb_backend.query_utils import process_lhs, process_rhs
+from django_mongodb_backend.query_utils import is_constant_value, process_lhs, process_rhs
 from django_mongodb_backend.utils import prefix_validation_error
 from django_mongodb_backend.validators import ArrayMaxLengthValidator, LengthValidator
 
@@ -236,6 +237,20 @@ def as_mql_expr(self, compiler, connection):
             for expr in self.get_source_expressions()
         ]
 
+    def as_mql_path(self, compiler, connection):
+        return [
+            expr.as_mql(compiler, connection, as_path=True)
+            for expr in self.get_source_expressions()
+        ]
+
+    @cached_property
+    def can_use_path(self):
+        return all(is_constant_value(expr) for expr in self.get_source_expressions())
+
+    @property
+    def is_simple_column(self):
+        return False
+
 
 class ArrayRHSMixin:
     def __init__(self, lhs, rhs):
@@ -254,13 +269,6 @@ def __init__(self, lhs, rhs):
 class ArrayContains(ArrayRHSMixin, FieldGetDbPrepValueMixin, Lookup):
     lookup_name = "contains"
 
-    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)
-        if value is None:
-            return False
-        return {lhs_mql: {"$all": 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)
@@ -272,6 +280,11 @@ def as_mql_expr(self, compiler, connection):
             ]
         }
 
+    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: {"$all": value}}
+
 
 @ArrayField.register_lookup
 class ArrayContainedBy(ArrayRHSMixin, FieldGetDbPrepValueMixin, Lookup):
@@ -333,11 +346,6 @@ def get_subquery_wrapping_pipeline(self, compiler, connection, field_name, expr)
             },
         ]
 
-    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: {"$in": 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)
@@ -348,6 +356,11 @@ def as_mql_expr(self, compiler, connection):
             ]
         }
 
+    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: {"$in": value}}
+
 
 @ArrayField.register_lookup
 class ArrayLenTransform(Transform):
@@ -381,21 +394,22 @@ def __init__(self, index, base_field, *args, **kwargs):
         self.index = index
         self.base_field = base_field
 
-    def is_simple_expression(self):
+    @property
+    def can_use_path(self):
         return self.is_simple_column
 
     @property
     def is_simple_column(self):
         return self.lhs.is_simple_column
 
-    def as_mql_path(self, compiler, connection):
-        lhs_mql = process_lhs(self, compiler, connection, as_path=True)
-        return f"{lhs_mql}.{self.index}"
-
     def as_mql_expr(self, compiler, connection):
         lhs_mql = process_lhs(self, compiler, connection, as_path=False)
         return {"$arrayElemAt": [lhs_mql, self.index]}
 
+    def as_mql_path(self, compiler, connection):
+        lhs_mql = process_lhs(self, compiler, connection, as_path=True)
+        return f"{lhs_mql}.{self.index}"
+
     @property
     def output_field(self):
         return self.base_field

django_mongodb_backend/fields/embedded_model.py

@@ -8,6 +8,7 @@
 from django.utils.functional import cached_property
 
 from django_mongodb_backend import forms
+from django_mongodb_backend.query_utils import valid_path_key_name
 
 
 class EmbeddedModelField(models.Field):
@@ -167,14 +168,15 @@ def __init__(self, field, *args, **kwargs):
     def get_lookup(self, name):
         return self.field.get_lookup(name)
 
-    def is_simple_expression(self):
+    @property
+    def can_use_path(self):
         return self.is_simple_column
 
     @cached_property
     def is_simple_column(self):
         previous = self
-        while isinstance(previous, KeyTransform):
-            if not previous.key_name.isalnum():
+        while isinstance(previous, EmbeddedModelTransform):
+            if not valid_path_key_name(previous._field.column):
                 return False
             previous = previous.lhs
         return previous.is_simple_column
@@ -198,27 +200,27 @@ def get_transform(self, name):
             f"{suggestion}"
         )
 
-    def as_mql_path(self, compiler, connection):
-        previous = self
-        key_transforms = []
-        while isinstance(previous, EmbeddedModelTransform):
-            key_transforms.insert(0, previous.key_name)
-            previous = previous.lhs
-        mql = previous.as_mql(compiler, connection, as_path=True)
-        mql_path = ".".join(key_transforms)
-        return f"{mql}.{mql_path}"
-
-    def as_mql_expr(self, compiler, connection):
+    def _get_target_path(self):
         previous = self
         columns = []
         while isinstance(previous, EmbeddedModelTransform):
             columns.insert(0, previous.field.column)
             previous = previous.lhs
-        mql = previous.as_mql(compiler, connection)
-        for column in columns:
-            mql = {"$getField": {"input": mql, "field": column}}
+        return columns, previous
+
+    def as_mql_expr(self, compiler, connection):
+        columns, parent_field = self._get_target_path()
+        mql = parent_field.as_mql(compiler, connection)
+        for key in columns:
+            mql = {"$getField": {"input": mql, "field": key}}
         return mql
 
+    def as_mql_path(self, compiler, connection):
+        columns, parent_field = self._get_target_path()
+        mql = parent_field.as_mql(compiler, connection, as_path=True)
+        mql_path = ".".join(columns)
+        return f"{mql}.{mql_path}"
+
     @property
     def output_field(self):
         return self._field