Edits.

Author: WaVEV

django_mongodb/compiler.py

@@ -1,4 +1,5 @@
 import itertools
+from collections import defaultdict
 
 from django.core.exceptions import EmptyResultSet, FullResultSet
 from django.db import DatabaseError, IntegrityError, NotSupportedError
@@ -19,7 +20,7 @@ class SQLCompiler(compiler.SQLCompiler):
     """Base class for all Mongo compilers."""
 
     query_class = MongoQuery
-    SEPARATOR = "10__MESSI__3"
+    GROUP_SEPARATOR = "___"
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -35,7 +36,7 @@ def _get_group_alias_column(self, col, annotation_group_idx):
             col = col_expr
         if self.collection_name == col.alias:
             return col.target.column, replacement
-        return f"{col.alias}{self.SEPARATOR}{col.target.column}", replacement
+        return f"{col.alias}{self.GROUP_SEPARATOR}{col.target.column}", replacement
 
     def _get_column_from_expression(self, expr, alias):
         """Get column target from expression."""
@@ -45,7 +46,21 @@ def _get_column_from_expression(self, expr, alias):
         return Col(self.collection_name, column_target)
 
     def _prepare_expressions_for_pipeline(self, expression, target, count):
-        """Prepare expressions for the aggregation pipeline."""
+        """
+        Prepare expressions for the aggregation pipeline.
+
+        This function handles the computation of aggregation functions used by various expressions.
+        It separates and creates intermediate columns, and replaces nodes
+        to simulate a group by operation.
+
+        In MongoDB, the `$group` stage does not allow operations over the aggregator
+        (e.g., `COALESCE(AVG(field), 3)`). However, it does support operations inside
+        the aggregation (e.g., `AVG(number * 2)`).
+        This function manages first cases by splitting the computation into stages:
+        it computes the aggregation function first, then applies additional operations
+        in a subsequent stage by replacing the aggregate expressions
+        with new columns prefixed by `__aggregation`.
+        """
         replacements = {}
         group = {}
         for sub_expr in self._get_aggregate_expressions(expression):
@@ -150,19 +165,17 @@ def _build_group_pipeline(self, ids, group):
         else:
             group["_id"] = ids
             pipeline.append({"$group": group})
-            sets = {}
+            projected_fields = defaultdict(dict)
             for key in ids:
                 value = f"$_id.{key}"
-                if self.SEPARATOR in key:
-                    subtable, field = key.split(self.SEPARATOR)
-                    if subtable not in sets:
-                        sets[subtable] = {}
-                    sets[subtable][field] = value
+                if self.GROUP_SEPARATOR in key:
+                    subtable, field = key.split(self.GROUP_SEPARATOR)
+                    projected_fields[subtable][field] = value
                 else:
-                    sets[key] = value
+                    projected_fields[key] = value
 
-            pipeline.append({"$addFields": sets})
-            if "_id" not in sets:
+            pipeline.append({"$addFields": projected_fields})
+            if "_id" not in projected_fields:
                 pipeline.append({"$unset": "_id"})
 
         return pipeline
@@ -320,7 +333,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:
-            where = getattr(self, "where", self.query.where)
+            where = self.get_where()
+            # where = getattr(self, "where", self.query.where)
             query.mongo_query = (
                 {"$expr": where.as_mql(self, self.connection)} if where is not None else {}
             )
@@ -466,6 +480,9 @@ def get_project_fields(self, columns=None, ordering=None):
                     fields[column] = 1
         return fields
 
+    def get_where(self):
+        return self.where
+
 
 class SQLInsertCompiler(SQLCompiler):
     def execute_sql(self, returning_fields=None):
@@ -511,6 +528,9 @@ def check_query(self):
                 "Cannot use QuerySet.delete() when querying across multiple collections on MongoDB."
             )
 
+    def get_where(self):
+        return self.query.where
+
 
 class SQLUpdateCompiler(compiler.SQLUpdateCompiler, SQLCompiler):
     def execute_sql(self, result_type):
@@ -572,6 +592,9 @@ def check_query(self):
                 "Cannot use QuerySet.update() when querying across multiple collections on MongoDB."
             )
 
+    def get_where(self):
+        return self.query.where
+
 
 class SQLAggregateCompiler(SQLCompiler):
     def build_query(self, columns=None):