More clean ups.

Author: WaVEV

django_mongodb_backend/fields/json.py

@@ -54,10 +54,7 @@ def data_contains(self, compiler, connection, as_path=False):  # noqa: ARG001
 def _has_key_predicate(path, root_column=None, negated=False, as_path=False):
     """Return MQL to check for the existence of `path`."""
     if as_path:
-        # if not negated:
         return {path: {"$exists": not negated}}
-        # return {"$and": [{path: {"$exists": True}}, {path: {"$ne": None}}]}
-        # return {"$or": [{path: {"$exists": False}}, {path: None}]}
     result = {
         "$and": [
             # The path must exist (i.e. not be "missing").
@@ -81,9 +78,9 @@ def has_key_check_simple_expression(self):
 def has_key_lookup(self, compiler, connection, as_path=False):
     """Return MQL to check for the existence of a key."""
     rhs = self.rhs
+    lhs = process_lhs(self, compiler, connection, as_path=as_path)
     if not isinstance(rhs, (list, tuple)):
         rhs = [rhs]
-    lhs = process_lhs(self, compiler, connection, as_path=as_path)
     paths = []
     # Transform any "raw" keys into KeyTransforms to allow consistent handling
     # in the code that follows.
@@ -198,7 +195,7 @@ def key_transform_is_null_expr(self, compiler, connection):
         previous = previous.lhs
     root_column = previous.as_mql(compiler, connection)
     lhs_mql = process_lhs(self, compiler, connection, as_path=False)
-    rhs_mql = process_rhs(self, compiler, connection)
+    rhs_mql = process_rhs(self, compiler, connection, as_path=False)
     return _has_key_predicate(lhs_mql, root_column, negated=rhs_mql)
 
 

django_mongodb_backend/functions.py

@@ -67,7 +67,7 @@
 
 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]
+    lhs_mql = process_lhs(self, compiler, connection)[0]
     if max_length := self.output_field.max_length:
         lhs_mql = {"$substrCP": [lhs_mql, 0, max_length]}
     # Skip the conversion for "object" as it doesn't need to be transformed for
@@ -81,22 +81,22 @@ def cast(self, compiler, connection):
 
 
 def concat(self, compiler, connection):
-    return self.get_source_expressions()[0].as_mql(compiler, connection, as_path=False)
+    return self.get_source_expressions()[0].as_mql(compiler, connection)
 
 
 def concat_pair(self, compiler, connection):
     # null on either side results in null for expression, wrap with coalesce.
     coalesced = self.coalesce()
-    return super(ConcatPair, coalesced).as_mql_expr(compiler, connection)
+    return super(ConcatPair, coalesced).as_mql(compiler, connection)
 
 
 def cot(self, compiler, connection):
-    lhs_mql = process_lhs(self, compiler, connection, as_path=False)
+    lhs_mql = process_lhs(self, compiler, connection)
     return {"$divide": [1, {"$tan": lhs_mql}]}
 
 
-def extract(self, compiler, connection, as_path=False):
-    lhs_mql = process_lhs(self, compiler, connection, as_path=as_path)
+def extract(self, compiler, connection):
+    lhs_mql = process_lhs(self, compiler, connection)
     operator = EXTRACT_OPERATORS.get(self.lookup_name)
     if operator is None:
         raise NotSupportedError(f"{self.__class__.__name__} is not supported.")
@@ -105,22 +105,8 @@ def extract(self, compiler, connection, as_path=False):
     return {f"${operator}": lhs_mql}
 
 
-def func(self, compiler, connection, as_path=False):
-    lhs_mql = process_lhs(self, compiler, connection, as_path=False)
-    if self.function is None:
-        raise NotSupportedError(f"{self} may need an as_mql() method.")
-    operator = MONGO_OPERATORS.get(self.__class__, self.function.lower())
-    if as_path:
-        return {"$expr": {f"${operator}": lhs_mql}}
-    return {f"${operator}": lhs_mql}
-
-
-def func_path(self, compiler, connection):  # noqa: ARG001
-    raise NotSupportedError(f"{self} may need an as_mql_path() method.")
-
-
-def func_expr(self, compiler, connection):
-    lhs_mql = process_lhs(self, compiler, connection, as_path=False)
+def func(self, compiler, connection):
+    lhs_mql = process_lhs(self, compiler, connection)
     if self.function is None:
         raise NotSupportedError(f"{self} may need an as_mql() method.")
     operator = MONGO_OPERATORS.get(self.__class__, self.function.lower())
@@ -291,8 +277,8 @@ def register_functions():
     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
+    Func.as_mql_expr = func
+    Func.can_use_path = False
     JSONArray.as_mql_expr = process_lhs
     Left.as_mql_expr = left
     Length.as_mql_expr = length
@@ -312,4 +298,3 @@ def register_functions():
     TruncDate.as_mql_expr = trunc_date
     TruncTime.as_mql_expr = trunc_time
     Upper.as_mql_expr = preserve_null("toUpper")
-    Func.can_use_path = False

django_mongodb_backend/lookups.py

@@ -12,18 +12,18 @@
 from .query_utils import is_constant_value, process_lhs, process_rhs
 
 
-def builtin_lookup_path(self, compiler, connection):
-    lhs_mql = process_lhs(self, compiler, connection, as_path=True)
-    value = process_rhs(self, compiler, connection, as_path=True)
-    return connection.mongo_match_operators[self.lookup_name](lhs_mql, value)
-
-
 def builtin_lookup_expr(self, compiler, connection):
     value = process_rhs(self, compiler, connection, as_path=False)
     lhs_mql = process_lhs(self, compiler, connection, as_path=False)
     return connection.mongo_expr_operators[self.lookup_name](lhs_mql, value)
 
 
+def builtin_lookup_path(self, compiler, connection):
+    lhs_mql = process_lhs(self, compiler, connection, as_path=True)
+    value = process_rhs(self, compiler, connection, as_path=True)
+    return connection.mongo_match_operators[self.lookup_name](lhs_mql, value)
+
+
 _field_resolve_expression_parameter = FieldGetDbPrepValueIterableMixin.resolve_expression_parameter
 
 
@@ -85,18 +85,18 @@ def get_subquery_wrapping_pipeline(self, compiler, connection, field_name, expr)
     ]
 
 
-def is_null_path(self, compiler, connection):
+def is_null_expr(self, compiler, connection):
     if not isinstance(self.rhs, bool):
         raise ValueError("The QuerySet value for an isnull lookup must be True or False.")
-    lhs_mql = process_lhs(self, compiler, connection, as_path=True)
-    return connection.mongo_match_operators["isnull"](lhs_mql, self.rhs)
+    lhs_mql = process_lhs(self, compiler, connection, as_path=False)
+    return connection.mongo_expr_operators["isnull"](lhs_mql, self.rhs)
 
 
-def is_null_expr(self, compiler, connection):
+def is_null_path(self, compiler, connection):
     if not isinstance(self.rhs, bool):
         raise ValueError("The QuerySet value for an isnull lookup must be True or False.")
-    lhs_mql = process_lhs(self, compiler, connection, as_path=False)
-    return connection.mongo_expr_operators["isnull"](lhs_mql, self.rhs)
+    lhs_mql = process_lhs(self, compiler, connection, as_path=True)
+    return connection.mongo_match_operators["isnull"](lhs_mql, self.rhs)
 
 
 # from https://www.pcre.org/current/doc/html/pcre2pattern.html#SEC4
@@ -146,9 +146,8 @@ def can_use_path(self):
 
 
 def register_lookups():
-    Lookup.can_use_path = can_use_path
-    BuiltinLookup.as_mql_path = builtin_lookup_path
     BuiltinLookup.as_mql_expr = builtin_lookup_expr
+    BuiltinLookup.as_mql_path = builtin_lookup_path
     FieldGetDbPrepValueIterableMixin.resolve_expression_parameter = (
         field_resolve_expression_parameter
     )
@@ -157,6 +156,7 @@ def register_lookups():
     In.get_subquery_wrapping_pipeline = get_subquery_wrapping_pipeline
     IsNull.as_mql_path = is_null_path
     IsNull.as_mql_expr = is_null_expr
+    Lookup.can_use_path = can_use_path
     PatternLookup.prep_lookup_value_mongo = pattern_lookup_prep_lookup_value
     # Patching the main method, it is not supported yet.
     UUIDTextMixin.as_mql = uuid_text_mixin

django_mongodb_backend/query.py

@@ -336,12 +336,12 @@ def where_node(self, compiler, connection, as_path=False):
     return mql
 
 
-def nothing_node(self, compiler, connection, as_path=None):  # noqa: ARG001
+def nothing_node(self, compiler, connection):
     return self.as_sql(compiler, connection)
 
 
 def register_nodes():
     ExtraWhere.as_mql = extra_where
     Join.as_mql = join
-    NothingNode.as_mql = nothing_node
+    NothingNode.as_mql_expr = nothing_node
     WhereNode.as_mql = where_node