Convert conditions into a whereNode

Author: WaVEV

django_mongodb_backend/compiler.py

@@ -13,7 +13,7 @@
 from django.db.models.sql import compiler
 from django.db.models.sql.constants import GET_ITERATOR_CHUNK_SIZE, MULTI, SINGLE
 from django.db.models.sql.datastructures import BaseTable
-from django.db.models.sql.where import AND
+from django.db.models.sql.where import AND, WhereNode
 from django.utils.functional import cached_property
 from pymongo import ASCENDING, DESCENDING
 
@@ -556,15 +556,15 @@ def get_lookup_pipeline(self):
             if (
                 isinstance(expr, Lookup)
                 and isinstance(expr.lhs, Col)
-                and (is_direct_value(expr.rhs) or isinstance(expr.rhs, Value))
+                and (is_direct_value(expr.rhs) or isinstance(expr.rhs, Value | Col))
             ):
                 promote_filters[expr.lhs.alias].append(expr)
 
         for alias in tuple(self.query.alias_map):
             if not self.query.alias_refcount[alias] or self.collection_name == alias:
                 continue
             result += self.query.alias_map[alias].as_mql(
-                self, self.connection, promote_filters[alias]
+                self, self.connection, WhereNode(promote_filters[alias], connector=AND)
             )
         return result
 

django_mongodb_backend/query.py

@@ -124,11 +124,13 @@ def extra_where(self, compiler, connection):  # noqa: ARG001
 
 
 def join(self, compiler, connection, pushed_expressions=None):
+    parent_template = "parent__field__"
+
     def _get_reroot_replacements(expressions):
         if not expressions:
             return None
         columns = []
-        for expr in expressions:
+        for expr in expressions.leaves():
             # Determine whether the column needs to be transformed or rerouted
             # as part of the subquery.
             for hand_side in ["lhs", "rhs"]:
@@ -162,7 +164,6 @@ def _get_reroot_replacements(expressions):
     lhs_fields = []
     rhs_fields = []
     # Add a join condition for each pair of joining fields.
-    parent_template = "parent__field__"
     for lhs, rhs in self.join_fields:
         lhs, rhs = connection.ops.prepare_join_on_clause(
             self.parent_alias, lhs, compiler.collection_name, rhs
@@ -174,19 +175,20 @@ def _get_reroot_replacements(expressions):
     # Handle any join conditions besides matching field pairs.
     extra = self.join_field.get_extra_restriction(self.table_alias, self.parent_alias)
 
+    extra_conditions = []
     if extra:
-        replacements = _get_reroot_replacements(extra.leaves())
-        extra_condition = [extra.replace_expressions(replacements).as_mql(compiler, connection)]
-    else:
-        extra_condition = []
-    if self.join_type == INNER:
+        replacements = _get_reroot_replacements(extra)
+        extra_conditions.append(
+            extra.replace_expressions(replacements).as_mql(compiler, connection)
+        )
+
+    if pushed_expressions and self.join_type == INNER:
         rerooted_replacement = _get_reroot_replacements(pushed_expressions)
-        resolved_pushed_expressions = [
-            expr.replace_expressions(rerooted_replacement).as_mql(compiler, connection)
-            for expr in pushed_expressions
-        ]
-    else:
-        resolved_pushed_expressions = []
+        extra_conditions.append(
+            pushed_expressions.replace_expressions(rerooted_replacement).as_mql(
+                compiler, connection
+            )
+        )
 
     lookup_pipeline = [
         {
@@ -213,8 +215,7 @@ def _get_reroot_replacements(expressions):
                                     {"$eq": [f"$${parent_template}{i}", field]}
                                     for i, field in enumerate(rhs_fields)
                                 ]
-                                + extra_condition
-                                + resolved_pushed_expressions
+                                + extra_conditions
                             }
                         }
                     }