Rename AggregateAs() -> SelectAggregate().

dgeelen-uipath · dgeelen-uipath · commit 0dd03387ce9c · 2021-06-21T15:58:00.000+02:00
diff --git a/QueryBuilder.Tests/AggregateTests.cs b/QueryBuilder.Tests/AggregateTests.cs
@@ -8,15 +8,15 @@ namespace SqlKata.Tests
     public class AggregateTests : TestSupport
     {
         [Fact]
-        public void AggregateAsEmpty()
+        public void SelectAggregateEmpty()
         {
-            Assert.Throws<ArgumentException>(() => new Query("A").AggregateAs("aggregate", new string[] { }));
+            Assert.Throws<ArgumentException>(() => new Query("A").SelectAggregate("aggregate", new string[] { }));
         }
 
         [Fact]
-        public void AggregateAs()
+        public void SelectAggregate()
         {
-            var query = new Query("A").AggregateAs("aggregate", new[] { "Column" });
+            var query = new Query("A").SelectAggregate("aggregate", new[] { "Column" });
 
             var c = Compile(query);
 
@@ -27,9 +27,9 @@ public void AggregateAs()
         }
 
         [Fact]
-        public void AggregateAsAlias()
+        public void SelectAggregateAlias()
         {
-            var query = new Query("A").AggregateAs("aggregate", new[] { "Column" }, "Alias");
+            var query = new Query("A").SelectAggregate("aggregate", new[] { "Column" }, "Alias");
 
             var c = Compile(query);
 
@@ -40,9 +40,9 @@ public void AggregateAsAlias()
         }
 
         [Fact]
-        public void AggregateAsMultipleColumns()
+        public void SelectAggregateMultipleColumns()
         {
-            var query = new Query("A").AggregateAs("aggregate", new[] { "Column1", "Column2" });
+            var query = new Query("A").SelectAggregate("aggregate", new[] { "Column1", "Column2" });
 
             var c = Compile(query);
 
@@ -53,9 +53,9 @@ public void AggregateAsMultipleColumns()
         }
 
         [Fact]
-        public void AggregateAsMultipleColumnsAlias()
+        public void SelectAggregateMultipleColumnsAlias()
         {
-            var query = new Query("A").AggregateAs("aggregate", new[] { "Column1", "Column2" }, "Alias");
+            var query = new Query("A").SelectAggregate("aggregate", new[] { "Column1", "Column2" }, "Alias");
 
             var c = Compile(query);
 
@@ -66,9 +66,9 @@ public void AggregateAsMultipleColumnsAlias()
         }
 
         [Fact]
-        public void CountAs()
+        public void SelectCount()
         {
-            var query = new Query("A").CountAs();
+            var query = new Query("A").SelectCount();
 
             var c = Compile(query);
 
@@ -79,9 +79,9 @@ public void CountAs()
         }
 
         [Fact]
-        public void CountAsStarAlias()
+        public void SelectCountStarAlias()
         {
-            var query = new Query("A").CountAs("*", "Alias");
+            var query = new Query("A").SelectCount("*", "Alias");
 
             var c = Compile(query);
 
@@ -92,9 +92,9 @@ public void CountAsStarAlias()
         }
 
         [Fact]
-        public void CountAsColumnAlias()
+        public void SelectCountColumnAlias()
         {
-            var query = new Query("A").CountAs("Column", "Alias");
+            var query = new Query("A").SelectCount("Column", "Alias");
 
             var c = Compile(query);
 
@@ -105,17 +105,17 @@ public void CountAsColumnAlias()
         }
 
         [Fact]
-        public void CountAsDoesntModifyColumns()
+        public void SelectCountDoesntModifyColumns()
         {
             {
                 var columns = new string[] { };
-                var query = new Query("A").CountAs(columns);
+                var query = new Query("A").SelectCount(columns);
                 Compile(query);
                 Assert.Equal(columns, new string[] { });
             }
             {
                 var columns = new[] { "ColumnA", "ColumnB" };
-                var query = new Query("A").CountAs(columns);
+                var query = new Query("A").SelectCount(columns);
                 Compile(query);
                 Assert.Equal(columns, new[] { "ColumnA", "ColumnB" });
             }
@@ -124,17 +124,17 @@ public void CountAsDoesntModifyColumns()
         [Fact]
         public void CountMultipleColumns()
         {
-            var query = new Query("A").CountAs(new[] { "ColumnA", "ColumnB" });
+            var query = new Query("A").SelectCount(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]);
         }
 
         [Fact]
-        public void CountAsMultipleColumns()
+        public void SelectCountMultipleColumns()
         {
-            var query = new Query("A").CountAs(new[] { "ColumnA", "ColumnB" }, "Alias");
+            var query = new Query("A").SelectCount(new[] { "ColumnA", "ColumnB" }, "Alias");
 
             var c = Compile(query);
 
@@ -144,7 +144,7 @@ public void CountAsMultipleColumns()
         [Fact]
         public void DistinctCount()
         {
-            var query = new Query("A").Distinct().CountAs();
+            var query = new Query("A").Distinct().SelectCount();
 
             var c = Compile(query);
 
@@ -154,7 +154,7 @@ public void DistinctCount()
         [Fact]
         public void DistinctCountMultipleColumns()
         {
-            var query = new Query("A").Distinct().CountAs(new[] { "ColumnA", "ColumnB" });
+            var query = new Query("A").Distinct().SelectCount(new[] { "ColumnA", "ColumnB" });
 
             var c = Compile(query);
 
@@ -164,7 +164,7 @@ public void DistinctCountMultipleColumns()
         [Fact]
         public void Average()
         {
-            var query = new Query("A").AverageAs("TTL");
+            var query = new Query("A").SelectAverage("TTL");
 
             var c = Compile(query);
 
@@ -174,7 +174,7 @@ public void Average()
         [Fact]
         public void AverageAlias()
         {
-            var query = new Query("A").AverageAs("TTL", "Alias");
+            var query = new Query("A").SelectAverage("TTL", "Alias");
 
             var c = Compile(query);
 
@@ -184,7 +184,7 @@ public void AverageAlias()
         [Fact]
         public void Sum()
         {
-            var query = new Query("A").SumAs("PacketsDropped");
+            var query = new Query("A").SelectSum("PacketsDropped");
 
             var c = Compile(query);
 
@@ -194,7 +194,7 @@ public void Sum()
         [Fact]
         public void SumAlias()
         {
-            var query = new Query("A").SumAs("PacketsDropped", "Alias");
+            var query = new Query("A").SelectSum("PacketsDropped", "Alias");
 
             var c = Compile(query);
 
@@ -204,7 +204,7 @@ public void SumAlias()
         [Fact]
         public void Max()
         {
-            var query = new Query("A").MaxAs("LatencyMs");
+            var query = new Query("A").SelectMax("LatencyMs");
 
             var c = Compile(query);
 
@@ -214,7 +214,7 @@ public void Max()
         [Fact]
         public void MaxAlias()
         {
-            var query = new Query("A").MaxAs("LatencyMs", "Alias");
+            var query = new Query("A").SelectMax("LatencyMs", "Alias");
 
             var c = Compile(query);
 
@@ -224,7 +224,7 @@ public void MaxAlias()
         [Fact]
         public void Min()
         {
-            var query = new Query("A").MinAs("LatencyMs");
+            var query = new Query("A").SelectMin("LatencyMs");
 
             var c = Compile(query);
 
@@ -234,7 +234,7 @@ public void Min()
         [Fact]
         public void MinAlias()
         {
-            var query = new Query("A").MinAs("LatencyMs", "Alias");
+            var query = new Query("A").SelectMin("LatencyMs", "Alias");
 
             var c = Compile(query);
 
diff --git a/QueryBuilder.Tests/DefineTest.cs b/QueryBuilder.Tests/DefineTest.cs
@@ -29,7 +29,7 @@ public void Test_Define_SubQuery()
         {
 
             var subquery = new Query("Products")
-                .AverageAs("unitprice")
+                .SelectAverage("unitprice")
                 .Define("@UnitsInSt", 10)
                 .Where("UnitsInStock", ">", Variable("@UnitsInSt"));
 
@@ -252,7 +252,7 @@ public void Test_Define_NestedCondition()
                .Where(q =>
                    q.Where("ShipRegion", "!=", Variable("@shipReg"))
                 //    .WhereRaw("1 = @one")
-                ).CountAs();
+                ).SelectCount();
 
             var c = Compile(query);
 
diff --git a/QueryBuilder.Tests/SelectTests.cs b/QueryBuilder.Tests/SelectTests.cs
@@ -192,7 +192,7 @@ public void OrWhereNull()
         [Fact]
         public void WhereSub()
         {
-            var subQuery = new Query("Table2").WhereColumns("Table2.Column", "=", "Table.MyCol").CountAs();
+            var subQuery = new Query("Table2").WhereColumns("Table2.Column", "=", "Table.MyCol").SelectCount();
 
             var query = new Query("Table").WhereSub(subQuery, 1);
 
@@ -206,7 +206,7 @@ public void WhereSub()
         [Fact]
         public void OrWhereSub()
         {
-            var subQuery = new Query("Table2").WhereColumns("Table2.Column", "=", "Table.MyCol").CountAs();
+            var subQuery = new Query("Table2").WhereColumns("Table2.Column", "=", "Table.MyCol").SelectCount();
 
             var query = new Query("Table").WhereNull("MyCol").OrWhereSub(subQuery, "<", 1);
 
diff --git a/QueryBuilder/Query.Aggregate.cs b/QueryBuilder/Query.Aggregate.cs
@@ -8,7 +8,7 @@ public partial class Query
         /**********************************************************************
          ** Generic aggregate                                                **
          **********************************************************************/
-        public Query AggregateAs(string type, IEnumerable<string> columns, string alias = null)
+        public Query SelectAggregate(string type, IEnumerable<string> columns, string alias = null)
         {
             if (columns.Count() == 0)
             {
@@ -32,55 +32,55 @@ public Query AggregateAs(string type, IEnumerable<string> columns, string alias
         /**********************************************************************
          ** Count                                                            **
          **********************************************************************/
-        public Query CountAs(string column = null, string alias = null)
+        public Query SelectCount(string column = null, string alias = null)
         {
-            return CountAs(column != null ? new[] { column } : new string[] { }, alias);
+            return SelectCount(column != null ? new[] { column } : new string[] { }, alias);
         }
 
-        public Query CountAs(IEnumerable<string> columns, string alias = null)
+        public Query SelectCount(IEnumerable<string> columns, string alias = null)
         {
-            return AggregateAs("count", columns.Count() == 0 ? new[] { "*" } : columns, alias);
+            return SelectAggregate("count", columns.Count() == 0 ? new[] { "*" } : columns, alias);
         }
 
 
         /**********************************************************************
          ** Average                                                          **
          **********************************************************************/
-        public Query AvgAs(string column, string alias = null)
+        public Query SelectAvg(string column, string alias = null)
         {
-            return AggregateAs("avg", new[] { column }, alias);
+            return SelectAggregate("avg", new[] { column }, alias);
         }
 
-        public Query AverageAs(string column, string alias = null)
+        public Query SelectAverage(string column, string alias = null)
         {
-            return AvgAs(column, alias);
+            return SelectAvg(column, alias);
         }
 
 
         /**********************************************************************
          ** Sum                                                              **
          **********************************************************************/
-        public Query SumAs(string column, string alias = null)
+        public Query SelectSum(string column, string alias = null)
         {
-            return AggregateAs("sum", new[] { column }, alias);
+            return SelectAggregate("sum", new[] { column }, alias);
         }
 
 
         /**********************************************************************
          ** Maximum                                                          **
          **********************************************************************/
-        public Query MaxAs(string column, string alias = null)
+        public Query SelectMax(string column, string alias = null)
         {
-            return AggregateAs("max", new[] { column }, alias);
+            return SelectAggregate("max", new[] { column }, alias);
         }
 
 
         /**********************************************************************
          ** Minimum                                                          **
          **********************************************************************/
-        public Query MinAs(string column, string alias = null)
+        public Query SelectMin(string column, string alias = null)
         {
-            return AggregateAs("min", new[] { column }, alias);
+            return SelectAggregate("min", new[] { column }, alias);
         }
     }
 }
diff --git a/SqlKata.Execution/Query.Extensions.cs b/SqlKata.Execution/Query.Extensions.cs
diff --git a/SqlKata.Execution/QueryFactory.cs b/SqlKata.Execution/QueryFactory.cs

Original file line number	Diff line number	Diff line change
`@@ -8,15 +8,15 @@ namespace SqlKata.Tests`
`8`	`8`	`public class AggregateTests : TestSupport`
`9`	`9`	`{`
`10`	`10`	`[Fact]`
`11`		`- public void AggregateAsEmpty()`
	`11`	`+ public void SelectAggregateEmpty()`
`12`	`12`	`{`
`13`		`- Assert.Throws<ArgumentException>(() => new Query("A").AggregateAs("aggregate", new string[] { }));`
	`13`	`+ Assert.Throws<ArgumentException>(() => new Query("A").SelectAggregate("aggregate", new string[] { }));`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`[Fact]`
`17`		`- public void AggregateAs()`
	`17`	`+ public void SelectAggregate()`
`18`	`18`	`{`
`19`		`- var query = new Query("A").AggregateAs("aggregate", new[] { "Column" });`
	`19`	`+ var query = new Query("A").SelectAggregate("aggregate", new[] { "Column" });`
`20`	`20`
`21`	`21`	`var c = Compile(query);`
`22`	`22`
`@@ -27,9 +27,9 @@ public void AggregateAs()`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`[Fact]`
`30`		`- public void AggregateAsAlias()`
	`30`	`+ public void SelectAggregateAlias()`
`31`	`31`	`{`
`32`		`- var query = new Query("A").AggregateAs("aggregate", new[] { "Column" }, "Alias");`
	`32`	`+ var query = new Query("A").SelectAggregate("aggregate", new[] { "Column" }, "Alias");`
`33`	`33`
`34`	`34`	`var c = Compile(query);`
`35`	`35`
`@@ -40,9 +40,9 @@ public void AggregateAsAlias()`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`[Fact]`
`43`		`- public void AggregateAsMultipleColumns()`
	`43`	`+ public void SelectAggregateMultipleColumns()`
`44`	`44`	`{`
`45`		`- var query = new Query("A").AggregateAs("aggregate", new[] { "Column1", "Column2" });`
	`45`	`+ var query = new Query("A").SelectAggregate("aggregate", new[] { "Column1", "Column2" });`
`46`	`46`
`47`	`47`	`var c = Compile(query);`
`48`	`48`
`@@ -53,9 +53,9 @@ public void AggregateAsMultipleColumns()`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`[Fact]`
`56`		`- public void AggregateAsMultipleColumnsAlias()`
	`56`	`+ public void SelectAggregateMultipleColumnsAlias()`
`57`	`57`	`{`
`58`		`- var query = new Query("A").AggregateAs("aggregate", new[] { "Column1", "Column2" }, "Alias");`
	`58`	`+ var query = new Query("A").SelectAggregate("aggregate", new[] { "Column1", "Column2" }, "Alias");`
`59`	`59`
`60`	`60`	`var c = Compile(query);`
`61`	`61`
`@@ -66,9 +66,9 @@ public void AggregateAsMultipleColumnsAlias()`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`[Fact]`
`69`		`- public void CountAs()`
	`69`	`+ public void SelectCount()`
`70`	`70`	`{`
`71`		`- var query = new Query("A").CountAs();`
	`71`	`+ var query = new Query("A").SelectCount();`
`72`	`72`
`73`	`73`	`var c = Compile(query);`
`74`	`74`
`@@ -79,9 +79,9 @@ public void CountAs()`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`[Fact]`
`82`		`- public void CountAsStarAlias()`
	`82`	`+ public void SelectCountStarAlias()`
`83`	`83`	`{`
`84`		`- var query = new Query("A").CountAs("*", "Alias");`
	`84`	`+ var query = new Query("A").SelectCount("*", "Alias");`
`85`	`85`
`86`	`86`	`var c = Compile(query);`
`87`	`87`
`@@ -92,9 +92,9 @@ public void CountAsStarAlias()`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`[Fact]`
`95`		`- public void CountAsColumnAlias()`
	`95`	`+ public void SelectCountColumnAlias()`
`96`	`96`	`{`
`97`		`- var query = new Query("A").CountAs("Column", "Alias");`
	`97`	`+ var query = new Query("A").SelectCount("Column", "Alias");`
`98`	`98`
`99`	`99`	`var c = Compile(query);`
`100`	`100`
`@@ -105,17 +105,17 @@ public void CountAsColumnAlias()`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`[Fact]`
`108`		`- public void CountAsDoesntModifyColumns()`
	`108`	`+ public void SelectCountDoesntModifyColumns()`
`109`	`109`	`{`
`110`	`110`	`{`
`111`	`111`	`var columns = new string[] { };`
`112`		`- var query = new Query("A").CountAs(columns);`
	`112`	`+ var query = new Query("A").SelectCount(columns);`
`113`	`113`	`Compile(query);`
`114`	`114`	`Assert.Equal(columns, new string[] { });`
`115`	`115`	`}`
`116`	`116`	`{`
`117`	`117`	`var columns = new[] { "ColumnA", "ColumnB" };`
`118`		`- var query = new Query("A").CountAs(columns);`
	`118`	`+ var query = new Query("A").SelectCount(columns);`
`119`	`119`	`Compile(query);`
`120`	`120`	`Assert.Equal(columns, new[] { "ColumnA", "ColumnB" });`
`121`	`121`	`}`
`@@ -124,17 +124,17 @@ public void CountAsDoesntModifyColumns()`
`124`	`124`	`[Fact]`
`125`	`125`	`public void CountMultipleColumns()`
`126`	`126`	`{`
`127`		`- var query = new Query("A").CountAs(new[] { "ColumnA", "ColumnB" });`
	`127`	`+ var query = new Query("A").SelectCount(new[] { "ColumnA", "ColumnB" });`
`128`	`128`
`129`	`129`	`var c = Compile(query);`
`130`	`130`
`131`	`131`	`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]);`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`[Fact]`
`135`		`- public void CountAsMultipleColumns()`
	`135`	`+ public void SelectCountMultipleColumns()`
`136`	`136`	`{`
`137`		`- var query = new Query("A").CountAs(new[] { "ColumnA", "ColumnB" }, "Alias");`
	`137`	`+ var query = new Query("A").SelectCount(new[] { "ColumnA", "ColumnB" }, "Alias");`
`138`	`138`
`139`	`139`	`var c = Compile(query);`
`140`	`140`
`@@ -144,7 +144,7 @@ public void CountAsMultipleColumns()`
`144`	`144`	`[Fact]`
`145`	`145`	`public void DistinctCount()`
`146`	`146`	`{`
`147`		`- var query = new Query("A").Distinct().CountAs();`
	`147`	`+ var query = new Query("A").Distinct().SelectCount();`
`148`	`148`
`149`	`149`	`var c = Compile(query);`
`150`	`150`
`@@ -154,7 +154,7 @@ public void DistinctCount()`
`154`	`154`	`[Fact]`
`155`	`155`	`public void DistinctCountMultipleColumns()`
`156`	`156`	`{`
`157`		`- var query = new Query("A").Distinct().CountAs(new[] { "ColumnA", "ColumnB" });`
	`157`	`+ var query = new Query("A").Distinct().SelectCount(new[] { "ColumnA", "ColumnB" });`
`158`	`158`
`159`	`159`	`var c = Compile(query);`
`160`	`160`
`@@ -164,7 +164,7 @@ public void DistinctCountMultipleColumns()`
`164`	`164`	`[Fact]`
`165`	`165`	`public void Average()`
`166`	`166`	`{`
`167`		`- var query = new Query("A").AverageAs("TTL");`
	`167`	`+ var query = new Query("A").SelectAverage("TTL");`
`168`	`168`
`169`	`169`	`var c = Compile(query);`
`170`	`170`
`@@ -174,7 +174,7 @@ public void Average()`
`174`	`174`	`[Fact]`
`175`	`175`	`public void AverageAlias()`
`176`	`176`	`{`
`177`		`- var query = new Query("A").AverageAs("TTL", "Alias");`
	`177`	`+ var query = new Query("A").SelectAverage("TTL", "Alias");`
`178`	`178`
`179`	`179`	`var c = Compile(query);`
`180`	`180`
`@@ -184,7 +184,7 @@ public void AverageAlias()`
`184`	`184`	`[Fact]`
`185`	`185`	`public void Sum()`
`186`	`186`	`{`
`187`		`- var query = new Query("A").SumAs("PacketsDropped");`
	`187`	`+ var query = new Query("A").SelectSum("PacketsDropped");`
`188`	`188`
`189`	`189`	`var c = Compile(query);`
`190`	`190`
`@@ -194,7 +194,7 @@ public void Sum()`
`194`	`194`	`[Fact]`
`195`	`195`	`public void SumAlias()`
`196`	`196`	`{`
`197`		`- var query = new Query("A").SumAs("PacketsDropped", "Alias");`
	`197`	`+ var query = new Query("A").SelectSum("PacketsDropped", "Alias");`
`198`	`198`
`199`	`199`	`var c = Compile(query);`
`200`	`200`
`@@ -204,7 +204,7 @@ public void SumAlias()`
`204`	`204`	`[Fact]`
`205`	`205`	`public void Max()`
`206`	`206`	`{`
`207`		`- var query = new Query("A").MaxAs("LatencyMs");`
	`207`	`+ var query = new Query("A").SelectMax("LatencyMs");`
`208`	`208`
`209`	`209`	`var c = Compile(query);`
`210`	`210`
`@@ -214,7 +214,7 @@ public void Max()`
`214`	`214`	`[Fact]`
`215`	`215`	`public void MaxAlias()`
`216`	`216`	`{`
`217`		`- var query = new Query("A").MaxAs("LatencyMs", "Alias");`
	`217`	`+ var query = new Query("A").SelectMax("LatencyMs", "Alias");`
`218`	`218`
`219`	`219`	`var c = Compile(query);`
`220`	`220`
`@@ -224,7 +224,7 @@ public void MaxAlias()`
`224`	`224`	`[Fact]`
`225`	`225`	`public void Min()`
`226`	`226`	`{`
`227`		`- var query = new Query("A").MinAs("LatencyMs");`
	`227`	`+ var query = new Query("A").SelectMin("LatencyMs");`
`228`	`228`
`229`	`229`	`var c = Compile(query);`
`230`	`230`
`@@ -234,7 +234,7 @@ public void Min()`
`234`	`234`	`[Fact]`
`235`	`235`	`public void MinAlias()`
`236`	`236`	`{`
`237`		`- var query = new Query("A").MinAs("LatencyMs", "Alias");`
	`237`	`+ var query = new Query("A").SelectMin("LatencyMs", "Alias");`
`238`	`238`
`239`	`239`	`var c = Compile(query);`
`240`	`240`
Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ public void OrWhereNull()`
`192`	`192`	`[Fact]`
`193`	`193`	`public void WhereSub()`
`194`	`194`	`{`
`195`		`- var subQuery = new Query("Table2").WhereColumns("Table2.Column", "=", "Table.MyCol").CountAs();`
	`195`	`+ var subQuery = new Query("Table2").WhereColumns("Table2.Column", "=", "Table.MyCol").SelectCount();`
`196`	`196`
`197`	`197`	`var query = new Query("Table").WhereSub(subQuery, 1);`
`198`	`198`
`@@ -206,7 +206,7 @@ public void WhereSub()`
`206`	`206`	`[Fact]`
`207`	`207`	`public void OrWhereSub()`
`208`	`208`	`{`
`209`		`- var subQuery = new Query("Table2").WhereColumns("Table2.Column", "=", "Table.MyCol").CountAs();`
	`209`	`+ var subQuery = new Query("Table2").WhereColumns("Table2.Column", "=", "Table.MyCol").SelectCount();`
`210`	`210`
`211`	`211`	`var query = new Query("Table").WhereNull("MyCol").OrWhereSub(subQuery, "<", 1);`
`212`	`212`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ public partial class Query`
`8`	`8`	`/**********************************************************************`
`9`	`9`	` Generic aggregate `
`10`	`10`	`**********************************************************************/`
`11`		`- public Query AggregateAs(string type, IEnumerable<string> columns, string alias = null)`
	`11`	`+ public Query SelectAggregate(string type, IEnumerable<string> columns, string alias = null)`
`12`	`12`	`{`
`13`	`13`	`if (columns.Count() == 0)`
`14`	`14`	`{`
`@@ -32,55 +32,55 @@ public Query AggregateAs(string type, IEnumerable<string> columns, string alias`
`32`	`32`	`/**********************************************************************`
`33`	`33`	` Count `
`34`	`34`	`**********************************************************************/`
`35`		`- public Query CountAs(string column = null, string alias = null)`
	`35`	`+ public Query SelectCount(string column = null, string alias = null)`
`36`	`36`	`{`
`37`		`- return CountAs(column != null ? new[] { column } : new string[] { }, alias);`
	`37`	`+ return SelectCount(column != null ? new[] { column } : new string[] { }, alias);`
`38`	`38`	`}`
`39`	`39`
`40`		`- public Query CountAs(IEnumerable<string> columns, string alias = null)`
	`40`	`+ public Query SelectCount(IEnumerable<string> columns, string alias = null)`
`41`	`41`	`{`
`42`		`- return AggregateAs("count", columns.Count() == 0 ? new[] { "*" } : columns, alias);`
	`42`	`+ return SelectAggregate("count", columns.Count() == 0 ? new[] { "*" } : columns, alias);`
`43`	`43`	`}`
`44`	`44`
`45`	`45`
`46`	`46`	`/**********************************************************************`
`47`	`47`	` Average `
`48`	`48`	`**********************************************************************/`
`49`		`- public Query AvgAs(string column, string alias = null)`
	`49`	`+ public Query SelectAvg(string column, string alias = null)`
`50`	`50`	`{`
`51`		`- return AggregateAs("avg", new[] { column }, alias);`
	`51`	`+ return SelectAggregate("avg", new[] { column }, alias);`
`52`	`52`	`}`
`53`	`53`
`54`		`- public Query AverageAs(string column, string alias = null)`
	`54`	`+ public Query SelectAverage(string column, string alias = null)`
`55`	`55`	`{`
`56`		`- return AvgAs(column, alias);`
	`56`	`+ return SelectAvg(column, alias);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`
`60`	`60`	`/**********************************************************************`
`61`	`61`	` Sum `
`62`	`62`	`**********************************************************************/`
`63`		`- public Query SumAs(string column, string alias = null)`
	`63`	`+ public Query SelectSum(string column, string alias = null)`
`64`	`64`	`{`
`65`		`- return AggregateAs("sum", new[] { column }, alias);`
	`65`	`+ return SelectAggregate("sum", new[] { column }, alias);`
`66`	`66`	`}`
`67`	`67`
`68`	`68`
`69`	`69`	`/**********************************************************************`
`70`	`70`	` Maximum `
`71`	`71`	`**********************************************************************/`
`72`		`- public Query MaxAs(string column, string alias = null)`
	`72`	`+ public Query SelectMax(string column, string alias = null)`
`73`	`73`	`{`
`74`		`- return AggregateAs("max", new[] { column }, alias);`
	`74`	`+ return SelectAggregate("max", new[] { column }, alias);`
`75`	`75`	`}`
`76`	`76`
`77`	`77`
`78`	`78`	`/**********************************************************************`
`79`	`79`	` Minimum `
`80`	`80`	`**********************************************************************/`
`81`		`- public Query MinAs(string column, string alias = null)`
	`81`	`+ public Query SelectMin(string column, string alias = null)`
`82`	`82`	`{`
`83`		`- return AggregateAs("min", new[] { column }, alias);`
	`83`	`+ return SelectAggregate("min", new[] { column }, alias);`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`	`}`