Clean ups.

Author: WaVEV

django_mongodb_backend/aggregates.py

@@ -64,12 +64,12 @@ 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):  # noqa: ARG001
+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/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

django_mongodb_backend/expressions/builtins.py

@@ -100,12 +100,12 @@ def combined_expression(self, compiler, connection):
     return connection.ops.combine_expression(self.connector, expressions)
 
 
-def expression_wrapper_expr(self, compiler, connection):
+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):
@@ -201,8 +201,8 @@ def exists(self, compiler, connection, get_wrapping_pipeline=None):
     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
@@ -239,8 +239,8 @@ 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
@@ -249,5 +249,5 @@ def register_expressions():
     ResolvedOuterRef.as_mql = ResolvedOuterRef.as_sql
     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/functions.py

@@ -128,20 +128,20 @@ def func_expr(self, compiler, connection):
 
 
 def left(self, compiler, connection):
-    return self.get_substr().as_mql(compiler, connection, as_path=False)
+    return self.get_substr().as_mql(compiler, connection)
 
 
 def length(self, compiler, connection):
     # Check for null first since $strLenCP only accepts strings.
-    lhs_mql = process_lhs(self, compiler, connection, as_path=False)
+    lhs_mql = process_lhs(self, compiler, connection)
     return {"$cond": {"if": {"$eq": [lhs_mql, None]}, "then": None, "else": {"$strLenCP": lhs_mql}}}
 
 
 def log(self, compiler, connection):
     # 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, as_path=False)
+    return func(clone, compiler, connection)
 
 
 def now(self, compiler, connection):  # noqa: ARG001
@@ -150,17 +150,15 @@ def now(self, compiler, connection):  # noqa: ARG001
 
 def null_if(self, compiler, connection):
     """Return None if expr1==expr2 else expr1."""
-    expr1, expr2 = (
-        expr.as_mql(compiler, connection, as_path=False) for expr in self.get_source_expressions()
-    )
+    expr1, expr2 = (expr.as_mql(compiler, connection) 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, as_path=False)
+        lhs_mql = process_lhs(self, compiler, connection)
         return {
             "$cond": {
                 "if": connection.mongo_expr_operators["isnull"](lhs_mql, True),
@@ -173,23 +171,18 @@ def wrapped(self, compiler, connection):
 
 
 def replace(self, compiler, connection):
-    expression, text, replacement = process_lhs(self, compiler, connection, as_path=False)
+    expression, text, replacement = process_lhs(self, compiler, connection)
     return {"$replaceAll": {"input": expression, "find": text, "replacement": replacement}}
 
 
 def round_(self, compiler, connection):
     # 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, as_path=False)
-            for expr in self.get_source_expressions()
-        ]
-    }
+    return {"$round": [expr.as_mql(compiler, connection) for expr in self.get_source_expressions()]}
 
 
 def str_index(self, compiler, connection):
-    lhs = process_lhs(self, compiler, connection, as_path=False)
+    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]}
 
@@ -253,7 +246,7 @@ def trunc_convert_value(self, value, expression, connection):
 
 def trunc_date(self, compiler, connection):
     # Cast to date rather than truncate to date.
-    lhs_mql = process_lhs(self, compiler, connection, as_path=False)
+    lhs_mql = process_lhs(self, compiler, connection)
     tzname = self.get_tzname()
     if tzname and tzname != "UTC":
         raise NotSupportedError(f"TruncDate with tzinfo ({tzname}) isn't supported on MongoDB.")
@@ -276,7 +269,7 @@ def trunc_time(self, compiler, connection):
     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, as_path=False)
+    lhs_mql = process_lhs(self, compiler, connection)
     return {
         "$dateFromString": {
             "dateString": {