iss-507: add the SelectAggregate method to QueryBuilder

Author: ahmad-moussawi

QueryBuilder/Clauses/ColumnClause.cs

@@ -77,4 +77,33 @@ public override AbstractClause Clone()
             };
         }
     }
+
+    /// <summary>
+    /// Represents an aggregated column clause with an optional filter
+    /// </summary>
+    /// <seealso cref="AbstractColumn" />
+    public class AggregatedColumn : AbstractColumn
+    {
+        /// <summary>
+        /// Gets or sets the a query that used to filter the data, 
+        /// the compiler will consider only the `Where` clause.
+        /// </summary>
+        /// <value>
+        /// The filter query.
+        /// </value>
+        public Query Filter { get; set; } = null;
+        public string Aggregate { get; set; }
+        public AbstractColumn Column { get; set; }
+        public override AbstractClause Clone()
+        {
+            return new AggregatedColumn
+            {
+                Engine = Engine,
+                Filter = Filter?.Clone(),
+                Column = Column.Clone() as AbstractColumn,
+                Aggregate = Aggregate,
+                Component = Component,
+            };
+        }
+    }
 }

QueryBuilder/Compilers/Compiler.cs

@@ -24,6 +24,12 @@ protected Compiler()
 
         public virtual string EngineCode { get; }
 
+        /// <summary>
+        /// Whether the compiler supports the `SELECT ... FILTER` syntax
+        /// </summary>
+        /// <value></value>            
+        public virtual bool SupportsFilterClause { get; set; } = false;
+
         protected virtual string SingleRowDummyTableName { get => null; }
 
         /// <summary>
@@ -512,10 +518,44 @@ public virtual string CompileColumn(SqlResult ctx, AbstractColumn column)
                 return "(" + subCtx.RawSql + $"){alias}";
             }
 
+            if (column is AggregatedColumn aggregatedColumn)
+            {
+                string agg = aggregatedColumn.Aggregate.ToUpperInvariant();
+
+                var (col, alias) = SplitAlias(CompileColumn(ctx, aggregatedColumn.Column));
+
+                alias = string.IsNullOrEmpty(alias) ? "" : $" {ColumnAsKeyword}{alias}";
+
+                string filterCondition = CompileFilterConditions(ctx, aggregatedColumn);
+
+                if (string.IsNullOrEmpty(filterCondition))
+                {
+                    return $"{agg}({col}){alias}";
+                }
+
+                if (SupportsFilterClause)
+                {
+                    return $"{agg}({col}) FILTER (WHERE {filterCondition}){alias}";
+                }
+
+                return $"{agg}(CASE WHEN {filterCondition} THEN {col} END){alias}";
+            }
+
             return Wrap((column as Column).Name);
 
         }
 
+        protected virtual string CompileFilterConditions(SqlResult ctx, AggregatedColumn aggregatedColumn)
+        {
+            if (aggregatedColumn.Filter == null)
+            {
+                return null;
+            }
+
+            var wheres = aggregatedColumn.Filter.GetComponents<AbstractCondition>("where");
+
+            return CompileConditions(ctx, wheres);
+        }
 
         public virtual SqlResult CompileCte(AbstractFrom cte)
         {
@@ -872,9 +912,7 @@ public virtual string Wrap(string value)
 
             if (value.ToLowerInvariant().Contains(" as "))
             {
-                var index = value.ToLowerInvariant().IndexOf(" as ");
-                var before = value.Substring(0, index);
-                var after = value.Substring(index + 4);
+                var (before, after) = SplitAlias(value);
 
                 return Wrap(before) + $" {ColumnAsKeyword}" + WrapValue(after);
             }
@@ -892,6 +930,20 @@ public virtual string Wrap(string value)
             return WrapValue(value);
         }
 
+        public virtual (string, string) SplitAlias(string value)
+        {
+            var index = value.LastIndexOf(" as ", StringComparison.OrdinalIgnoreCase);
+
+            if (index > 0)
+            {
+                var before = value.Substring(0, index);
+                var after = value.Substring(index + 4);
+                return (before, after);
+            }
+
+            return (value, null);
+        }
+
         /// <summary>
         /// Wrap a single string in keyword identifiers.
         /// </summary>

QueryBuilder/Query.Select.cs

@@ -68,5 +68,54 @@ public Query Select(Func<Query, Query> callback, string alias)
         {
             return Select(callback.Invoke(NewChild()), alias);
         }
+
+        public Query SelectAggregate(string aggregate, string column, Query filter = null)
+        {
+            Method = "select";
+
+            AddComponent("select", new AggregatedColumn
+            {
+                Column = new Column { Name = column },
+                Aggregate = aggregate,
+                Filter = filter,
+            });
+
+            return this;
+        }
+
+        public Query SelectAggregate(string aggregate, string column, Func<Query, Query> filter)
+        {
+            if (filter == null)
+            {
+                return SelectAggregate(aggregate, column);
+            }
+
+            return SelectAggregate(aggregate, column, filter.Invoke(NewChild()));
+        }
+
+        public Query SelectSum(string column, Func<Query, Query> filter = null)
+        {
+            return SelectAggregate("sum", column, filter);
+        }
+
+        public Query SelectCount(string column, Func<Query, Query> filter = null)
+        {
+            return SelectAggregate("count", column, filter);
+        }
+
+        public Query SelectAvg(string column, Func<Query, Query> filter = null)
+        {
+            return SelectAggregate("avg", column, filter);
+        }
+
+        public Query SelectMin(string column, Func<Query, Query> filter = null)
+        {
+            return SelectAggregate("min", column, filter);
+        }
+
+        public Query SelectMax(string column, Func<Query, Query> filter = null)
+        {
+            return SelectAggregate("max", column, filter);
+        }
     }
 }