This addresses the request in #152 by adding a With(...) variation that takes a list of column names and a list of list of values to create a CTE representation of that data. That CTE can then be used in subsequent SELECT statements to, for example, query efficiently against a number of composite keys.

Here is an example for creating a CTE with two rows of parameterized data:

var query = new Query("rows").With("rows",
    new[] { "a", "b", "c" },
    new object[][] {
        new object[] { 1, 2, 3 },
        new object[] { 4, 5, 6 },
    });

This conceptually results in a CTE whose contents are:

The default SQL implementation uses a number of SELECT statements joined by UNION ALL:

Postgres Output:

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"
)
SELECT *
FROM "rows"

SQL Server output uses its own VALUES (...), (...) syntax:

WITH [rows] AS (
    SELECT [a], [b], [c]
    FROM (
        VALUES
            (1, 2, 3),
            (4, 5, 6)
    ) AS tbl ([a], [b], [c])
)
SELECT *
FROM [rows]

Note: The initial issue #152 showed that Postgres has its own syntax for ad-hoc tables in a CTE, but I did not implement that specific flavor because it would involve more substantial changes to the actual WITH portion of the CTE, e.g. WITH cte (a, b, c) AS (...). Postgres instead uses the UNION ALL flavor