Edits.

Author: WaVEV

django_mongodb_backend/compiler.py

@@ -670,22 +670,28 @@ def collect_pushable(expr, negated=False):
                     return {}
                 if negated:
                     operator = OR if operator == AND else AND
-                result = defaultdict(list, next(pushable_expressions, {}))
+                result = next(pushable_expressions, {})
                 shared_alias = set(result)
                 for pe in pushable_expressions:
                     shared_alias &= set(pe)
                     for alias, expressions in pe.items():
-                        result[alias] += expressions
+                        children = [expressions]
+                        if alias in result:
+                            children.append(result[alias])
+                        result[alias] = WhereNode(
+                            children=children,
+                            negated=negated,
+                            connector=operator,
+                        )
                 if operator == AND:
                     return result
                 return {k: v for k, v in result.items() if k in shared_alias}
             if expr.lhs.is_simple_column and (
                 is_constant_value(expr.rhs) or expr.rhs.is_simple_column
             ):
                 alias = expr.lhs.alias
-                if negated:
-                    expr = WhereNode(children=[expr], negated=True)
-                return {expr.lhs.alias: [expr]}
+                expr = WhereNode(children=[expr], negated=negated)
+                return {alias: expr}
             return {}
 
         return collect_pushable(self.get_where())
@@ -699,7 +705,7 @@ def get_lookup_pipeline(self):
             if not self.query.alias_refcount[alias] or self.collection_name == alias:
                 continue
             result += self.query.alias_map[alias].as_mql(
-                self, self.connection, WhereNode(pushed_filters[alias], connector=AND)
+                self, self.connection, pushed_filters.get(alias)
             )
         return result
 

django_mongodb_backend/test.py

@@ -6,6 +6,28 @@
 class MongoTestCaseMixin:
     maxDiff = None
 
+    COMMUTATIVE_OPERATORS = {"$and", "$or", "$all"}
+
+    @staticmethod
+    def _normalize_query(obj):
+        if isinstance(obj, dict):
+            normalized = {}
+            for k, v in obj.items():
+                if k in MongoTestCaseMixin.COMMUTATIVE_OPERATORS and isinstance(v, list):
+                    # Only sort for commutative operators
+                    normalized[k] = sorted(
+                        (MongoTestCaseMixin._normalize_query(i) for i in v), key=lambda x: str(x)
+                    )
+                else:
+                    normalized[k] = MongoTestCaseMixin._normalize_query(v)
+            return normalized
+
+        if isinstance(obj, list):
+            # Lists not under commutative ops keep their order
+            return [MongoTestCaseMixin._normalize_query(i) for i in obj]
+
+        return obj
+
     def assertAggregateQuery(self, query, expected_collection, expected_pipeline):
         """
         Assert that the logged query is equal to:
@@ -16,6 +38,10 @@ def assertAggregateQuery(self, query, expected_collection, expected_pipeline):
         self.assertEqual(operator, "aggregate")
         self.assertEqual(collection, expected_collection)
         self.assertEqual(
-            eval(pipeline[:-1], {"SON": SON, "ObjectId": ObjectId, "Decimal128": Decimal128}, {}),  # noqa: S307
-            expected_pipeline,
+            self._normalize_query(
+                eval(  # noqa: S307
+                    pipeline[:-1], {"SON": SON, "ObjectId": ObjectId, "Decimal128": Decimal128}, {}
+                )
+            ),
+            self._normalize_query(expected_pipeline),
         )

tests/queries_/test_mql.py

@@ -267,8 +267,6 @@ def test_filter_on_local_and_nested_join_fields(self):
         )
 
     def test_negated_related_filter_is_not_pushable(self):
-        # import ipdb
-        # ipdb.set_trace()
         with self.assertNumQueries(1) as ctx:
             list(Book.objects.filter(~models.Q(author__name="John")))
         self.assertAggregateQuery(
@@ -283,7 +281,14 @@ def test_negated_related_filter_is_not_pushable(self):
                         "pipeline": [
                             {
                                 "$match": {
-                                    "$expr": {"$and": [{"$eq": ["$$parent__field__0", "$_id"]}]}
+                                    "$and": [
+                                        {
+                                            "$expr": {
+                                                "$and": [{"$eq": ["$$parent__field__0", "$_id"]}]
+                                            }
+                                        },
+                                        {"$nor": [{"name": "John"}]},
+                                    ]
                                 }
                             }
                         ],