@minnowdb/core 0.4.1 → 0.5.0

package/dist/engine/errors.d.ts

@@ -3,6 +3,12 @@
  * them (name, fields, instanceof) without bundling the executor.
  */
 type ErrorValue = boolean | number | string | Date;
+/** A database operation named a table that is not present in the current catalog. */
+export declare class UnknownTableError extends TypeError {
+    readonly tableName: string;
+    readonly name = "UnknownTableError";
+    constructor(tableName: string);
+}
 export declare class UniqueConstraintError extends Error {
     readonly tableName: string;
     readonly columnName: string;

package/dist/engine/errors.js

@@ -5,6 +5,15 @@
 function formatValue(value) {
     return value instanceof Date ? dateIsoString(value) : String(value);
 }
+/** A database operation named a table that is not present in the current catalog. */
+export class UnknownTableError extends TypeError {
+    tableName;
+    name = "UnknownTableError";
+    constructor(tableName) {
+        super(`Unknown table: ${tableName}`);
+        this.tableName = tableName;
+    }
+}
 export class UniqueConstraintError extends Error {
     tableName;
     columnName;

package/dist/engine/live.js

@@ -37,6 +37,8 @@ function digestResult(result) {
     };
     for (const column of result.columns)
         mixString(column);
+    for (const domain of result.columnDomains)
+        mixString(JSON.stringify(domain));
     for (const row of result.rows) {
         for (const column of result.columns) {
             const value = row[column] ?? null;
@@ -76,6 +78,9 @@ function sameResult(left, right) {
     for (let index = 0; index < left.columns.length; index += 1) {
         if (left.columns[index] !== right.columns[index])
             return false;
+        if (JSON.stringify(left.columnDomains[index]) !== JSON.stringify(right.columnDomains[index])) {
+            return false;
+        }
     }
     for (let rowIndex = 0; rowIndex < left.rows.length; rowIndex += 1) {
         const leftRow = left.rows[rowIndex];
@@ -109,7 +114,11 @@ function cloneRow(row, columns) {
 }
 function cloneResult(result) {
     const columns = [...result.columns];
-    return { columns, rows: result.rows.map((row) => cloneRow(row, columns)) };
+    return {
+        columns,
+        columnDomains: structuredClone(result.columnDomains),
+        rows: result.rows.map((row) => cloneRow(row, columns)),
+    };
 }
 /** Type-tagged, length-delimited structural identity. Unlike JSON, it preserves Date vs string,
  * -0, non-finite numbers, and undefined fields, so deduplication cannot merge distinct plans. */

package/dist/engine/optimizer.js

@@ -906,10 +906,15 @@ function foldExpression(expression) {
                         : targetWord === "json" ||
                             targetWord === "jsonb" ||
                             targetWord === "uuid" ||
+                            targetWord === "date" ||
                             targetWord === "time" ||
                             targetWord === "interval"
                             ? { kind: targetWord }
-                            : undefined;
+                            : expression.name === "JSON_QUERY" ||
+                                expression.name === "JSON_OBJECT" ||
+                                expression.name === "JSON_ARRAY"
+                                ? { kind: "json" }
+                                : undefined;
                     return {
                         kind: "literal",
                         value: folded,

package/dist/engine/query-cache.js

@@ -38,6 +38,7 @@ export function copyQueryResult(result) {
     const columns = result.columns;
     const copy = {
         columns: [...columns],
+        columnDomains: structuredClone(result.columnDomains),
         rows: result.rows.map((row) => {
             const copy = { ...row };
             for (const name of columns) {

package/dist/engine/query.d.ts

@@ -7,8 +7,12 @@ export type QueryValue = boolean | number | string | Date | null;
 export type QueryRow = Record<string, QueryValue>;
 export interface QueryResult {
     columns: string[];
+    /** Logical SQL domain for each output column, positionally aligned with `columns`. */
+    columnDomains: Array<SqlDomain | null>;
     rows: QueryRow[];
 }
+/** Domain metadata for an execution path that has no catalog-backed type information. */
+export declare function unknownColumnDomains(columns: readonly string[]): null[];
 export interface PreparedQuery {
     readonly sql: string;
     readonly tables: string[];
@@ -72,7 +76,7 @@ export declare function intervalLiteral(text: string): {
  * does not exist in the target month clamps to that month's last day, which is what both SQLite
  * and PostgreSQL do with 31 January plus a month.
  */
-export declare function dateAddValue(value: unknown, months: unknown, milliseconds: unknown): Date | null;
+export declare function dateAddValue(value: unknown, months: unknown, milliseconds: unknown): Date | string | null;
 export declare function dateTruncValue(unit: unknown, value: unknown): Date | null;
 export type Expression = {
     kind: "literal";
@@ -387,6 +391,8 @@ export interface ForeignKeyDefinition {
     parentColumn?: string;
     parentColumns?: string[];
     onDelete: "restrict" | "cascade" | "set null";
+    /** False is reserved for schema/catalog declarations; SQL-created keys are enforced. */
+    enforced?: boolean;
 }
 export interface UniqueConstraintDefinition {
     name: string;
@@ -687,15 +693,19 @@ export interface SqlColumnSchema {
  * derived table always has concrete column types even when its result is empty.
  */
 export declare function inferBlockSchema(plan: CompiledQuery, schemas: ReadonlyMap<string, readonly SqlColumnSchema[]>): SqlColumnSchema[];
+/** Best-effort logical domains for a public result without making execution a new typecheck. */
+export declare function inferResultColumnDomains(plan: CompiledQuery, schemas: ReadonlyMap<string, readonly SqlColumnSchema[]>): Array<SqlDomain | null>;
 /** Whether a final result can contain one of the engine's tagged string-domain values. */
 export declare function queryResultNeedsExternalization(plan: CompiledQuery, schemas: ReadonlyMap<string, readonly SqlColumnSchema[]>): boolean;
 export declare function referencedColumns(plan: CompiledQuery, schemas: ReadonlyMap<string, readonly string[]>): Map<string, string[]>;
 export declare function createPreparedQuery(plan: CompiledQuery, tables: ReadonlyMap<string, DatabaseRow[]>, options?: QueryExecutionOptions): PreparedQuery;
 /** Internal columnar entry point used after MinnowDatabase materializes a stable snapshot. */
-export declare function createPreparedColumnarQuery(plan: CompiledQuery, tables: ReadonlyMap<string, ColumnarTable>, memory?: QueryMemoryContext, options?: {
+export declare function createPreparedColumnarQuery(plan: CompiledQuery, tables: ReadonlyMap<string, ColumnarTable>, memory?: QueryMemoryContext, preparedOptions?: {
     ftsStats?: ReadonlyMap<string, FtsStats>;
     /** False only when catalog-backed schema inference proves every output is already public. */
     outputNeedsExternalization?: boolean;
+    /** Catalog-inferred logical domains, positionally aligned with the visible output. */
+    outputColumnDomains?: ReadonlyArray<SqlDomain | null>;
 }): PreparedQuery;
 export declare function executeQuery(plan: CompiledQuery, tables: ReadonlyMap<string, DatabaseRow[]>, options?: QueryExecutionOptions): QueryResult;
 /**
@@ -843,6 +853,7 @@ export declare function distinctFromComparison(left: unknown, right: unknown): b
  * Leaf values come from the executor-specific callback so both executors share these semantics.
  */
 export declare function evaluateBooleanExpression(expression: Expression, evaluateValue: (expression: Expression) => unknown): boolean | null;
+export declare function comparisonHolds(operator: PredicateOperator, leftValue: unknown, rightValue: unknown): boolean;
 export declare function hasAggregate(expression: Expression): boolean;
 /** The column references inside one expression; a subquery contributes none (its own scope). */
 export declare function expressionColumnNames(expression: Expression): string[];

package/dist/engine/query.js

@@ -9,8 +9,19 @@ import { stringArgument } from "./sql-semantics.js";
 import { jsonAtPath, jsonConstructor, jsonIsValid, jsonValueOf, 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, 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)}`);
@@ -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",
@@ -1797,7 +1827,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 +1859,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 +2017,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 +2120,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 +2154,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 +2352,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 +2374,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 +2409,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 +2480,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 +2580,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 +2782,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 +2801,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 +3381,7 @@ export function applyWindowFunctions(result, windows, options = {}) {
     }
     return {
         columns: [...result.columns, ...windows.map((window) => window.alias)],
+        columnDomains: [...result.columnDomains, ...windows.map(() => null)],
         rows,
     };
 }
@@ -3435,7 +3544,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) {
@@ -4084,7 +4210,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 +4373,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 +4465,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.
@@ -5060,7 +5194,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 +5233,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 +7088,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) };
@@ -8338,6 +8474,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)

package/dist/engine/result-wire.d.ts

@@ -1,3 +1,4 @@
+import type { SqlDomain } from "../storage/types.js";
 import type { QueryResult, QueryRow, QueryValue } from "./query.js";
 /**
  * The shape a query result takes on the worker channel. A result is rows of objects at the
@@ -49,6 +50,7 @@ export type WireResultColumn = {
 export interface WireQueryResult {
     readonly kind: "columnar-result";
     readonly columns: string[];
+    readonly columnDomains: Array<SqlDomain | null>;
     readonly rowCount: number;
     readonly values: WireResultColumn[];
 }