Wrapping group when no group by.

Author: WaVEV

django_mongodb/compiler.py

@@ -19,10 +19,18 @@ class SQLCompiler(compiler.SQLCompiler):
     query_class = MongoQuery
     _group_pipeline = None
 
+    @staticmethod
+    def _random_separtor():
+        import random
+        import string
+
+        size = 6
+        chars = string.ascii_uppercase + string.digits
+        return "".join(random.choice(chars) for _ in range(size))  # noqa: S311
+
     def pre_sql_setup(self, with_col_aliases=False):
         pre_setup = super().pre_sql_setup(with_col_aliases=with_col_aliases)
         self.annotations = {}
-        # mongo_having = self.having.copy() if self.having else None
         group = {}
         group_expressions = set()
         aggregation_idx = 1
@@ -38,13 +46,14 @@ def pre_sql_setup(self, with_col_aliases=False):
                         aggregation_idx += 1
                     else:
                         alias = target
-                    group_expressions |= set(sub_expr.get_group_by_cols())
                     group[alias] = sub_expr.as_mql(self, self.connection)
                     column_target = expr.output_field.__class__()
+                    column_target.db_column = alias
                     column_target.set_attributes_from_name(alias)
                     replacements[sub_expr] = Col(self.collection_name, column_target)
                 result_expr = expr.replace_expressions(replacements)
                 all_replacements.update(replacements)
+            group_expressions |= set(expr.get_group_by_cols())
             self.annotations[target] = result_expr
         if group:
             order_by = self.get_order_by()
@@ -59,24 +68,69 @@ def pre_sql_setup(self, with_col_aliases=False):
             if isinstance(self.query.group_by, tuple | list):
                 group_expressions |= set(self.query.group_by)
 
+            all_strings = "".join(
+                str(col.as_mql(self, self.connection)) for col in group_expressions
+            )
+
+            while True:
+                random_string = self._random_separtor()
+                if random_string not in all_strings:
+                    break
+            SEPARATOR = f"__{random_string}__"
+
+            def _ccc(col):
+                if self.collection_name == col.alias:
+                    return col.target.column
+                return f"{col.alias}{SEPARATOR}{col.target.column}"
+
             ids = (
                 None
                 if not group_expressions
                 else {
-                    col.target.column: col.as_mql(self, self.connection)
+                    _ccc(col): col.as_mql(self, self.connection)
                     # expression aren't needed in the group by clouse ()
                     for col in group_expressions
                     if isinstance(col, Col)
                 }
             )
-            group["_id"] = ids
-            pipeline = [{"$group": group}]
-            if ids:
+            pipeline = []
+            if ids is None:
+                group["_id"] = None
+                pipeline.append({"$facet": {"group": [{"$group": group}]}})
                 pipeline.append(
-                    {"$addFields": {key: f"$_id.{value[1:]}" for key, value in ids.items()}}
+                    {
+                        "$project": {
+                            key: {
+                                "$getField": {
+                                    "input": {"$arrayElemAt": ["$group", 0]},
+                                    "field": key,
+                                }
+                            }
+                            for key in group
+                        }
+                    }
                 )
-                if "_id" not in ids:
+            else:
+                group["_id"] = ids
+                pipeline.append({"$group": group})
+                sets = {}
+                for key in ids:
+                    value = f"$_id.{key}"
+                    if SEPARATOR in key:
+                        subtable, field = key.split(SEPARATOR)
+                        if subtable not in sets:
+                            sets[subtable] = {}
+                        sets[subtable][field] = value
+                    else:
+                        sets[key] = value
+
+                pipeline.append(
+                    # {"$addFields": {key: f"$_id.{value[1:]}" for key, value in ids.items()}}
+                    {"$addFields": sets}
+                )
+                if "_id" not in sets:
                     pipeline.append({"$unset": "_id"})
+
             if self.having:
                 pipeline.append(
                     {
@@ -250,14 +304,14 @@ def build_query(self, columns=None):
         query = self.query_class(self)
         query.aggregation_stage = self.get_aggregation_pipeline()
         query.lookup_pipeline = self.get_lookup_pipeline()
-        query.project_fields = self.get_project_fields(columns)
+        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
             )
         except FullResultSet:
             query.mongo_query = {}
-        query.order_by(self._get_ordering())
         return query
 
     def get_columns(self):
@@ -369,7 +423,7 @@ def _get_aggregate_expressions(self, expr):
     def get_aggregation_pipeline(self):
         return self._group_pipeline
 
-    def get_project_fields(self, columns=None):
+    def get_project_fields(self, columns=None, ordering=None):
         fields = {}
         for name, expr in columns or []:
             try:
@@ -393,6 +447,10 @@ def get_project_fields(self, columns=None):
                 if self.query.alias_refcount[alias] and self.collection_name != alias:
                     fields[alias] = 1
 
+            for column, _ in ordering or []:
+                if column not in fields:
+                    fields[column] = 1
+
         return fields
 
 
@@ -513,7 +571,16 @@ def build_query(self, columns=None):
             elide_empty=self.elide_empty,
         )
         compiler.pre_sql_setup(with_col_aliases=False)
-        query.sub_query = compiler.build_query()
+        columns = (
+            compiler.get_columns()
+            if compiler.query.annotations or not compiler.query.default_cols
+            else None
+        )
+        subquery = compiler.build_query(
+            # Avoid $project (columns=None) if unneeded.
+            columns
+        )
+        query.subquery = subquery
         return query
 
     def _make_result(self, result, columns=None):

django_mongodb/features.py

@@ -594,6 +594,24 @@ def django_test_expected_failures(self):
         "Test not applicable for MongoDB's SQLCompiler.": {
             "queries.test_iterator.QuerySetIteratorTests",
         },
+        "skip agg": {
+            "aggregation.test_filter_argument.FilteredAggregateTests.test_filtered_aggregate_on_exists",
+            # Custom aggregations:
+            "aggregation.tests.AggregateAnnotationPruningTests.test_non_aggregate_annotation_pruned",
+            "aggregation.tests.AggregateTestCase.test_add_implementation",
+            "aggregation.tests.AggregateTestCase.test_aggregation_default_using_datetime_from_database",
+            # SQL custom values.
+            "aggregation.tests.AggregateTestCase.test_aggregation_default_using_date_from_database",
+            # No sql generate
+            "aggregation.tests.AggregateAnnotationPruningTests.test_unreferenced_aggregate_annotation_pruned",
+            "aggregation.tests.AggregateAnnotationPruningTests.test_unused_aliased_aggregate_pruned",
+            # PI expression:
+            "aggregation.tests.AggregateTestCase.test_aggregation_default_using_decimal_from_database",
+            # check sql query performance
+            "aggregation.tests.AggregateAnnotationPruningTests.test_referenced_aggregate_annotation_kept",
+            # Using a QuerySet in annotate() is not supported on MongoDB
+            "aggregation.tests.AggregateTestCase.test_group_by_subquery_annotation",
+        }
     }
 
     @cached_property

django_mongodb/functions.py

@@ -1,6 +1,7 @@
 from django.db import NotSupportedError
 from django.db.models.aggregates import Aggregate, Avg, Count, Max, Min, StdDev, Sum, Variance
-from django.db.models.expressions import Case, Func, Value, When
+from django.db.models.expressions import Case, Func, Star, Value, When
+from django.db.models.functions import Now
 from django.db.models.functions.comparison import Cast, Coalesce, Greatest, Least, NullIf
 from django.db.models.functions.datetime import (
     Extract,
@@ -122,12 +123,13 @@ def count(self, compiler, connection, **extra_context):  # noqa: ARG001
         condition = When(self.filter, then=Value(1))
         copy.set_source_expressions([Case(condition)] + source_expressions[1:])
         node = copy
+        cond = process_lhs(node, compiler, connection)
     else:
         node = self
-        # lhs_mql = process_lhs(self, compiler, connection)
-    lhs_mql = process_lhs(node, compiler, connection)
-    null_cond = {"$in": [{"$type": lhs_mql}, ["missing", "null"]]}
-    return {"$sum": {"$cond": {"if": null_cond, "then": 0, "else": 1}}}
+        lhs_mql = process_lhs(self, compiler, connection)
+        null_cond = {"$in": [{"$type": lhs_mql}, ["missing", "null"]]}
+        cond = {"$cond": {"if": null_cond, "then": 0, "else": 1}}
+    return {"$sum": cond}
 
 
 def extract(self, compiler, connection):
@@ -163,6 +165,10 @@ def log(self, compiler, connection):
     return func(clone, compiler, connection)
 
 
+def now(self, compiler, connection):  # noqa: ARG001
+    return "$$NOW"
+
+
 def null_if(self, compiler, connection):
     """Return None if expr1==expr2 else expr1."""
     expr1, expr2 = (expr.as_mql(compiler, connection) for expr in self.get_source_expressions())
@@ -196,6 +202,10 @@ def round_(self, compiler, connection):
     return {"$round": [expr.as_mql(compiler, connection) for expr in self.get_source_expressions()]}
 
 
+def star(self, compiler, connection):  # noqa: ARG001
+    return {"$literal": True}
+
+
 def str_index(self, compiler, connection):
     lhs = process_lhs(self, compiler, connection)
     # StrIndex should be 0-indexed (not found) but it's -1-indexed on MongoDB.
@@ -243,10 +253,12 @@ def register_functions():
     Log.as_mql = log
     Lower.as_mql = perserve_null("toLower")
     LTrim.as_mql = trim("ltrim")
+    Now.as_mql = now
     NullIf.as_mql = null_if
     Replace.as_mql = replace
     Round.as_mql = round_
     RTrim.as_mql = trim("rtrim")
+    Star.as_mql = star
     StrIndex.as_mql = str_index
     Substr.as_mql = substr
     Trim.as_mql = trim("trim")

django_mongodb/query.py

@@ -47,7 +47,7 @@ def __init__(self, compiler):
         self.collection = self.compiler.get_collection()
         self.collection_name = self.compiler.collection_name
         self.mongo_query = getattr(compiler.query, "raw_query", {})
-        self.sub_query = None
+        self.subquery = None
         self.lookup_pipeline = None
         self.annotation_stage = None
         self.project_fields = None
@@ -90,7 +90,7 @@ def delete(self):
         return self.collection.delete_many(self.mongo_query, **options).deleted_count
 
     def get_pipeline(self, count=False, limit=None, skip=None):
-        pipeline = [] if self.sub_query is None else self.sub_query.get_pipeline()
+        pipeline = [] if self.subquery is None else self.subquery.get_pipeline()
         if self.lookup_pipeline:
             pipeline.extend(self.lookup_pipeline)
         if self.mongo_query: