Fix refactor

Author: WaVEV

django_mongodb_backend/functions.py

@@ -65,7 +65,7 @@
 }
 
 
-def cast(self, compiler, connection, as_path=False):
+def cast(self, compiler, connection):
     output_type = connection.data_types[self.output_field.get_internal_type()]
     lhs_mql = process_lhs(self, compiler, connection, as_path=False)[0]
     if max_length := self.output_field.max_length:
@@ -78,27 +78,21 @@ def cast(self, compiler, connection, as_path=False):
     if decimal_places := getattr(self.output_field, "decimal_places", None):
         lhs_mql = {"$trunc": [lhs_mql, decimal_places]}
 
-    if as_path:
-        return {"$expr": lhs_mql}
     return lhs_mql
 
 
-def concat(self, compiler, connection, as_path=False):
-    return self.get_source_expressions()[0].as_mql(compiler, connection, as_path=as_path)
+def concat(self, compiler, connection):
+    return self.get_source_expressions()[0].as_mql(compiler, connection, as_path=False)
 
 
-def concat_pair(self, compiler, connection, as_path=False):
+def concat_pair(self, compiler, connection):
     # null on either side results in null for expression, wrap with coalesce.
     coalesced = self.coalesce()
-    if as_path:
-        return {"$expr": super(ConcatPair, coalesced).as_mql(compiler, connection, as_path=False)}
     return super(ConcatPair, coalesced).as_mql(compiler, connection, as_path=False)
 
 
-def cot(self, compiler, connection, as_path=False):
+def cot(self, compiler, connection):
     lhs_mql = process_lhs(self, compiler, connection, as_path=False)
-    if as_path:
-        return {"$expr": {"$divide": [1, {"$tan": lhs_mql}]}}
     return {"$divide": [1, {"$tan": lhs_mql}]}
 
 
@@ -109,10 +103,7 @@ def extract(self, compiler, connection, as_path=False):
         raise NotSupportedError(f"{self.__class__.__name__} is not supported.")
     if timezone := self.get_tzname():
         lhs_mql = {"date": lhs_mql, "timezone": timezone}
-    expr = {f"${operator}": lhs_mql}
-    if as_path:
-        return {"$expr": expr}
-    return expr
+    return {f"${operator}": lhs_mql}
 
 
 def func(self, compiler, connection, as_path=False):
@@ -137,73 +128,57 @@ def func_expr(self, compiler, connection):
     return {f"${operator}": lhs_mql}
 
 
-def left(self, compiler, connection, as_path=False):
-    return self.get_substr().as_mql(compiler, connection, as_path=as_path)
+def left(self, compiler, connection):
+    return self.get_substr().as_mql(compiler, connection, as_path=False)
 
 
-def length(self, compiler, connection, as_path=False):
+def length(self, compiler, connection):
     # Check for null first since $strLenCP only accepts strings.
     lhs_mql = process_lhs(self, compiler, connection, as_path=False)
-    expr = {"$cond": {"if": {"$eq": [lhs_mql, None]}, "then": None, "else": {"$strLenCP": lhs_mql}}}
-    if as_path:
-        return {"$expr": expr}
-    return expr
+    return {"$cond": {"if": {"$eq": [lhs_mql, None]}, "then": None, "else": {"$strLenCP": lhs_mql}}}
 
 
-def log(self, compiler, connection, as_path=False):
+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=as_path)
+    return func(clone, compiler, connection, as_path=False)
 
 
-def now(self, compiler, connection, as_path=False):  # noqa: ARG001
+def now(self, compiler, connection):  # noqa: ARG001
     return "$$NOW"
 
 
-def null_if(self, compiler, connection, as_path=False):
+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()
     )
-    expr = {"$cond": {"if": {"$eq": [expr1, expr2]}, "then": None, "else": expr1}}
-    if as_path:
-        return {"$expr": expr}
-    return expr
+    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, as_path=False):
-        if as_path and self.is_constant_value(self.lhs):
-            if self.lhs is None:
-                return None
-            lhs_mql = process_lhs(self, compiler, connection, as_path=True)
-            return lhs_mql.upper()
+    def wrapped(self, compiler, connection):
         lhs_mql = process_lhs(self, compiler, connection, as_path=False)
-        inner_expression = {
+        return {
             "$cond": {
                 "if": connection.mongo_operators_expr["isnull"](lhs_mql, True),
                 "then": None,
                 "else": {f"${operator}": lhs_mql},
             }
         }
-        # we need to wrap this, because it will be handled in a no expression tree.
-        # needed in MongoDB 6.
-        if as_path:
-            return {"$expr": inner_expression}
-        return inner_expression
 
     return wrapped
 
 
-def replace(self, compiler, connection, as_path=False):
-    expression, text, replacement = process_lhs(self, compiler, connection, as_path=as_path)
+def replace(self, compiler, connection):
+    expression, text, replacement = process_lhs(self, compiler, connection, as_path=False)
     return {"$replaceAll": {"input": expression, "find": text, "replacement": replacement}}
 
 
-def round_(self, compiler, connection, as_path=False):  # noqa: ARG001
+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 {
@@ -214,13 +189,13 @@ def round_(self, compiler, connection, as_path=False):  # noqa: ARG001
     }
 
 
-def str_index(self, compiler, connection, as_path=False):  # noqa: ARG001
-    lhs = process_lhs(self, compiler, connection)
+def str_index(self, compiler, connection):
+    lhs = process_lhs(self, compiler, connection, as_path=False)
     # StrIndex should be 0-indexed (not found) but it's -1-indexed on MongoDB.
     return {"$add": [{"$indexOfCP": lhs}, 1]}
 
 
-def substr(self, compiler, connection, as_path=False):  # noqa: ARG001
+def substr(self, compiler, connection):
     lhs = process_lhs(self, compiler, connection)
     # The starting index is zero-indexed on MongoDB rather than one-indexed.
     lhs[1] = {"$add": [lhs[1], -1]}
@@ -232,14 +207,14 @@ def substr(self, compiler, connection, as_path=False):  # noqa: ARG001
 
 
 def trim(operator):
-    def wrapped(self, compiler, connection, as_path=False):  # noqa: ARG001
+    def wrapped(self, compiler, connection):
         lhs = process_lhs(self, compiler, connection)
         return {f"${operator}": {"input": lhs}}
 
     return wrapped
 
 
-def trunc(self, compiler, connection, as_path=False):  # noqa: ARG001
+def trunc(self, compiler, connection):
     lhs_mql = process_lhs(self, compiler, connection)
     lhs_mql = {"date": lhs_mql, "unit": self.kind, "startOfWeek": "mon"}
     if timezone := self.get_tzname():
@@ -298,7 +273,7 @@ def trunc_date(self, compiler, connection, **extra):  # noqa: ARG001
     }
 
 
-def trunc_time(self, compiler, connection, as_path=False):  # noqa: ARG001
+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.")
@@ -318,30 +293,35 @@ def trunc_time(self, compiler, connection, as_path=False):  # noqa: ARG001
     }
 
 
+def is_simple_expression(self):  # noqa: ARG001
+    return False
+
+
 def register_functions():
-    Cast.as_mql = cast
-    Concat.as_mql = concat
-    ConcatPair.as_mql = concat_pair
-    Cot.as_mql = cot
-    Extract.as_mql = extract
+    Cast.as_mql_expr = cast
+    Concat.as_mql_expr = concat
+    ConcatPair.as_mql_expr = concat_pair
+    Cot.as_mql_expr = cot
+    Extract.as_mql_expr = extract
     Func.as_mql_path = func_path
     Func.as_mql_expr = func_expr
-    JSONArray.as_mql = process_lhs
-    Left.as_mql = left
-    Length.as_mql = length
-    Log.as_mql = log
-    Lower.as_mql = preserve_null("toLower")
-    LTrim.as_mql = trim("ltrim")
-    Now.as_mql = now
-    NullIf.as_mql = null_if
-    Replace.as_mql = replace
-    Round.as_mql = round_
-    RTrim.as_mql = trim("rtrim")
-    StrIndex.as_mql = str_index
-    Substr.as_mql = substr
-    Trim.as_mql = trim("trim")
-    TruncBase.as_mql = trunc
-    TruncBase.convert_value = trunc_convert_value
-    TruncDate.as_mql = trunc_date
-    TruncTime.as_mql = trunc_time
-    Upper.as_mql = preserve_null("toUpper")
+    JSONArray.as_mql_expr = process_lhs
+    Left.as_mql_expr = left
+    Length.as_mql_expr = length
+    Log.as_mql_expr = log
+    Lower.as_mql_expr = preserve_null("toLower")
+    LTrim.as_mql_expr = trim("ltrim")
+    Now.as_mql_expr = now
+    NullIf.as_mql_expr = null_if
+    Replace.as_mql_expr = replace
+    Round.as_mql_expr = round_
+    RTrim.as_mql_expr = trim("rtrim")
+    StrIndex.as_mql_expr = str_index
+    Substr.as_mql_expr = substr
+    Trim.as_mql_expr = trim("trim")
+    TruncBase.as_mql_expr = trunc
+    TruncBase.convert_value_expr = trunc_convert_value
+    TruncDate.as_mql_expr = trunc_date
+    TruncTime.as_mql_expr = trunc_time
+    Upper.as_mql_expr = preserve_null("toUpper")
+    Func.is_simple_expression = is_simple_expression

django_mongodb_backend/query_utils.py

@@ -1,7 +1,8 @@
 from django.core.exceptions import FullResultSet
 from django.db.models.aggregates import Aggregate
-from django.db.models.expressions import Col, Func, Ref, Value
+from django.db.models.expressions import Col, CombinedExpression, Ref, Value
 from django.db.models.fields.json import KeyTransform
+from django.db.models.sql.query import Query
 
 
 def is_direct_value(node):
@@ -64,15 +65,27 @@ def regex_match(field, regex, insensitive=False):
 
 
 def is_constant_value(value):
+    # This should be remove once CombinedExpression which are cosntant value
+    # are resolved
+    if isinstance(value, CombinedExpression):
+        return False
     if isinstance(value, list):
         return all(map(is_constant_value, value))
     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
+    # This should be remove when the same thing above.
+    if hasattr(value, "get_source_expressions"):
+        simple_sub_expressions = all(map(is_constant_value, value.get_source_expressions()))
+    return (
+        simple_sub_expressions
+        and isinstance(value, Value)
+        and not (
+            isinstance(value, Query)
+            or value.contains_aggregate
+            or value.contains_over_clause
+            or value.contains_column_references
+            or value.contains_subquery
+        )
     )