Fix grouped count aggregation on SQL Server

Author: apples-kksk

QueryBuilder.Tests/AggregateTests.cs

@@ -29,6 +29,20 @@ public void CountMultipleColumns()
             Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT 1 FROM [A] WHERE [ColumnA] IS NOT NULL AND [ColumnB] IS NOT NULL) AS [countQuery]", c[EngineCodes.SqlServer]);
         }
 
+        [Fact]
+        public void CountWithGroupBy()
+        {
+            var query = new Query("org_storage")
+                .Select("organization_id")
+                .LeftJoin("organizations", "org_storage.organization_id", "organizations.id")
+                .GroupBy("organization_id")
+                .AsCount();
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT [organization_id] FROM [org_storage] \nLEFT JOIN [organizations] ON [org_storage].[organization_id] = [organizations].[id] GROUP BY [organization_id]) AS [countQuery]", c[EngineCodes.SqlServer]);
+        }
+
         [Fact]
         public void DistinctCount()
         {
@@ -69,6 +83,18 @@ public void Sum()
             Assert.Equal("SELECT SUM([PacketsDropped]) AS [sum] FROM [A]", c[EngineCodes.SqlServer]);
         }
 
+        [Fact]
+        public void SumWithGroupBy()
+        {
+            var query = new Query("A")
+                .GroupBy("UserId")
+                .AsSum("PacketsDropped");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT SUM([PacketsDropped]) AS [sum] FROM [A] GROUP BY [UserId]", c[EngineCodes.SqlServer]);
+        }
+
         [Fact]
         public void Max()
         {

QueryBuilder/Compilers/Compiler.cs

@@ -80,16 +80,33 @@ protected SqlResult PrepareResult(SqlResult ctx)
         private Query TransformAggregateQuery(Query query)
         {
             var clause = query.GetOneComponent<AggregateClause>("aggregate", EngineCode);
+            var hasGroup = query.HasComponent("group", EngineCode);
 
-            if (clause.Columns.Count == 1 && !query.IsDistinct) return query;
+            if (clause.Columns.Count == 1 && !query.IsDistinct && (!hasGroup || clause.Type != "count")) return query;
+
+            if (hasGroup && clause.Columns.Count == 1 && !query.IsDistinct)
+            {
+                var innerQuery = query.Clone();
+                innerQuery.ClearComponent("aggregate", EngineCode);
+
+                var groupedOuterClause = new AggregateClause()
+                {
+                    Columns = new List<string> { "*" },
+                    Type = clause.Type
+                };
+
+                return new Query()
+                    .AddComponent("aggregate", groupedOuterClause)
+                    .From(innerQuery, $"{clause.Type}Query");
+            }
 
             if (query.IsDistinct)
             {
                 query.ClearComponent("aggregate", EngineCode);
                 query.ClearComponent("select", EngineCode);
                 query.Select(clause.Columns.ToArray());
             }
-            else
+            else if (!hasGroup)
             {
                 foreach (var column in clause.Columns)
                 {
@@ -129,8 +146,7 @@ protected virtual SqlResult CompileRaw(Query query)
                 if (query.Method == "aggregate")
                 {
                     query.ClearComponent("limit")
-                        .ClearComponent("order")
-                        .ClearComponent("group");
+                        .ClearComponent("order");
 
                     query = TransformAggregateQuery(query);
                 }