@minnowdb/core 0.4.1 → 0.6.0

package/dist/engine/query.js

@@ -6,11 +6,22 @@ import { cachedQueryTerms, ftsBm25Row, FtsStatsAccumulator, ftsMatchTruth, rende
 import { QueryMemoryContext } from "./memory.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
 import { stringArgument } from "./sql-semantics.js";
-import { jsonAtPath, jsonConstructor, jsonIsValid, jsonValueOf, parseJsonPath, } from "./sql-json.js";
+import { jsonAtPath, jsonConstructor, jsonIsValid, parseJsonPath } from "./sql-json.js";
 import { optimizePlan } from "./optimizer.js";
 import { compareSqlValues as compareValues, compileLikePattern, compileSimilarPattern, encodeSqlEqualityValue, roundSqlNumber, } from "./sql-semantics.js";
-import { arrayDomainValue, boundedJsonText, collatedDomainValue, exactNumericBinary, exactNumericValue, externalSqlDomainValue, intervalDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue, } from "./sql-domains.js";
+import { arrayDomainValue, boundedJsonText, collatedDomainValue, dateDomainValue, exactNumericBinary, exactNumericValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, preservedJsonDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue, } from "./sql-domains.js";
 import { columnarTableFromRows, prepareVectorQuery, } from "./vector.js";
+/** Domain metadata for an execution path that has no catalog-backed type information. */
+export function unknownColumnDomains(columns) {
+    return columns.map(() => null);
+}
+function withColumnDomains(result, domains) {
+    const columnDomains = domains ?? unknownColumnDomains(result.columns);
+    if (columnDomains.length !== result.columns.length) {
+        throw new TypeError(`Query result column domains must align with the result columns (${String(columnDomains.length)} domains for ${String(result.columns.length)} columns)`);
+    }
+    return { ...result, columnDomains: [...columnDomains] };
+}
 export const scalarFunctionNames = new Set([
     "ROUND",
     "COALESCE",
@@ -138,6 +149,8 @@ function castValue(value, target) {
         return jsonDomainValue(value, true);
     if (target === "uuid")
         return uuidDomainValue(value);
+    if (target === "date")
+        return dateDomainValue(value);
     if (target === "time")
         return timeDomainValue(value);
     if (target === "interval")
@@ -199,8 +212,9 @@ function castValue(value, target) {
     if (target === "datetime") {
         if (value instanceof Date)
             return value;
-        if (typeof value === "string" || typeof value === "number") {
-            const parsed = new Date(value);
+        const external = externalSqlDomainValue(value);
+        if (typeof external === "string" || typeof external === "number") {
+            const parsed = new Date(external);
             if (Number.isFinite(dateMilliseconds(parsed)))
                 return parsed;
             throw new TypeError(`Cannot cast this value to a datetime: ${String(value)}`);
@@ -250,7 +264,7 @@ export function scalarFunctionValue(name, values) {
     }
     if (name === "JSON_ARRAY" || name === "JSON_OBJECT") {
         // These build from every argument, so a NULL first one is data, not an early exit.
-        return jsonConstructor(name, values);
+        return preservedJsonDomainValue(jsonConstructor(name, values));
     }
     if (name === "ARRAY")
         return arrayDomainValue(values);
@@ -380,7 +394,7 @@ export function scalarFunctionValue(name, values) {
             if (!found.found || found.value === undefined)
                 return null;
             // JSON_QUERY returns JSON text, so a selected string keeps its quotes.
-            return JSON.stringify(found.value);
+            return preservedJsonDomainValue(JSON.stringify(found.value));
         }
         case "LPAD":
         case "RPAD": {
@@ -624,10 +638,18 @@ export function intervalLiteral(text) {
 export function dateAddValue(value, months, milliseconds) {
     if (value === null || value === undefined)
         return null;
-    if (!(value instanceof Date))
-        throw new TypeError("Date arithmetic requires a datetime value");
+    const calendarDate = isDateDomainValue(value);
+    const external = externalSqlDomainValue(value);
+    const input = value instanceof Date
+        ? value
+        : calendarDate && typeof external === "string"
+            ? new Date(`${external}T00:00:00.000Z`)
+            : undefined;
+    if (input === undefined)
+        throw new TypeError("Date arithmetic requires a date or datetime value");
     const monthCount = Number(months ?? 0);
-    const shifted = copyDate(value);
+    const millisecondCount = Number(milliseconds ?? 0);
+    const shifted = copyDate(input);
     if (monthCount !== 0) {
         const day = dateUtcDate(shifted);
         setDateUtcDate(shifted, 1);
@@ -635,7 +657,10 @@ export function dateAddValue(value, months, milliseconds) {
         const lastDay = new Date(Date.UTC(dateUtcFullYear(shifted), dateUtcMonth(shifted) + 1, 0));
         setDateUtcDate(shifted, Math.min(day, dateUtcDate(lastDay)));
     }
-    return new Date(dateMilliseconds(shifted) + Number(milliseconds ?? 0));
+    const result = new Date(dateMilliseconds(shifted) + millisecondCount);
+    return calendarDate && millisecondCount % 86_400_000 === 0
+        ? dateDomainValue(dateIsoString(result).slice(0, 10))
+        : result;
 }
 export function dateTruncValue(unit, value) {
     if (typeof unit !== "string" || !dateTruncUnits.has(unit.toLowerCase())) {
@@ -643,12 +668,18 @@ export function dateTruncValue(unit, value) {
     }
     if (value === null || value === undefined)
         return null;
-    if (!(value instanceof Date))
-        throw new TypeError("DATE_TRUNC requires a datetime value");
+    const external = externalSqlDomainValue(value);
+    const input = value instanceof Date
+        ? value
+        : isDateDomainValue(value) && typeof external === "string"
+            ? new Date(`${external}T00:00:00.000Z`)
+            : undefined;
+    if (input === undefined)
+        throw new TypeError("DATE_TRUNC requires a date or datetime value");
     const normalized = unit.toLowerCase();
-    const year = dateUtcFullYear(value);
-    const month = dateUtcMonth(value);
-    const day = dateUtcDate(value);
+    const year = dateUtcFullYear(input);
+    const month = dateUtcMonth(input);
+    const day = dateUtcDate(input);
     switch (normalized) {
         case "year":
             return new Date(Date.UTC(year, 0, 1));
@@ -664,11 +695,11 @@ export function dateTruncValue(unit, value) {
         case "day":
             return new Date(Date.UTC(year, month, day));
         case "hour":
-            return new Date(Date.UTC(year, month, day, dateUtcHours(value)));
+            return new Date(Date.UTC(year, month, day, dateUtcHours(input)));
         case "minute":
-            return new Date(Date.UTC(year, month, day, dateUtcHours(value), dateUtcMinutes(value)));
+            return new Date(Date.UTC(year, month, day, dateUtcHours(input), dateUtcMinutes(input)));
         default:
-            return new Date(Date.UTC(year, month, day, dateUtcHours(value), dateUtcMinutes(value), dateUtcSeconds(value)));
+            return new Date(Date.UTC(year, month, day, dateUtcHours(input), dateUtcMinutes(input), dateUtcSeconds(input)));
     }
 }
 /** The output column type of one window: rankings and most aggregates count, MIN/MAX carry. */
@@ -737,7 +768,6 @@ const createTableTypeNames = new Map([
     ["TIMESTAMP", "datetime"],
     ["TIMESTAMPTZ", "datetime"],
     ["DATETIME", "datetime"],
-    ["DATE", "datetime"],
 ]);
 const clauseKeywords = new Set([
     "WHERE",
@@ -1735,7 +1765,10 @@ export function bindStatementParameters(statement, params) {
  */
 export function inferBlockSchema(plan, schemas) {
     const sources = [plan.base, ...plan.joins];
-    const multipleSources = sources.length > 1;
+    const multipleSources = sources.filter((source) => {
+        const schema = schemas.get(source.table);
+        return schema === undefined || schema.some((column) => !column.name.startsWith("\0"));
+    }).length > 1;
     const wildcardSchema = (source) => (schemas.get(source.table) ?? [])
         .filter((column) => !column.name.startsWith("\0"))
         .map((column) => ({
@@ -1797,7 +1830,11 @@ export function inferBlockSchema(plan, schemas) {
                 ...(scale === undefined ? {} : { scale }),
             };
         }
-        if (target === "json" || target === "jsonb" || target === "uuid" || target === "time") {
+        if (target === "json" ||
+            target === "jsonb" ||
+            target === "uuid" ||
+            target === "date" ||
+            target === "time") {
             return { kind: target };
         }
         if (target === "interval")
@@ -1825,12 +1862,32 @@ export function inferBlockSchema(plan, schemas) {
         }
         if (expression.kind !== "call")
             return undefined;
+        if (expression.name === "CURRENT_DATE")
+            return { kind: "date" };
         if (expression.name === "CAST") {
             const target = expression.arguments[1];
             return target?.kind === "literal" && typeof target.value === "string"
                 ? castDomain(target.value)
                 : undefined;
         }
+        if (expression.name === "JSON_ARRAYAGG" ||
+            expression.name === "JSON_QUERY" ||
+            expression.name === "JSON_OBJECT" ||
+            expression.name === "JSON_ARRAY") {
+            return { kind: "json" };
+        }
+        if (expression.name === "GEN_RANDOM_UUID")
+            return { kind: "uuid" };
+        if (expression.name === "DATE_ADD") {
+            const input = inferDomain(expression.arguments[0] ?? { kind: "literal", value: null });
+            const milliseconds = expression.arguments[2];
+            return input?.kind === "date" &&
+                milliseconds?.kind === "literal" &&
+                typeof milliseconds.value === "number" &&
+                milliseconds.value % 86_400_000 === 0
+                ? input
+                : undefined;
+        }
         if (expression.name === "SUM" ||
             expression.name === "AVG" ||
             expression.name === "MIN" ||
@@ -1963,9 +2020,13 @@ export function inferBlockSchema(plan, schemas) {
             return "boolean";
         if (expression.name === "DATE_TRUNC")
             return "datetime";
-        if (expression.name === "CURRENT_DATE" || expression.name === "CURRENT_TIMESTAMP") {
-            return "datetime";
+        if (expression.name === "DATE_ADD") {
+            return inferDomain(expression)?.kind === "date" ? "string" : "datetime";
         }
+        if (expression.name === "CURRENT_DATE")
+            return "string";
+        if (expression.name === "CURRENT_TIMESTAMP")
+            return "datetime";
         // LOCALTIME is the statement clock's canonical 'HH:MM:SS' text; explicit TIME values use
         // the same public representation while carrying a logical domain internally.
         if (expression.name === "LOCALTIME")
@@ -2062,6 +2123,22 @@ export function inferBlockSchema(plan, schemas) {
         ];
     });
 }
+/** Best-effort logical domains for a public result without making execution a new typecheck. */
+export function inferResultColumnDomains(plan, schemas) {
+    try {
+        return inferBlockSchema(plan, schemas).map(({ sqlDomain }) => sqlDomain ?? null);
+    }
+    catch {
+        return plan.select.flatMap((item) => {
+            try {
+                return inferBlockSchema({ ...plan, select: [item] }, schemas).map(({ sqlDomain }) => sqlDomain ?? null);
+            }
+            catch {
+                return [null];
+            }
+        });
+    }
+}
 /** Whether a final result can contain one of the engine's tagged string-domain values. */
 export function queryResultNeedsExternalization(plan, schemas) {
     // This is only a result-boundary optimization flag, not a second typecheck. In particular,
@@ -2080,7 +2157,7 @@ export function queryResultNeedsExternalization(plan, schemas) {
                 if (target?.kind === "literal" &&
                     typeof target.value === "string" &&
                     (target.value.startsWith("numeric:") ||
-                        ["json", "jsonb", "uuid", "time", "interval"].includes(target.value))) {
+                        ["json", "jsonb", "uuid", "date", "time", "interval"].includes(target.value))) {
                     return true;
                 }
             }
@@ -2278,15 +2355,17 @@ export function createPreparedQuery(plan, tables, options = {}) {
     }
 }
 /** Internal columnar entry point used after MinnowDatabase materializes a stable snapshot. */
-export function createPreparedColumnarQuery(plan, tables, memory = new QueryMemoryContext(), options = {}) {
+export function createPreparedColumnarQuery(plan, tables, memory = new QueryMemoryContext(), preparedOptions = {}) {
     plan = resolveStatementDatetimes(plan);
     const ties = withTiesPlan(plan);
     if (ties.plan !== plan) {
-        return trimPreparedResults(createPreparedColumnarQuery(ties.plan, tables, memory, options), ties.trim);
+        return trimPreparedResults(createPreparedColumnarQuery(ties.plan, tables, memory, preparedOptions), ties.trim);
     }
     const columnarColumns = (tableName) => {
         const table = tables.get(tableName);
-        return table === undefined ? undefined : [...table.columns.keys()];
+        return table === undefined
+            ? undefined
+            : [...table.columns.keys()].filter((name) => !name.startsWith("\0"));
     };
     plan = expandSourceColumnAliases(plan, columnarColumns);
     plan = expandNaturalJoins(plan, columnarColumns);
@@ -2298,14 +2377,32 @@ export function createPreparedColumnarQuery(plan, tables, memory = new QueryMemo
     try {
         prepared = prepareVectorQuery(plan, tables, {
             memoryContext: memory,
-            ...(options.ftsStats === undefined ? {} : { ftsStats: options.ftsStats }),
+            ...(preparedOptions.ftsStats === undefined ? {} : { ftsStats: preparedOptions.ftsStats }),
         });
     }
     catch (error) {
         memory.close();
         throw error;
     }
-    const outputNeedsExternalization = options.outputNeedsExternalization;
+    const outputNeedsExternalization = preparedOptions.outputNeedsExternalization;
+    let outputColumnDomains = preparedOptions.outputColumnDomains;
+    if (outputColumnDomains === undefined) {
+        try {
+            const schemas = new Map([...tables].map(([name, table]) => [
+                name,
+                [...table.columns].map(([columnName, vector]) => ({
+                    name: columnName,
+                    type: vector.kind,
+                })),
+            ]));
+            outputColumnDomains = inferResultColumnDomains(plan, schemas);
+        }
+        catch {
+            // This low-level schema-less entry point may not have enough source information. Known
+            // expression domains (including JSON constructors) are still inferred whenever it does.
+            outputColumnDomains = undefined;
+        }
+    }
     return {
         sql: plan.sql,
         tables: [plan.base.table, ...plan.joins.map((join) => join.table)],
@@ -2315,17 +2412,17 @@ export function createPreparedColumnarQuery(plan, tables, memory = new QueryMemo
         execute() {
             if (closed || prepared === undefined)
                 throw new Error("Prepared query is closed");
-            return markExternalizationState(prepared.execute(), outputNeedsExternalization);
+            return markExternalizationState(withColumnDomains(prepared.execute(), outputColumnDomains), outputNeedsExternalization);
         },
         async executeAsync(options) {
             if (closed || prepared === undefined)
                 throw new Error("Prepared query is closed");
-            return markExternalizationState(await prepared.executeAsync(options), outputNeedsExternalization);
+            return markExternalizationState(withColumnDomains(await prepared.executeAsync(options), outputColumnDomains), outputNeedsExternalization);
         },
         executeBatches(options, consume) {
             if (closed || prepared === undefined)
                 throw new Error("Prepared query is closed");
-            return prepared.executeBatches(options, (batch) => consume(markExternalizationState(batch, outputNeedsExternalization)));
+            return prepared.executeBatches(options, (batch) => consume(markExternalizationState(withColumnDomains(batch, outputColumnDomains), outputNeedsExternalization)));
         },
         close() {
             if (closed)
@@ -2386,6 +2483,7 @@ function createPreparedRowQuery(plan, tables, memory) {
                 options.signal?.throwIfAborted();
                 await consume({
                     columns: [...result.columns],
+                    columnDomains: [...result.columnDomains],
                     rows: result.rows.slice(start, start + options.batchRows),
                 });
             }
@@ -2485,7 +2583,7 @@ export function combineUnionResults(results, ops) {
         const membership = new Set(next.map(encode));
         combined = dedupe(combined).filter((row) => op === "intersect" ? membership.has(encode(row)) : !membership.has(encode(row)));
     }
-    return { columns: [...columns], rows: combined };
+    return { columns: [...columns], columnDomains: [...first.columnDomains], rows: combined };
 }
 function encodeRowKey(columns) {
     return (row) => JSON.stringify(columns.map((name) => {
@@ -2687,9 +2785,17 @@ export function resolveStatementDatetimes(plan, now = new Date()) {
         return plan;
     const iso = dateIsoString(now);
     const values = new Map([
-        ["CURRENT_DATE", new Date(`${iso.slice(0, 10)}T00:00:00.000Z`)],
-        ["CURRENT_TIMESTAMP", copyDate(now)],
-        ["LOCALTIME", iso.slice(11, 19)],
+        [
+            "CURRENT_DATE",
+            {
+                kind: "literal",
+                value: dateDomainValue(iso.slice(0, 10)),
+                internalSqlValue: true,
+                sqlDomain: { kind: "date" },
+            },
+        ],
+        ["CURRENT_TIMESTAMP", { kind: "literal", value: copyDate(now) }],
+        ["LOCALTIME", { kind: "literal", value: iso.slice(11, 19) }],
     ]);
     const resolved = clonePlanTree(plan);
     const substitute = (expression) => {
@@ -2698,7 +2804,12 @@ export function resolveStatementDatetimes(plan, now = new Date()) {
             return expression;
         }
         if (expression.kind === "call" && values.has(expression.name)) {
-            return { kind: "literal", value: values.get(expression.name) ?? null };
+            const value = values.get(expression.name);
+            return value === undefined
+                ? { kind: "literal", value: null }
+                : value.kind === "literal"
+                    ? { ...value }
+                    : value;
         }
         if (expression.kind === "window") {
             // A window's own clauses are positions mapChildExpressions cannot rebuild; the plan is
@@ -3273,6 +3384,7 @@ export function applyWindowFunctions(result, windows, options = {}) {
     }
     return {
         columns: [...result.columns, ...windows.map((window) => window.alias)],
+        columnDomains: [...result.columnDomains, ...windows.map(() => null)],
         rows,
     };
 }
@@ -3405,10 +3517,10 @@ function executeRowQueryInternal(plan, tables, memory) {
         // Only a wildcard select needs the source shapes: every other select resolves against its
         // own output aliases.
         const orderSources = plan.select[0]?.expression.kind === "wildcard"
-            ? [plan.base, ...plan.joins].map((source) => ({
-                alias: source.alias,
-                columns: rowTableColumnNames(tables.get(source.table) ?? []),
-            }))
+            ? [plan.base, ...plan.joins].flatMap((source) => {
+                const columns = rowTableColumnNames(tables.get(source.table) ?? []).filter((name) => !name.startsWith("\0"));
+                return columns.length === 0 ? [] : [{ alias: source.alias, columns }];
+            })
             : [];
         const sortColumns = plan.orderBy.map(({ expression, direction, nulls }) => ({
             outputName: orderOutputName(expression, plan.select, orderSources),
@@ -3435,7 +3547,24 @@ function executeRowQueryInternal(plan, tables, memory) {
     const columns = plan.select[0]?.expression.kind === "wildcard"
         ? Object.keys(rows[0] ?? {})
         : plan.select.map((item) => item.alias);
-    return ties.trim({ columns, rows });
+    const schemas = new Map([...tables].map(([name, tableRows]) => {
+        const names = [...new Set(tableRows.flatMap((row) => Object.keys(row)))];
+        return [
+            name,
+            names.map((columnName) => {
+                const value = tableRows.map((row) => row[columnName]).find((entry) => entry !== null);
+                const type = value instanceof Date
+                    ? "datetime"
+                    : typeof value === "boolean"
+                        ? "boolean"
+                        : typeof value === "number"
+                            ? "number"
+                            : "string";
+                return { name: columnName, type };
+            }),
+        ];
+    }));
+    return ties.trim({ columns, columnDomains: inferResultColumnDomains(plan, schemas), rows });
 }
 /** Matches the vector executor's deliberately inexpensive modeled result-payload accounting. */
 function rowQueryPayloadBytes(row) {
@@ -3574,11 +3703,10 @@ function isSqlJoinKey(value) {
 }
 function project(select, context, group) {
     if (select[0]?.expression.kind === "wildcard") {
-        const aliases = Object.keys(context);
-        return Object.fromEntries(aliases.flatMap((alias) => Object.entries(context[alias] ?? {}).map(([name, value]) => [
-            aliases.length === 1 ? name : `${alias}.${name}`,
-            value,
-        ])));
+        const aliases = Object.keys(context).filter((alias) => Object.keys(context[alias] ?? {}).some((name) => !name.startsWith("\0")));
+        return Object.fromEntries(aliases.flatMap((alias) => Object.entries(context[alias] ?? {})
+            .filter(([name]) => !name.startsWith("\0"))
+            .map(([name, value]) => [aliases.length === 1 ? name : `${alias}.${name}`, value])));
     }
     return Object.fromEntries(select.map((item) => [item.alias, asQueryValue(evaluate(item.expression, context, group))]));
 }
@@ -3749,7 +3877,7 @@ function evaluate(expression, context, group) {
                 if (expression.name === "JSON_ARRAYAGG") {
                     return values.length === 0
                         ? null
-                        : JSON.stringify(values.map((value) => jsonValueOf(value ?? null)));
+                        : preservedJsonDomainValue(jsonConstructor("JSON_ARRAY", values));
                 }
                 if (expression.name === "MIN")
                     return values.reduce((best, value) => (best === undefined || compareValues(value, best) < 0 ? value : best), undefined);
@@ -4084,7 +4212,7 @@ export function evaluateBooleanExpression(expression, evaluateValue) {
         return value;
     throw new TypeError("Boolean conditions require boolean operands");
 }
-function comparisonHolds(operator, leftValue, rightValue) {
+export function comparisonHolds(operator, leftValue, rightValue) {
     if (operator === "IS NULL")
         return leftValue === null || leftValue === undefined;
     if (operator === "IS NOT NULL")
@@ -4247,7 +4375,13 @@ export function expressionAliases(expression) {
     return new Set(expressionColumns(expression).flatMap((reference) => reference.includes(".") ? [reference.split(".")[0] ?? ""] : []));
 }
 function comparable(value) {
-    return value instanceof Date ? dateMilliseconds(value) : value;
+    if (value instanceof Date)
+        return dateMilliseconds(value);
+    if (isDateDomainValue(value)) {
+        const external = externalSqlDomainValue(value);
+        return typeof external === "string" ? Date.parse(`${external}T00:00:00.000Z`) : value;
+    }
+    return value;
 }
 /**
  * Resolves NULL placement for one order term. An omitted placement follows PostgreSQL: NULLS LAST
@@ -4333,7 +4467,9 @@ export function externalizeQueryResult(result) {
         }
         rows[rowIndex] = output;
     }
-    const externalized = changed ? { columns: [...result.columns], rows } : result;
+    const externalized = changed
+        ? { columns: [...result.columns], columnDomains: [...result.columnDomains], rows }
+        : result;
     // Public TEXT is allowed to begin with the private tag prefix, so externalization is not
     // byte-idempotent. Record the boundary crossing: a wrapper such as executeQuery(query()) must
     // not interpret the now-public bytes a second time.
@@ -4727,6 +4863,7 @@ class Parser {
             const columnType = this.#columnType();
             let nullable = true;
             let defaultValue;
+            let generatedValue;
             for (;;) {
                 if (this.#isKeyword("DEFAULT")) {
                     // PostgreSQL-compatible variable-free scalar expression, retained in the catalog.
@@ -4734,6 +4871,10 @@ class Parser {
                     defaultValue = this.#columnDefault();
                     continue;
                 }
+                if (this.#isKeyword("GENERATED")) {
+                    generatedValue = this.#generatedColumn();
+                    continue;
+                }
                 if (this.#isKeyword("CHECK")) {
                     checks.push(this.#checkConstraint(`${table}_${name}_check`));
                     continue;
@@ -4779,6 +4920,7 @@ class Parser {
                 ...columnType,
                 ...(nullable ? { nullable: true } : {}),
                 ...(defaultValue === undefined ? {} : { defaultValue }),
+                ...(generatedValue === undefined ? {} : { generatedValue }),
             });
             if (!this.#punctuation(","))
                 break;
@@ -4804,6 +4946,23 @@ class Parser {
                 }
             }
         }
+        for (const column of columns) {
+            if (column.defaultValue !== undefined && column.generatedValue !== undefined) {
+                throw new TypeError(`Generated column ${column.name} cannot also have a DEFAULT`);
+            }
+            if (column.generatedValue === undefined)
+                continue;
+            for (const reference of expressionColumnNames(compileCheckExpression(column.generatedValue.sql, `generated ${table}.${column.name}`))) {
+                const referencedName = reference.split(".").at(-1) ?? reference;
+                const referenced = columns.find(({ name }) => name === referencedName);
+                if (referenced === undefined) {
+                    throw new TypeError(`Generated column ${column.name} refers to a column this table has no: ${referencedName}`);
+                }
+                if (referenced === column || referenced.generatedValue !== undefined) {
+                    throw new TypeError(`Generated column ${column.name} cannot reference a generated column: ${referencedName}`);
+                }
+            }
+        }
         // Preserve the released single-UNIQUE row-addressing behavior when no PRIMARY KEY was
         // declared. Additional UNIQUE constraints remain independently enforced secondary keys.
         const promotedUnique = primaryKey === undefined && uniqueConstraints[0]?.columns.length === 1
@@ -4926,6 +5085,23 @@ class Parser {
             throw new TypeError("DEFAULT requires an expression");
         return columnDefaultFor(expression, sql);
     }
+    /** GENERATED [ALWAYS] AS (expression) STORED. */
+    #generatedColumn() {
+        this.#keyword("GENERATED");
+        if (this.#isKeyword("ALWAYS"))
+            this.#keyword("ALWAYS");
+        this.#keyword("AS");
+        const open = this.#peek();
+        this.#expectPunctuation("(");
+        const expression = this.#expression();
+        const close = this.#peek();
+        this.#expectPunctuation(")");
+        this.#keyword("STORED");
+        if (hasAggregate(expression) || containsWindow(expression) || containsParameter(expression)) {
+            throw new TypeError("Generated columns take an immutable row expression");
+        }
+        return { kind: "stored", sql: this.text.slice(open.start + 1, close.start).trim() };
+    }
     /** DROP VIEW [IF EXISTS] name (F031-16). */
     parseDropView() {
         this.#keyword("DROP");
@@ -5060,7 +5236,7 @@ class Parser {
             }
             return `numeric:${precision === undefined ? "" : String(precision)}:${scale === undefined ? "" : String(scale)}`;
         }
-        if (["JSON", "JSONB", "UUID", "TIME", "INTERVAL"].includes(word)) {
+        if (["JSON", "JSONB", "UUID", "DATE", "TIME", "INTERVAL"].includes(word)) {
             return word.toLowerCase();
         }
         if (word === "DOUBLE") {
@@ -5099,7 +5275,7 @@ class Parser {
                 },
             };
         }
-        if (["JSON", "JSONB", "UUID", "TIME", "INTERVAL"].includes(word)) {
+        if (["JSON", "JSONB", "UUID", "DATE", "TIME", "INTERVAL"].includes(word)) {
             return { type: "string", sqlDomain: { kind: word.toLowerCase() } };
         }
         if (word === "DOUBLE") {
@@ -6954,10 +7130,12 @@ class Parser {
             };
         }
         if (upper === "DATE" && this.#peek().kind === "string") {
-            const date = new Date(`${this.#take("string").text}T00:00:00.000Z`);
-            if (!Number.isFinite(dateMilliseconds(date)))
-                throw new TypeError("Invalid DATE literal");
-            return { kind: "literal", value: date };
+            return {
+                kind: "literal",
+                value: dateDomainValue(this.#take("string").text),
+                internalSqlValue: true,
+                sqlDomain: { kind: "date" },
+            };
         }
         if ((upper === "TIMESTAMP" || upper === "DATETIME") && this.#peek().kind === "string") {
             return { kind: "literal", value: timestampLiteral(this.#take("string").text) };
@@ -7601,8 +7779,8 @@ class Parser {
 /**
  * GROUPING SETS desugar: one grouped block per set, combined with UNION ALL. A grouped column
  * absent from a member's set projects as NULLIF(expr, expr) — always NULL, but carrying the
- * expression's type through schema inference. The GROUPING() marker function is deliberately
- * unsupported, so rollup NULLs and data NULLs are indistinguishable; the docs call this out.
+ * expression's type through schema inference. GROUPING() becomes one constant bitmask per member
+ * block, distinguishing columns aggregated away by the set from data NULLs.
  */
 function desugarGroupingSets(parts, nextSequence) {
     const { groupingSets, limit, offset, limitParameter, offsetParameter, ...blockParts } = parts;
@@ -7872,16 +8050,17 @@ export function assembleSelectBlock(parts, nextSequence) {
 export function expandDistinctWildcard(plan, columnsOf) {
     if (plan.distinctWildcard !== true)
         return plan;
-    const sources = [plan.base, ...plan.joins];
-    const multiple = sources.length > 1;
-    const select = sources.flatMap((source) => {
-        const columns = columnsOf(source.table);
-        if (columns === undefined || columns.length === 0) {
+    const shaped = [plan.base, ...plan.joins].map((source) => ({
+        source,
+        columns: sourceWildcardColumns(source, columnsOf),
+    }));
+    const visible = shaped.filter(({ columns }) => (columns?.length ?? 0) > 0);
+    const multiple = visible.length > 1;
+    const select = visible.flatMap(({ source, columns }) => {
+        if (columns === undefined) {
             throw new TypeError(`SELECT DISTINCT * requires known columns for: ${source.table}`);
         }
-        return columns
-            .filter((name) => !name.startsWith("\0"))
-            .map((name) => {
+        return columns.map((name) => {
             const output = multiple ? `${source.alias}.${name}` : name;
             return { expression: { kind: "column", reference: output }, alias: output };
         });
@@ -7977,10 +8156,12 @@ export function withTiesPlan(plan) {
         return { plan, trim: (result) => result };
     if (plan.orderBy.length === 0)
         throw new TypeError("FETCH ... WITH TIES requires ORDER BY");
-    const sources = [plan.base, ...plan.joins].map((source) => ({
-        alias: source.alias,
-        columns: source.derived?.select.map((item) => item.alias) ?? [],
-    }));
+    const sources = [plan.base, ...plan.joins].flatMap((source) => {
+        const columns = source.derived?.select
+            .map((item) => item.alias)
+            .filter((name) => !name.startsWith("\0"));
+        return columns?.length === 0 ? [] : [{ alias: source.alias, columns: columns ?? [] }];
+    });
     // orderOutputName throws when a sort key has no output column, which is the same failure the
     // executors report; nothing here has to re-check it.
     const keys = plan.orderBy.map(({ expression }) => orderOutputName(expression, plan.select, sources));
@@ -8160,7 +8341,8 @@ export function expandQualifiedWildcards(plan, columnsOf) {
     const expandBlock = (block) => {
         forEachNestedBlock(block, expandBlock);
         const sources = [block.base, ...block.joins];
-        const multiple = sources.length > 1;
+        const multiple = sources.filter((source) => (sourceWildcardColumns(source, columnsOf)?.length ?? 0) > 0)
+            .length > 1;
         block.select = block.select.flatMap((item) => {
             if (item.expression.kind !== "wildcard" || item.expression.table === undefined)
                 return [item];
@@ -8250,9 +8432,9 @@ function assembleOrderByExpressionBlock(parts, nextSequence) {
             throw new TypeError("Window functions are only allowed in the select list");
         }
         // A bare literal is almost always a SQL ordinal (ORDER BY 2); sorting by a constant would
-        // silently do nothing, so reject it the way the engine always has.
+        // silently do nothing. Valid ordinals have already resolved; a remaining literal is invalid.
         if (order.expression.kind === "literal") {
-            throw new TypeError("ORDER BY ordinals are not supported; name the column or alias");
+            throw new TypeError("ORDER BY position is outside the select list");
         }
     }
     const selectSignatures = new Map(parts.select.map((item) => [JSON.stringify(item.expression), item.alias]));
@@ -8338,6 +8520,10 @@ export function transparentProjectionSource(plan) {
 export function projectResultColumns(result, aliases) {
     return copyQueryResultExternalization(result, {
         columns: [...aliases],
+        columnDomains: aliases.map((alias) => {
+            const position = result.columns.indexOf(alias);
+            return position < 0 ? null : (result.columnDomains[position] ?? null);
+        }),
         rows: result.rows.map((row) => {
             const projected = {};
             for (const alias of aliases)