Implement column-as keyword for 'count' aggregate with AsCountAs().

QueryBuilder.Tests/AggregateTests.cs

@@ -26,14 +26,67 @@ public void Count()
             Assert.Equal("SELECT COUNT(*) AS \"COUNT\" FROM \"A\"", c[EngineCodes.Firebird]);
         }
 
+        [Fact]
+        public void CountAsStarAlias()
+        {
+            var query = new Query("A").AsCountAs("*", "Alias");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT COUNT(*) AS [Alias] FROM [A]", c[EngineCodes.SqlServer]);
+            Assert.Equal("SELECT COUNT(*) AS `Alias` FROM `A`", c[EngineCodes.MySql]);
+            Assert.Equal("SELECT COUNT(*) AS \"Alias\" FROM \"A\"", c[EngineCodes.PostgreSql]);
+            Assert.Equal("SELECT COUNT(*) AS \"ALIAS\" FROM \"A\"", c[EngineCodes.Firebird]);
+        }
+
+        [Fact]
+        public void CountAsColumnAlias()
+        {
+            var query = new Query("A").AsCountAs("Column", "Alias");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT COUNT([Column]) AS [Alias] FROM [A]", c[EngineCodes.SqlServer]);
+            Assert.Equal("SELECT COUNT(`Column`) AS `Alias` FROM `A`", c[EngineCodes.MySql]);
+            Assert.Equal("SELECT COUNT(\"Column\") AS \"Alias\" FROM \"A\"", c[EngineCodes.PostgreSql]);
+            Assert.Equal("SELECT COUNT(\"COLUMN\") AS \"ALIAS\" FROM \"A\"", c[EngineCodes.Firebird]);
+        }
+
+        [Fact]
+        public void CountDoesntModifyColumns()
+        {
+            {
+                var columns = new string[] { };
+                var query = new Query("A").AsCount(columns);
+                Compile(query);
+                Assert.Equal(columns, new string[] { });
+            }
+            {
+                var columns = new[] { "ColumnA", "ColumnB" };
+                var query = new Query("A").AsCount(columns);
+                Compile(query);
+                Assert.Equal(columns, new[] { "ColumnA", "ColumnB" });
+            }
+        }
+
         [Fact]
         public void CountMultipleColumns()
         {
             var query = new Query("A").AsCount(new[] { "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[EngineCodes.SqlServer]);
+            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 CountAsMultipleColumns()
+        {
+            var query = new Query("A").AsCountAs(new[] { "ColumnA", "ColumnB" }, "Alias");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT COUNT(*) AS [Alias] FROM (SELECT 1 FROM [A] WHERE [ColumnA] IS NOT NULL AND [ColumnB] IS NOT NULL) AS [AliasCountQuery]", c[EngineCodes.SqlServer]);
         }
 
         [Fact]
@@ -43,7 +96,7 @@ public void DistinctCount()
 
             var c = Compile(query);
 
-            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT * FROM [A]) AS [countQuery]", c[EngineCodes.SqlServer]);
+            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT * FROM [A]) AS [CountQuery]", c[EngineCodes.SqlServer]);
         }
 
         [Fact]
@@ -53,7 +106,7 @@ public void DistinctCountMultipleColumns()
 
             var c = Compile(query);
 
-            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT [ColumnA], [ColumnB] FROM [A]) AS [countQuery]", c[EngineCodes.SqlServer]);
+            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT [ColumnA], [ColumnB] FROM [A]) AS [CountQuery]", c[EngineCodes.SqlServer]);
         }
 
         [Fact]

QueryBuilder/Clauses/AggregateClause.cs

@@ -16,6 +16,11 @@ public class AggregateClause : AbstractClause
         /// </value>
         public List<string> Columns { get; set; }
 
+        /// <summary>
+        /// Gets or sets the alias of the result column.
+        /// </summary>
+        public string Alias { get; set; }
+
         /// <summary>
         /// Gets or sets the type of aggregate function.
         /// </summary>
@@ -32,6 +37,7 @@ public override AbstractClause Clone()
                 Engine = Engine,
                 Type = Type,
                 Columns = new List<string>(Columns),
+                Alias = Alias,
                 Component = Component,
             };
         }

QueryBuilder/Compilers/Compiler.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text;
 
@@ -69,7 +70,7 @@ private Query TransformAggregateQuery(Query query)
             {
                 query.ClearComponent("aggregate", EngineCode);
                 query.ClearComponent("select", EngineCode);
-                query.Select(clause.Columns.ToArray());
+                query.SelectAs(clause.Columns.Select(x => (x, null as string)).ToArray());
             }
             else
             {
@@ -82,12 +83,14 @@ private Query TransformAggregateQuery(Query query)
             var outerClause = new AggregateClause()
             {
                 Columns = new List<string> { "*" },
-                Type = clause.Type
+                Type = clause.Type,
+                Alias = clause.Alias,
             };
 
             return new Query()
                 .AddComponent("aggregate", outerClause)
-                .From(query, $"{clause.Type}Query");
+                // Use alias + capitalized type + 'query' as alias
+                .From(query, $"{clause.Alias}{clause.Type.First().ToString().ToUpperInvariant()}{clause.Type.Substring(1)}Query");
         }
 
         protected virtual SqlResult CompileRaw(Query query)
@@ -534,9 +537,12 @@ protected virtual string CompileColumns(SqlResult ctx)
                         sql = "DISTINCT " + sql;
                     }
 
-                    return "SELECT " + aggregate.Type.ToUpperInvariant() + "(" + sql + $") {ColumnAsKeyword}" + WrapValue(aggregate.Type);
+                    return $"SELECT {aggregate.Type.ToUpperInvariant()}({sql}) {ColumnAsKeyword}{WrapValue(aggregate.Alias ?? aggregate.Type)}";
                 }
 
+                // Counts of multiple columns are implemented by a sub-query
+                // which selects 1 from every non-null record. E.g.
+                // SELECT COUNT(*) FROM (SELECT 1 FROM [A] WHERE [ColumnA] IS NOT NULL AND [ColumnB] IS NOT NULL)
                 return "SELECT 1";
             }
 

QueryBuilder/Query.Aggregate.cs

@@ -5,7 +5,7 @@ namespace SqlKata
 {
     public partial class Query
     {
-        public Query AsAggregate(string type, string[] columns = null)
+        public Query AsAggregate(string type, IEnumerable<string> columns, string alias = null)
         {
             if (columns.Count() == 0)
             {
@@ -18,15 +18,16 @@ public Query AsAggregate(string type, string[] columns = null)
             .AddComponent("aggregate", new AggregateClause
             {
                 Type = type,
-                Columns = columns?.ToList() ?? new List<string>(),
+                Columns = columns.ToList(),
+                Alias = alias
             });
 
             return this;
         }
 
-        public Query AsCount(string[] columns = null)
+        public Query AsCount(params string[] columns)
         {
-            var cols = columns?.ToList() ?? new List<string> { };
+            var cols = columns.ToList();
 
             if (!cols.Any())
             {
@@ -36,6 +37,12 @@ public Query AsCount(string[] columns = null)
             return AsAggregate("count", cols.ToArray());
         }
 
+        public Query AsCountAs(string column, string alias) =>
+            AsAggregate("count", new string[] { column }, alias);
+
+        public Query AsCountAs(IEnumerable<string> columns, string alias) =>
+            AsAggregate("count", columns, alias);
+
         public Query AsAvg(string column)
         {
             return AsAggregate("avg", new string[] { column });