enahance/fix AsCount support

initial fix for issues #185  and #186
add aggregate query builder tests

Author: ceastwood

QueryBuilder.Tests/QueryBuilderTest.Aggregate.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace SqlKata.Tests
+{
+    public partial class QueryBuilderTest
+    {
+        [Fact]
+        public void Count()
+        {
+            var query = new Query("A").AsCount();
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT COUNT(*) AS [count] FROM [A]", c[0]);
+            Assert.Equal("SELECT COUNT(*) AS `count` FROM `A`", c[1]);
+            Assert.Equal("SELECT COUNT(*) AS \"count\" FROM \"A\"", c[2]);
+            Assert.Equal("SELECT COUNT(*) AS \"COUNT\" FROM \"A\"", c[3]);
+        }
+
+        [Fact]
+        public void CountMultipleColumns()
+        {
+            var query = new Query("A").AsCount("ColumnA", "ColumnB");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT 1 FROM [A] WHERE [ColumnA] IS NOT NULL AND [ColumnB] IS NOT NULL) AS [countQuery]", c[0]);
+        }
+
+        [Fact]
+        public void DistinctCount()
+        {
+            var query = new Query("A").Distinct().AsCount();
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT * FROM [A]) AS [countQuery]", c[0]);
+        }
+
+        [Fact]
+        public void DistinctCountMultipleColumns()
+        {
+            var query = new Query("A").Distinct().AsCount("ColumnA", "ColumnB");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT [ColumnA], [ColumnB] FROM [A]) AS [countQuery]", c[0]);
+        }
+
+        [Fact]
+        public void Average()
+        {
+            var query = new Query("A").AsAverage("TTL");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT AVG([TTL]) AS [avg] FROM [A]", c[0]);
+        }
+
+        [Fact]
+        public void Sum()
+        {
+            var query = new Query("A").AsSum("PacketsDropped");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT SUM([PacketsDropped]) AS [sum] FROM [A]", c[0]);
+        }
+
+        [Fact]
+        public void Max()
+        {
+            var query = new Query("A").AsMax("LatencyMs");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT MAX([LatencyMs]) AS [max] FROM [A]", c[0]);
+        }
+
+        [Fact]
+        public void Min()
+        {
+            var query = new Query("A").AsMin("LatencyMs");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT MIN([LatencyMs]) AS [min] FROM [A]", c[0]);
+        }
+    }
+}

QueryBuilder.Tests/QueryBuilderTest.cs

@@ -8,7 +8,7 @@
 
 namespace SqlKata.Tests
 {
-    public class QueryBuilderTest
+    public partial class QueryBuilderTest
     {
         private readonly Compiler pgsql;
         private readonly MySqlCompiler mysql;
@@ -817,20 +817,6 @@ public void Return_Different_MethodInfo_WhenSame_Method_With_Different_GenericTy
             Assert.NotSame(call1, call2);
         }
 
-
-        [Fact]
-        public void Count()
-        {
-            var query = new Query("A").AsCount().Limit(1);
-
-            var c = Compile(query);
-
-            Assert.Equal("SELECT COUNT(*) AS [count] FROM [A]", c[0]);
-            Assert.Equal("SELECT COUNT(*) AS `count` FROM `A`", c[1]);
-            Assert.Equal("SELECT COUNT(*) AS \"count\" FROM \"A\"", c[2]);
-            Assert.Equal("SELECT COUNT(*) AS \"COUNT\" FROM \"A\"", c[3]);
-        }
-
         [Fact]
         public void Should_Equal_AfterMultipleCompile()
         {

QueryBuilder/Compilers/Compiler.cs

@@ -57,6 +57,35 @@ protected SqlResult PrepareResult(SqlResult ctx)
             return ctx;
         }
 
+        private Query TransformAggregateQuery(Query query)
+        {
+            var clause = query.GetOneComponent<AggregateClause>("aggregate", EngineCode);
+            if (clause.Columns.Count == 1 && !query.IsDistinct) return query;
+
+            if (query.IsDistinct)
+            {
+                query.ClearComponent("aggregate", EngineCode);
+                query.Select(clause.Columns.ToArray());
+            }
+            else
+            {
+                foreach (var column in clause.Columns)
+                {
+                    query.WhereNotNull(column);
+                }
+            }
+
+            var outerClause = new AggregateClause()
+            {
+                Columns = new List<string> {"*"},
+                Type = clause.Type
+            };
+
+            return new Query()
+                .AddComponent("aggregate", outerClause)
+                .From(query, $"{clause.Type}Query");
+        }
+
         protected virtual SqlResult CompileRaw(Query query)
         {
             SqlResult ctx;
@@ -80,6 +109,8 @@ protected virtual SqlResult CompileRaw(Query query)
                     query.ClearComponent("limit")
                         .ClearComponent("order")
                         .ClearComponent("group");
+
+                    query = TransformAggregateQuery(query);
                 }
 
                 ctx = CompileSelectQuery(query);
@@ -395,7 +426,6 @@ protected virtual SqlResult OnBeforeSelect(SqlResult ctx)
 
         protected virtual string CompileColumns(SqlResult ctx)
         {
-
             if (ctx.Query.HasComponent("aggregate", EngineCode))
             {
                 var aggregate = ctx.Query.GetOneComponent<AggregateClause>("aggregate", EngineCode);
@@ -404,14 +434,21 @@ protected virtual string CompileColumns(SqlResult ctx)
                     .Select(x => CompileColumn(ctx, new Column { Name = x }))
                     .ToList();
 
-                var sql = string.Join(", ", aggregateColumns);
+                string sql = string.Empty;
 
-                if (ctx.Query.IsDistinct)
+                if (aggregateColumns.Count == 1)
                 {
-                    sql = "DISTINCT " + sql;
+                    sql = string.Join(", ", aggregateColumns);
+
+                    if (ctx.Query.IsDistinct)
+                    {
+                        sql = "DISTINCT " + sql;
+                    }
+
+                    return "SELECT " + aggregate.Type.ToUpper() + "(" + sql + $") {ColumnAsKeyword}" + WrapValue(aggregate.Type);
                 }
 
-                return "SELECT " + aggregate.Type.ToUpper() + "(" + sql + $") {ColumnAsKeyword}" + WrapValue(aggregate.Type);
+                return "SELECT 1";
             }
 
             var columns = ctx.Query