test fixed.

Author: WaVEV

django_mongodb/compiler.py

@@ -17,12 +17,20 @@ class SQLCompiler(compiler.SQLCompiler):
 
     query_class = MongoQuery
     _group_pipeline = None
+    aggregation_idx = 0
 
-    def _prepare_expressions_for_pipeline(self, expression, target, aggregation_idx):
+    def _get_colum_from_expression(self, expr, alias):
+        column_target = expr.output_field.__class__()
+        column_target.db_column = alias
+        column_target.set_attributes_from_name(alias)
+        return Col(self.collection_name, column_target)
+
+    def _prepare_expressions_for_pipeline(self, expression, target):
         replacements = {}
         group = {}
         for sub_expr in self._get_aggregate_expressions(expression):
-            alias = f"__aggregation{aggregation_idx}" if sub_expr != expression else target
+            alias = f"__aggregation{self.aggregation_idx}" if sub_expr != expression else target
+            self.aggregation_idx += 1
 
             column_target = sub_expr.output_field.__class__()
             column_target.db_column = alias
@@ -38,6 +46,7 @@ def _prepare_expressions_for_pipeline(self, expression, target, aggregation_idx)
                 group[alias] = sub_expr.as_mql(self, self.connection)
                 replacing_expr = inner_column
 
+            sub_expr.as_mql(self, self.connection)
             replacements[sub_expr] = replacing_expr
         return replacements, group
 
@@ -56,19 +65,16 @@ def pre_sql_setup(self, with_col_aliases=False):
         group = {}
         group_expressions = set()
         all_replacements = {}
-        for idx, (target, expr) in enumerate(self.query.annotation_select.items()):
+        self.aggregation_idx = 0
+        for target, expr in self.query.annotation_select.items():
             if expr.contains_aggregate:
-                replacements, expr_group = self._prepare_expressions_for_pipeline(expr, target, idx)
-                result_expr = expr.replace_expressions(replacements)
+                replacements, expr_group = self._prepare_expressions_for_pipeline(expr, target)
                 all_replacements.update(replacements)
                 group.update(expr_group)
-            else:
-                result_expr = expr
             group_expressions |= set(expr.get_group_by_cols())
-            self.annotations[target] = result_expr
 
         having_replacements, having_group = self._prepare_expressions_for_pipeline(
-            self.having, None, len(self.query.annotation_select)
+            self.having, None
         )
         all_replacements.update(having_replacements)
         group.update(having_group)
@@ -109,7 +115,10 @@ def _ccc(col):
 
                 if not isinstance(col, Col):
                     annotation_group_idx += 1
-                    return "__annotation_group_1"
+                    alias = f"__annotation_group_{annotation_group_idx}"
+                    col_expr = self._get_colum_from_expression(col, alias)
+                    all_replacements[col] = col_expr
+                    col = col_expr
                 if self.collection_name == col.alias:
                     return col.target.column
                 return f"{col.alias}{SEPARATOR}{col.target.column}"
@@ -123,13 +132,17 @@ def _ccc(col):
                     for col in group_expressions
                 }
             )
+            self.annotations = {
+                target: expr.replace_expressions(all_replacements)
+                for target, expr in self.query.annotation_select.items()
+            }
             pipeline = []
             if not ids:
                 group["_id"] = None
                 pipeline.append({"$facet": {"group": [{"$group": group}]}})
                 pipeline.append(
                     {
-                        "$project": {
+                        "$addFields": {
                             key: {
                                 "$getField": {
                                     "input": {"$arrayElemAt": ["$group", 0]},
@@ -173,6 +186,11 @@ def _ccc(col):
         else:
             self._group_pipeline = None
 
+        self.annotations = {
+            target: expr.replace_expressions(all_replacements)
+            for target, expr in self.query.annotation_select.items()
+        }
+
         return pre_setup
 
     def execute_sql(
@@ -306,9 +324,8 @@ def build_query(self, columns=None):
         query.order_by(self._get_ordering())
         query.project_fields = self.get_project_fields(columns, ordering=query.ordering)
         try:
-            query.mongo_query = (
-                {"$expr": self.where.as_mql(self, self.connection)} if self.where else None
-            )
+            where = getattr(self, "where", self.query.where)
+            query.mongo_query = {"$expr": where.as_mql(self, self.connection)} if where else None
         except FullResultSet:
             query.mongo_query = {}
         return query
@@ -487,7 +504,7 @@ def insert(self, docs, returning_fields=None):
 class SQLDeleteCompiler(compiler.SQLDeleteCompiler, SQLCompiler):
     def execute_sql(self, result_type=MULTI):
         cursor = Cursor()
-        cursor.rowcount = self.build_query([self.query.get_meta().pk]).delete()
+        cursor.rowcount = self.build_query().delete()
         return cursor
 
     def check_query(self):

django_mongodb/features.py

@@ -132,8 +132,11 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         "aggregation.test_filter_argument.FilteredAggregateTests.test_filtered_numerical_aggregates",
         # Sum returns 0 instead of None in mongodb.
         "aggregation.test_filter_argument.FilteredAggregateTests.test_plain_annotate",
+        "aggregation.tests.AggregateTestCase.test_aggregation_default_passed_another_aggregate",
         "aggregation.tests.AggregateTestCase.test_annotation_expressions",
         "aggregation.tests.AggregateTestCase.test_reverse_fkey_annotate",
+        # Manage empty result when the flag elide_empty is False
+        "aggregation.tests.AggregateTestCase.test_empty_result_optimization",
     }
     # $bitAnd, #bitOr, and $bitXor are new in MongoDB 6.3.
     _django_test_expected_failures_bitwise = {

django_mongodb/functions.py

@@ -166,7 +166,9 @@ def extract(self, compiler, connection):
 
 def func(self, compiler, connection):
     lhs_mql = process_lhs(self, compiler, connection)
-    operator = MONGO_OPERATORS.get(self.__class__, self.function.lower())
+    operator = MONGO_OPERATORS.get(
+        self.__class__, (self.extra["function"] if self.function is None else self.function).lower()
+    )
     return {f"${operator}": lhs_mql}
 
 

django_mongodb/query_utils.py

@@ -1,6 +1,6 @@
 from django.core.exceptions import FullResultSet
 from django.db.models.aggregates import Aggregate
-from django.db.models.expressions import Value
+from django.db.models.expressions import Expression, Value
 
 
 def is_direct_value(node):
@@ -37,6 +37,9 @@ def process_rhs(node, compiler, connection):
             value = value[0]
     if hasattr(node, "prep_lookup_value_mongo"):
         value = node.prep_lookup_value_mongo(value)
+    # Can't apply converters to symbolic things.
+    if isinstance(rhs, Expression):
+        return value
     return connection.ops.prep_lookup_value(value, node.lhs.output_field, node.lookup_name)