Add ad-hoc default implementation

This uses the UNION ALL syntax for all compilers

Author: freakingawesome

QueryBuilder.Tests/GeneralTests.cs

@@ -401,5 +401,82 @@ public void Where_Nested()
 
             Assert.Equal("SELECT * FROM [table] WHERE ([a] = 1 OR [a] = 2)", c[EngineCodes.SqlServer].ToString());
         }
+
+        [Fact]
+        public void AdHoc_Throws_WhenNoColumnsProvided() =>
+            Assert.Throws<InvalidOperationException>(() =>
+                new Query("rows").With("rows",
+                    new string[0],
+                    new object[][] {
+                        new object[] {},
+                        new object[] {},
+                    }));
+
+        [Fact]
+        public void AdHoc_Throws_WhenNoValueRowsProvided() =>
+            Assert.Throws<InvalidOperationException>(() =>
+                new Query("rows").With("rows",
+                    new[] { "a", "b", "c" },
+                    new object[][] {
+                    }));
+
+        [Fact]
+        public void AdHoc_Throws_WhenColumnsOutnumberFieldValues() =>
+            Assert.Throws<InvalidOperationException>(() =>
+                new Query("rows").With("rows",
+                    new[] { "a", "b", "c", "d" },
+                    new object[][] {
+                        new object[] { 1, 2, 3 },
+                        new object[] { 4, 5, 6 },
+                    }));
+
+        [Fact]
+        public void AdHoc_Throws_WhenFieldValuesOutNumberColumns() =>
+            Assert.Throws<InvalidOperationException>(() =>
+                new Query("rows").With("rows",
+                    new[] { "a", "b" },
+                    new object[][] {
+                        new object[] { 1, 2, 3 },
+                        new object[] { 4, 5, 6 },
+                    }));
+
+        [Fact]
+        public void AdHoc_SingletonRow()
+        {
+            var query = new Query("rows").With("rows",
+                new[] { "a" },
+                new object[][] {
+                    new object[] { 1 },
+                });
+
+            var c = Compilers.Compile(query);
+
+            Assert.Equal("WITH [rows] AS (SELECT 1 AS a)\nSELECT * FROM [rows]", c[EngineCodes.SqlServer].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS a)\nSELECT * FROM \"rows\"", c[EngineCodes.PostgreSql].ToString());
+            Assert.Equal("WITH `rows` AS (SELECT 1 AS a)\nSELECT * FROM `rows`", c[EngineCodes.MySql].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS a)\nSELECT * FROM \"rows\"", c[EngineCodes.Sqlite].ToString());
+            Assert.Equal("WITH \"ROWS\" AS (SELECT 1 AS a FROM RDB$DATABASE)\nSELECT * FROM \"ROWS\"", c[EngineCodes.Firebird].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS a FROM DUAL)\nSELECT * FROM \"rows\"", c[EngineCodes.Oracle].ToString());
+        }
+
+        [Fact]
+        public void AdHoc_TwoRows()
+        {
+            var query = new Query("rows").With("rows",
+                new[] { "a", "b", "c" },
+                new object[][] {
+                    new object[] { 1, 2, 3 },
+                    new object[] { 4, 5, 6 },
+                });
+
+            var c = Compilers.Compile(query);
+
+            Assert.Equal("WITH [rows] AS (SELECT 1 AS a, 2 AS b, 3 AS c UNION ALL SELECT 4 AS a, 5 AS b, 6 AS c)\nSELECT * FROM [rows]", c[EngineCodes.SqlServer].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS a, 2 AS b, 3 AS c UNION ALL SELECT 4 AS a, 5 AS b, 6 AS c)\nSELECT * FROM \"rows\"", c[EngineCodes.PostgreSql].ToString());
+            Assert.Equal("WITH `rows` AS (SELECT 1 AS a, 2 AS b, 3 AS c UNION ALL SELECT 4 AS a, 5 AS b, 6 AS c)\nSELECT * FROM `rows`", c[EngineCodes.MySql].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS a, 2 AS b, 3 AS c UNION ALL SELECT 4 AS a, 5 AS b, 6 AS c)\nSELECT * FROM \"rows\"", c[EngineCodes.Sqlite].ToString());
+            Assert.Equal("WITH \"ROWS\" AS (SELECT 1 AS a, 2 AS b, 3 AS c FROM RDB$DATABASE UNION ALL SELECT 4 AS a, 5 AS b, 6 AS c FROM RDB$DATABASE)\nSELECT * FROM \"ROWS\"", c[EngineCodes.Firebird].ToString());
+            Assert.Equal("WITH \"rows\" AS (SELECT 1 AS a, 2 AS b, 3 AS c FROM DUAL UNION ALL SELECT 4 AS a, 5 AS b, 6 AS c FROM DUAL)\nSELECT * FROM \"rows\"", c[EngineCodes.Oracle].ToString());
+        }
     }
 }

QueryBuilder/Clauses/FromClause.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace SqlKata
 {
@@ -94,4 +95,25 @@ public override AbstractClause Clone()
             };
         }
     }
+
+    /// <summary>
+    /// Represents a FROM clause that is an ad-hoc table built with predefined values.
+    /// </summary>
+    public class AdHocTableFromClause : AbstractFrom
+    {
+        public List<string> Columns { get; set; }
+        public List<object> Values { get; set; }
+
+        public override AbstractClause Clone()
+        {
+            return new AdHocTableFromClause
+            {
+                Engine = Engine,
+                Alias = Alias,
+                Columns = Columns,
+                Values = Values,
+                Component = Component,
+            };
+        }
+    }
 }

QueryBuilder/Compilers/Compiler.cs

@@ -24,6 +24,7 @@ protected Compiler()
 
         public virtual string EngineCode { get; }
 
+        protected virtual string SingleRowDummyTableName { get => null; }
 
         /// <summary>
         /// A list of white-listed operators
@@ -209,6 +210,27 @@ protected virtual SqlResult CompileSelectQuery(Query query)
             return ctx;
         }
 
+        protected virtual SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc)
+        {
+            var ctx = new SqlResult();
+
+            var row = "SELECT " + string.Join(", ", adHoc.Columns.Select(col => $"? AS {WrapIdentifiers(col)}"));
+
+            var fromTable = SingleRowDummyTableName;
+
+            if (fromTable != null)
+            {
+                row += $" FROM {fromTable}";
+            }
+
+            var rows = string.Join(" UNION ALL ", Enumerable.Repeat(row, adHoc.Values.Count / adHoc.Columns.Count));
+
+            ctx.RawSql = rows;
+            ctx.Bindings = adHoc.Values;
+
+            return ctx;
+        }
+
         private SqlResult CompileDeleteQuery(Query query)
         {
             var ctx = new SqlResult
@@ -477,6 +499,13 @@ public virtual SqlResult CompileCte(AbstractFrom cte)
 
                 ctx.RawSql = $"{WrapValue(queryFromClause.Alias)} AS ({subCtx.RawSql})";
             }
+            else if (cte is AdHocTableFromClause adHoc)
+            {
+                var subCtx = CompileAdHocQuery(adHoc);
+                ctx.Bindings.AddRange(subCtx.Bindings);
+
+                ctx.RawSql = $"{WrapValue(adHoc.Alias)} AS ({subCtx.RawSql})";
+            }
 
             return ctx;
         }

QueryBuilder/Compilers/FirebirdCompiler.cs

@@ -11,6 +11,7 @@ public FirebirdCompiler()
         }
 
         public override string EngineCode { get; } = EngineCodes.Firebird;
+        protected override string SingleRowDummyTableName => "RDB$DATABASE";
 
         protected override SqlResult CompileInsertQuery(Query query)
         {

QueryBuilder/Compilers/OracleCompiler.cs

@@ -16,6 +16,7 @@ public OracleCompiler()
 
         public override string EngineCode { get; } = EngineCodes.Oracle;
         public bool UseLegacyPagination { get; set; } = false;
+        protected override string SingleRowDummyTableName => "DUAL";
 
         protected override SqlResult CompileSelectQuery(Query query)
         {

QueryBuilder/Query.cs

@@ -118,6 +118,40 @@ public Query With(string alias, Func<Query, Query> fn)
             return With(alias, fn.Invoke(new Query()));
         }
 
+        /// <summary>
+        /// Constructs an ad-hoc table of the given data as a CTE.
+        /// </summary>
+        public Query With(string alias, IEnumerable<string> columns, IEnumerable<IEnumerable<object>> valuesCollection)
+        {
+            var columnsList = columns?.ToList();
+            var valuesCollectionList = valuesCollection?.ToList();
+
+            if ((columnsList?.Count ?? 0) == 0 || (valuesCollectionList?.Count ?? 0) == 0)
+            {
+                throw new InvalidOperationException("Columns and valuesCollection cannot be null or empty");
+            }
+
+            var clause = new AdHocTableFromClause()
+            {
+                Alias = alias,
+                Columns = columnsList,
+                Values = new List<object>(),
+            };
+
+            foreach (var values in valuesCollectionList)
+            {
+                var valuesList = values.ToList();
+                if (columnsList.Count != valuesList.Count)
+                {
+                    throw new InvalidOperationException("Columns count should be equal to each Values count");
+                }
+
+                clause.Values.AddRange(valuesList);
+            }
+
+            return AddComponent("cte", clause);
+        }
+
         public Query WithRaw(string alias, string sql, params object[] bindings)
         {
             return AddComponent("cte", new RawFromClause