@minnowdb/core 0.4.1 → 0.5.0

package/dist/engine/result-wire.js

@@ -1,6 +1,7 @@
 import { dateMilliseconds } from "../date-value.js";
+import { unknownColumnDomains } from "./query.js";
 export function encodeQueryResult(result) {
-    return encodeRows(result.columns, result.rows);
+    return encodeRows(result.columns, result.rows, result.columnDomains);
 }
 /**
  * Encodes a bare row array (`run()` returns rows without a column list). Every row of one result
@@ -8,13 +9,18 @@ export function encodeQueryResult(result) {
  */
 export function encodeQueryRows(rows) {
     const first = rows[0];
-    return encodeRows(first === undefined ? [] : Object.keys(first), rows);
+    const columns = first === undefined ? [] : Object.keys(first);
+    return encodeRows(columns, rows, unknownColumnDomains(columns));
 }
 export function decodeQueryResult(payload) {
     if (!isWireQueryResult(payload)) {
         throw new TypeError("Expected a columnar query result frame");
     }
     const columns = [...payload.columns];
+    if (payload.values.length !== columns.length || payload.columnDomains.length !== columns.length) {
+        throw new TypeError("Columnar result frame metadata is not aligned");
+    }
+    const columnDomains = structuredClone(payload.columnDomains);
     const rows = [];
     for (let index = 0; index < payload.rowCount; index += 1)
         rows.push({});
@@ -26,17 +32,21 @@ export function decodeQueryResult(payload) {
             throw new TypeError("Columnar result frame is missing a column");
         fillColumn(rows, name, column);
     }
-    return { columns, rows };
+    return { columns, columnDomains, rows };
 }
 export function isWireQueryResult(value) {
     return (typeof value === "object" &&
         value !== null &&
         value.kind === "columnar-result" &&
         Array.isArray(value.columns) &&
+        Array.isArray(value.columnDomains) &&
         Array.isArray(value.values) &&
         typeof value.rowCount === "number");
 }
-function encodeRows(columns, rows) {
+function encodeRows(columns, rows, columnDomains) {
+    if (columnDomains.length !== columns.length) {
+        throw new TypeError("Query result column domains must align with the result columns");
+    }
     const transfer = [];
     const values = columns.map((name) => {
         const column = encodeColumn(name, rows);
@@ -53,7 +63,13 @@ function encodeRows(columns, rows) {
         return column;
     });
     return {
-        payload: { kind: "columnar-result", columns: [...columns], rowCount: rows.length, values },
+        payload: {
+            kind: "columnar-result",
+            columns: [...columns],
+            columnDomains: structuredClone([...columnDomains]),
+            rowCount: rows.length,
+            values,
+        },
         transfer,
     };
 }

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

@@ -17,6 +17,7 @@ export interface WireColumn {
         table: string;
         column: string;
         onDelete: ReferentialAction;
+        enforced?: boolean;
     };
     readonly enumValues?: readonly string[];
     /** Already frozen by planning, so the wire carries a value and never a generator. */
@@ -83,6 +84,12 @@ export type WireMigrationStep = {
     tableName: string;
     columnName: string;
     defaultValue: ColumnDefault | null;
+} | {
+    kind: "alter-foreign-keys";
+    tableName: string;
+    foreignKeys: Extract<MigrationStep, {
+        kind: "alter-foreign-keys";
+    }>["foreignKeys"];
 } | {
     kind: "replace-view";
     view: WireView;

package/dist/engine/schema-wire.js

@@ -96,7 +96,9 @@ function deserializeColumn(wire) {
         ...(wire.sqlDomain === undefined ? {} : { sqlDomain: structuredClone(wire.sqlDomain) }),
         ...(wire.defaultSpec === undefined ? {} : { defaultSpec: wire.defaultSpec }),
         ...(wire.renamedFromName === undefined ? {} : { renamedFromName: wire.renamedFromName }),
-        ...(wire.reference === undefined ? {} : { reference: wire.reference }),
+        ...(wire.reference === undefined
+            ? {}
+            : { reference: { ...wire.reference, enforced: wire.reference.enforced !== false } }),
         ...(wire.enumValues === undefined ? {} : { enumValues: wire.enumValues }),
         ...(wire.backfillValue === undefined ? {} : { backfillValue: wire.backfillValue }),
     });

package/dist/engine/schema.d.ts

@@ -16,6 +16,7 @@ export interface ColumnReferenceSpec {
     readonly table: string;
     readonly column: string;
     readonly onDelete: ReferentialAction;
+    readonly enforced: boolean;
 }
 /** A row condition every write must satisfy (E141-06); `sql` is a boolean expression. */
 export interface TableCheck {
@@ -31,6 +32,8 @@ export interface TableForeignKey<TColumnName extends string = string> {
         readonly columns: readonly string[];
     };
     readonly onDelete?: ReferentialAction;
+    /** False keeps the relationship in the catalog without validating or cascading rows. */
+    readonly enforced?: boolean;
 }
 /**
  * The constraint name `migrate()` gives a declared relation. It matches the name the SQL parser
@@ -91,9 +94,14 @@ export interface ColumnBuilder<TValue extends SchemaValue, TNullable extends boo
      */
     references(this: ColumnBuilder<TValue, TNullable, TUnique, THasDefault, TInput>, table: string, column: string, options?: {
         onDelete?: Exclude<ReferentialAction, "set null">;
+        enforced?: true;
+    } | {
+        enforced: false;
+        onDelete?: never;
     }): ColumnBuilder<TValue, TNullable, TUnique, THasDefault, TInput>;
     references(this: ColumnBuilder<TValue, true, TUnique, THasDefault, TInput>, table: string, column: string, options: {
         onDelete: "set null";
+        enforced?: true;
     }): ColumnBuilder<TValue, TNullable, TUnique, THasDefault, TInput>;
     /** Declares a literal SQL default. Omission or SQL `DEFAULT` invokes it; NULL does not. */
     default(value: TInput): ColumnBuilder<TValue, TNullable, TUnique, true, TInput>;
@@ -152,6 +160,8 @@ export declare const column: {
     json: () => ColumnBuilder<string, false, false, false, string>;
     jsonb: () => ColumnBuilder<string, false, false, false, string>;
     uuid: () => ColumnBuilder<string, false, false, false, string>;
+    /** A zoneless calendar date, represented publicly as canonical `YYYY-MM-DD` text. */
+    date: () => ColumnBuilder<string, false, false, false, string>;
     time: () => ColumnBuilder<string, false, false, false, string>;
     interval: () => ColumnBuilder<string, false, false, false, string>;
     /** JSON array text at the JavaScript boundary, with the SQL element type retained in metadata. */
@@ -234,6 +244,7 @@ export declare function declaredForeignKeys(definition: AnyTable): Array<{
     parentTable: string;
     parentColumns: string[];
     onDelete: ReferentialAction;
+    enforced: boolean;
 }>;
 /**
  * A view declared in the schema: the query it stands for, plus the column shape the author
@@ -366,6 +377,12 @@ export type MigrationStep = {
     columnName: string;
     defaultValue: ColumnDefault | null;
 }
+/** Informational relationships are catalog-only and may change without scanning stored rows. */
+ | {
+    kind: "alter-foreign-keys";
+    tableName: string;
+    foreignKeys: ReturnType<typeof declaredForeignKeys>;
+}
 /**
  * A view is derived and disposable: nothing is stored under it, so replacing its body loses no
  * data and needs none of the proofs a table alteration needs. `replace` covers both creating a

package/dist/engine/schema.js

@@ -71,12 +71,16 @@ function createColumn(type, state = {}) {
         references: (table, referencedColumn, options = {}) => {
             validateSchemaName(table, "Referenced table");
             validateSchemaName(referencedColumn, "Referenced column");
+            if (options.enforced === false && options.onDelete !== undefined) {
+                throw new TypeError("An informational FOREIGN KEY cannot declare ON DELETE behavior");
+            }
             return createColumn(type, {
                 ...state,
                 reference: {
                     table,
                     column: referencedColumn,
                     onDelete: options.onDelete ?? "restrict",
+                    enforced: options.enforced !== false,
                 },
             });
         },
@@ -160,6 +164,8 @@ export const column = {
     json: () => createColumn("string", { sqlDomain: { kind: "json" } }),
     jsonb: () => createColumn("string", { sqlDomain: { kind: "jsonb" } }),
     uuid: () => createColumn("string", { sqlDomain: { kind: "uuid" } }),
+    /** A zoneless calendar date, represented publicly as canonical `YYYY-MM-DD` text. */
+    date: () => createColumn("string", { sqlDomain: { kind: "date" } }),
     time: () => createColumn("string", { sqlDomain: { kind: "time" } }),
     interval: () => createColumn("string", { sqlDomain: { kind: "interval" } }),
     /** JSON array text at the JavaScript boundary, with the SQL element type retained in metadata. */
@@ -301,6 +307,9 @@ export function table(name, columns, options = {}) {
     const foreignKeyNames = new Set();
     for (const key of foreignKeys) {
         validateSchemaName(key.name, "FOREIGN KEY");
+        if (key.enforced === false && key.onDelete !== undefined) {
+            throw new TypeError(`Informational FOREIGN KEY ${key.name} cannot declare ON DELETE behavior`);
+        }
         if (foreignKeyNames.has(key.name)) {
             throw new TypeError(`Duplicate FOREIGN KEY in table ${name}: ${key.name}`);
         }
@@ -431,6 +440,7 @@ export function declaredForeignKeys(definition) {
             parentTable: reference.table,
             parentColumns: [reference.column],
             onDelete: reference.onDelete,
+            enforced: reference.enforced,
         });
     }
     for (const key of definition.foreignKeys) {
@@ -442,6 +452,7 @@ export function declaredForeignKeys(definition) {
             parentTable: key.references.table,
             parentColumns,
             onDelete: key.onDelete ?? "restrict",
+            enforced: key.enforced !== false,
         });
     }
     return keys;
@@ -675,34 +686,58 @@ function backfillsEqual(left, right) {
     return externalLeft === externalRight;
 }
 /**
- * Constraints on an existing table cannot change through a metadata-only step. Attaching a
- * FOREIGN KEY or CHECK to a table that already holds rows would claim something about those rows
+ * Enforced constraints on an existing table cannot change through a metadata-only step. Attaching
+ * a FOREIGN KEY or CHECK to a table that already holds rows would claim something about those rows
  * that nobody has verified, and no validation scan exists; dropping one is refused for the mirror
- * reason, so that a constraint never disappears because a schema file drifted. Both get the same
- * discipline every other unprovable change gets: an explicit error naming the fix.
+ * reason, so that a constraint never disappears because a schema file drifted. Informational
+ * foreign keys are catalog metadata only, so adding, dropping, or remapping one is safe.
  */
-function assertConstraintsUnchanged(record, definition) {
+function planConstraintChanges(record, definition, steps) {
     const describeKey = (key) => `${key.columns.join(",")} -> ${key.parentTable}.` +
         `${key.parentColumns.join(",")} ON DELETE ${key.onDelete}`;
+    const declaredList = declaredForeignKeys(definition);
     const existingKeys = new Map(record.foreignKeys.map((key) => [key.name, key]));
-    const declaredKeys = new Map(declaredForeignKeys(definition).map((key) => [key.name, key]));
+    const declaredKeys = new Map(declaredList.map((key) => [key.name, key]));
+    let informationalChanged = false;
     for (const [name, declared] of declaredKeys) {
         const existing = existingKeys.get(name);
         if (existing === undefined) {
+            if (!declared.enforced) {
+                informationalChanged = true;
+                continue;
+            }
             throw new TypeError(`FOREIGN KEY cannot be added after creation: ${definition.name}.${declared.columns.join(",")}. ` +
                 `Existing rows are not known to satisfy it; recreate the table to add a relation.`);
         }
+        if (existing.enforced !== declared.enforced) {
+            throw new TypeError(`FOREIGN KEY enforcement cannot change: ${definition.name}.${declared.columns.join(",")}`);
+        }
         if (describeKey(existing) !== describeKey(declared)) {
+            if (!declared.enforced) {
+                informationalChanged = true;
+                continue;
+            }
             throw new TypeError(`FOREIGN KEY cannot change: ${definition.name}.${declared.columns.join(",")} is ` +
                 `${describeKey(existing)}, schema says ${describeKey(declared)}`);
         }
     }
     for (const name of existingKeys.keys()) {
         if (!declaredKeys.has(name)) {
+            if (existingKeys.get(name)?.enforced === false) {
+                informationalChanged = true;
+                continue;
+            }
             throw new TypeError(`FOREIGN KEY cannot be dropped: ${definition.name} still has ${name}. ` +
                 `Declare the relation, or recreate the table without it.`);
         }
     }
+    if (informationalChanged) {
+        steps.push({
+            kind: "alter-foreign-keys",
+            tableName: definition.name,
+            foreignKeys: declaredList,
+        });
+    }
     const existingChecks = new Map(record.checks.map((check) => [check.name, check.sql]));
     const declaredChecks = new Map(definition.checks.map((check) => [check.name, check.sql]));
     for (const [name, sql] of declaredChecks) {
@@ -889,7 +924,7 @@ export function planMigration(catalog, definition, options = {}) {
             desiredKeyIds.some((id, index) => id !== existingKeyIds[index])) {
             throw new TypeError(`Primary key order cannot change: ${tableDefinition.name}`);
         }
-        assertConstraintsUnchanged(record, tableDefinition);
+        planConstraintChanges(record, tableDefinition, steps);
     }
     if (options.schemaOwnsDatabase === true) {
         const declaredTables = new Set(definition.tables.map(({ name }) => name));

package/dist/engine/sql-domains.d.ts

@@ -19,6 +19,9 @@ export declare function exactNumericCompare(left: unknown, right: unknown): numb
 export declare function boundedJsonText(value: unknown, canonical: boolean, label?: string): string;
 export declare function jsonDomainValue(value: unknown, binary: boolean): string | null;
 export declare function uuidDomainValue(value: unknown): string | null;
+/** Canonical, zoneless SQL DATE value. No JavaScript time zone participates in validation. */
+export declare function dateDomainValue(value: unknown): string | null;
+export declare function isDateDomainValue(value: unknown): value is string;
 export declare function timeDomainValue(value: unknown): string | null;
 export declare function intervalDomainValue(value: unknown): string | null;
 export declare function arrayDomainValue(values: readonly unknown[]): string;

package/dist/engine/sql-domains.js

@@ -8,6 +8,7 @@ const NUMERIC = `${PREFIX}numeric:`;
 const JSON_VALUE = `${PREFIX}json:`;
 const JSONB_VALUE = `${PREFIX}jsonb:`;
 const UUID_VALUE = `${PREFIX}uuid:`;
+const DATE_VALUE = `${PREFIX}date:`;
 const TIME_VALUE = `${PREFIX}time:`;
 const INTERVAL_VALUE = `${PREFIX}interval:`;
 const ARRAY_VALUE = `${PREFIX}array:`;
@@ -324,6 +325,42 @@ export function uuidDomainValue(value) {
     }
     return UUID_VALUE + source;
 }
+/** Canonical, zoneless SQL DATE value. No JavaScript time zone participates in validation. */
+export function dateDomainValue(value) {
+    if (value === null || value === undefined)
+        return null;
+    let source;
+    if (value instanceof Date) {
+        if (!Number.isFinite(value.getTime()))
+            throw new TypeError("DATE accepts a valid Date value");
+        source = dateIsoString(value).slice(0, 10);
+    }
+    else if (typeof value === "string") {
+        assertBoundedDomainString(value, "DATE value");
+        source = value.startsWith(DATE_VALUE) ? value.slice(DATE_VALUE.length) : value;
+    }
+    else {
+        throw new TypeError("DATE accepts a YYYY-MM-DD string value");
+    }
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(source);
+    const year = Number(match?.[1]);
+    const month = Number(match?.[2]);
+    const day = Number(match?.[3]);
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    if (match === null ||
+        year < 1 ||
+        month < 1 ||
+        month > 12 ||
+        day < 1 ||
+        day > (days[month - 1] ?? 0)) {
+        throw new TypeError(`Invalid DATE value: ${String(value)}`);
+    }
+    return DATE_VALUE + source;
+}
+export function isDateDomainValue(value) {
+    return typeof value === "string" && value.startsWith(DATE_VALUE);
+}
 export function timeDomainValue(value) {
     if (value === null || value === undefined)
         return null;
@@ -464,6 +501,8 @@ export function normalizeSqlDomainValue(domain, value) {
         return jsonDomainValue(value, true);
     if (domain.kind === "uuid")
         return uuidDomainValue(value);
+    if (domain.kind === "date")
+        return dateDomainValue(value);
     if (domain.kind === "time")
         return timeDomainValue(value);
     if (domain.kind === "interval")
@@ -562,7 +601,7 @@ export function externalSqlDomainValue(value) {
         return value;
     if (value.startsWith(TEXT_VALUE))
         return value.slice(TEXT_VALUE.length);
-    for (const prefix of [NUMERIC, JSON_VALUE, JSONB_VALUE, UUID_VALUE, TIME_VALUE]) {
+    for (const prefix of [NUMERIC, JSON_VALUE, JSONB_VALUE, UUID_VALUE, DATE_VALUE, TIME_VALUE]) {
         if (value.startsWith(prefix))
             return value.slice(prefix.length);
     }

package/dist/engine/sql-semantics.js

@@ -1,7 +1,7 @@
 import { dateMilliseconds } from "../date-value.js";
 import { assertWellFormedString } from "../block-format/unicode.js";
 import { MAX_SQL_NESTING_DEPTH, MAX_SQL_PATTERN_CHARACTERS, MAX_SQL_PATTERN_MATCH_STEPS, } from "./cache-limits.js";
-import { collatedDomainCompare, enumDomainCompare, exactNumericCompare, externalSqlDomainValue, externalSqlTextValue, } from "./sql-domains.js";
+import { collatedDomainCompare, enumDomainCompare, exactNumericCompare, externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, } from "./sql-domains.js";
 /**
  * SQL value semantics shared by the row and vector executors.
  *
@@ -31,8 +31,26 @@ export function compareSqlValues(left, right) {
     const exact = exactNumericCompare(left, right);
     if (exact !== undefined)
         return exact;
-    const a = left instanceof Date ? dateMilliseconds(left) : left;
-    const b = right instanceof Date ? dateMilliseconds(right) : right;
+    const temporal = (value) => {
+        if (value instanceof Date)
+            return dateMilliseconds(value);
+        if (!isDateDomainValue(value))
+            return undefined;
+        const external = externalSqlDomainValue(value);
+        return typeof external === "string" ? Date.parse(`${external}T00:00:00.000Z`) : undefined;
+    };
+    const temporalLeft = temporal(left);
+    const temporalRight = temporal(right);
+    if (temporalLeft !== undefined || temporalRight !== undefined) {
+        const comparableLeft = temporalLeft ?? (typeof left === "number" ? left : undefined);
+        const comparableRight = temporalRight ?? (typeof right === "number" ? right : undefined);
+        if (comparableLeft === undefined || comparableRight === undefined) {
+            throw new TypeError("Values must have comparable SQL types");
+        }
+        return comparableLeft - comparableRight;
+    }
+    const a = left;
+    const b = right;
     if (a === b)
         return 0;
     if (a === null || a === undefined)

package/dist/engine/vector.js

@@ -1,13 +1,14 @@
 import { dateMilliseconds } from "../date-value.js";
 import { MAX_TEMP_RUN_BATCH_BYTES, MAX_TEMP_RUN_PAGE_BYTES, MAX_TEMP_RUN_PAGES_PER_BATCH, } from "../storage/types.js";
-import { cachedListMembership, childExpressions, distinctFromComparison, nullOrder, isScalarFunctionName, likeMatches, orderOutputName, parseQuantified, quantifiedComparison, scalarFunctionValue, } from "./query.js";
+import { cachedListMembership, childExpressions, distinctFromComparison, nullOrder, isScalarFunctionName, likeMatches, orderOutputName, parseQuantified, quantifiedComparison, scalarFunctionValue, unknownColumnDomains, } from "./query.js";
 import { jsonValueOf } from "./sql-json.js";
 import { bm25DocumentScore, cachedQueryTerms, FtsStatsAccumulator, fullTermsMask, renderDocumentValue, termFrequencies, termsMask, tokenize, } from "./fts.js";
 import { ByteGroupIndex } from "./group-index.js";
 import { ByteJoinIndex } from "./join-index.js";
+import { UnknownTableError } from "./errors.js";
 import { QueryMemoryBudgetError, QueryMemoryContext, } from "./memory.js";
-import { compareSqlStrings, compileSimilarPattern, defineSqlResultProperty, } from "./sql-semantics.js";
-import { exactNumericBinary, exactNumericCompare, collatedDomainCompare, enumDomainCompare, externalSqlDomainValue, isExactNumeric, protectedSqlTextValue, } from "./sql-domains.js";
+import { compareSqlValues, compileSimilarPattern, defineSqlResultProperty, } from "./sql-semantics.js";
+import { exactNumericBinary, externalSqlDomainValue, isDateDomainValue, isExactNumeric, protectedSqlTextValue, } from "./sql-domains.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
 const DEFAULT_BATCH_ROWS = 2_048;
 /** Above this, locating each IN member separately costs more than scanning between them. */
@@ -559,7 +560,7 @@ function bindPlan(plan, tables, memory, ftsStats) {
     const sourceTables = sources.map((source) => {
         const table = tables.get(source.table);
         if (table === undefined)
-            throw new TypeError(`Unknown table: ${source.table}`);
+            throw new UnknownTableError(source.table);
         return table;
     });
     const sourceAliases = sources.map((source) => source.alias);
@@ -1304,7 +1305,11 @@ async function executeBoundPlanBatches(plan, memory, options, consume) {
             }
             if (rows.length > 0) {
                 emitted += rows.length;
-                await consume({ columns: [...columns], rows });
+                await consume({
+                    columns: [...columns],
+                    columnDomains: unknownColumnDomains(columns),
+                    rows,
+                });
             }
         }
         finally {
@@ -1374,7 +1379,7 @@ async function executeBoundPlanWithSortSpill(plan, memory, options) {
             start += length;
         }
         if (runs.length === 0)
-            return { columns, rows: [] };
+            return { columns, columnDomains: unknownColumnDomains(columns), rows: [] };
         let active = runs;
         while (active.length > 1) {
             const merged = [];
@@ -1408,7 +1413,7 @@ async function executeBoundPlanWithSortSpill(plan, memory, options) {
         }
         if (offset > 0)
             rows.splice(0, Math.min(offset, rows.length));
-        return { columns, rows };
+        return { columns, columnDomains: unknownColumnDomains(columns), rows };
     }
     finally {
         await store.removeOwner(ownerId);
@@ -1563,7 +1568,7 @@ async function executeBoundPlanWithHashSpill(plan, memory, options) {
             }
         }
         if (runs.length === 0)
-            return { columns, rows: [] };
+            return { columns, columnDomains: unknownColumnDomains(columns), rows: [] };
         const finalRun = await mergeAllSpillRuns(store, ownerId, runs, columns, plan.orderBy, pageRows, () => `merge-${String(runSequence++)}`, memory);
         const spillOffset = plan.offset ?? 0;
         const result = await readFinalSpillRun(store, ownerId, finalRun, columns, plan.limit === undefined ? undefined : plan.limit + spillOffset);
@@ -1609,7 +1614,7 @@ async function readFinalSpillRun(store, ownerId, run, columns, requestedLimit) {
             rows.push(row);
         }
     }
-    return { columns: [...columns], rows };
+    return { columns: [...columns], columnDomains: unknownColumnDomains(columns), rows };
 }
 const hashScratch = new DataView(new ArrayBuffer(8));
 /**
@@ -1909,7 +1914,7 @@ function finishResult(plan, inputRows, memory) {
         rows.length = Math.min(plan.limit, rows.length);
     }
     const columns = plan.wildcard ? wildcardColumnNames(plan) : plan.select.map((item) => item.alias);
-    return { columns, rows };
+    return { columns, columnDomains: unknownColumnDomains(columns), rows };
 }
 /** Source indexes a bound expression reads, for pre-join predicate placement. */
 function prefilterSources(expression, into) {
@@ -3883,6 +3888,8 @@ function projectBatchRow(plan, batch, row) {
         const rowIndex = batch.rowsBySource[source]?.[row] ?? -1;
         const prefix = multiple ? `${plan.sourceAliases[source] ?? ""}.` : "";
         for (const [name, vector] of table.columns) {
+            if (name.startsWith("\0"))
+                continue;
             const outputName = multiple ? prefix + name : name;
             const value = vectorValue(vector, rowIndex);
             if (outputName === "__proto__")
@@ -3895,7 +3902,9 @@ function projectBatchRow(plan, batch, row) {
 }
 function wildcardColumnNames(plan) {
     const multiple = plan.sourceTables.length > 1;
-    return plan.sourceTables.flatMap((table, source) => [...table.columns.keys()].map((name) => multiple ? `${plan.sourceAliases[source] ?? ""}.${name}` : name));
+    return plan.sourceTables.flatMap((table, source) => [...table.columns.keys()]
+        .filter((name) => !name.startsWith("\0"))
+        .map((name) => (multiple ? `${plan.sourceAliases[source] ?? ""}.${name}` : name)));
 }
 /** Detects `stringColumn = 'literal'` (or !=) so batches compare dictionary codes per row. */
 function detectDictionaryEquality(predicate) {
@@ -4506,7 +4515,13 @@ function comparisonValue(operator, leftValue, rightValue) {
     return comparison <= 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;
 }
 function groupKey(value) {
     const comparableValue = comparable(value);
@@ -4547,35 +4562,7 @@ function stableSortRows(rows, orderBy) {
     }
 }
 function compareValues(left, right) {
-    const collated = collatedDomainCompare(left, right);
-    if (collated !== undefined)
-        return collated;
-    const enumOrder = enumDomainCompare(left, right);
-    if (enumOrder !== undefined)
-        return enumOrder;
-    const exact = exactNumericCompare(left, right);
-    if (exact !== undefined)
-        return exact;
-    const a = left instanceof Date ? dateMilliseconds(left) : left;
-    const b = right instanceof Date ? dateMilliseconds(right) : right;
-    if (a === b)
-        return 0;
-    if (a === null || a === undefined)
-        return -1;
-    if (b === null || b === undefined)
-        return 1;
-    if (typeof a === "number" && typeof b === "number") {
-        if (Number.isNaN(a))
-            return Number.isNaN(b) ? 0 : 1;
-        if (Number.isNaN(b))
-            return -1;
-        return a - b;
-    }
-    if (typeof a === "string" && typeof b === "string")
-        return compareSqlStrings(a, b);
-    if (typeof a === "boolean" && typeof b === "boolean")
-        return Number(a) - Number(b);
-    throw new TypeError("Values must have comparable SQL types");
+    return compareSqlValues(left, right);
 }
 function numeric(value) {
     if (typeof value !== "number")

package/dist/storage/indexeddb.js

@@ -1,4 +1,4 @@
-import { CompactionJobConflictError, assertCompactionOutputProvenance, compactionOutputSegmentIds, CompactionBacklogError, createManifest, createGarbageCollectionJobRecord, storeNames, advanceGarbageCollectionJobRecord as advanceGarbageCollectionJobRecordUnchecked, BlockReadBatchTooLargeError, activePostingStorageColumnIds, assertTempRunPageBatchLimits, assertStorageBulkReadItems, assertTransactionArtifactBatchLimits, assertTransactionArtifactJournalLimits, boundedMaintenanceBatchItems, canonicalManifestChangedTableIds, catalogRecordRetainedBytes, manifestRecordRetainedReservationBytes, segmentRecordRetainedBytes, collectFtsPostings, ftsPostingQueryMatches, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, MAX_FTS_CANDIDATE_ROW_IDS, MAX_ACTIVE_UNIQUE_KEY_BUILDS, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL, MAX_UNIQUE_KEY_BUILD_CHUNK_BYTES, MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK, MAX_UNIQUE_KEY_BUILD_TTL_MS, MAX_FTS_BASE_CHUNKS, MAX_FTS_DELTA_CHUNKS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_TOKENS_PER_DOCUMENT, MAX_FTS_ORDERED_READ_BYTES, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MANIFEST_RECORDS, MAX_MANIFEST_RETAINED_BYTES, MAX_BLOCK_READ_BATCH_BYTES, MAX_STORAGE_ID_CHARACTERS, MAX_LEASE_TTL_MS, MAX_ACTIVE_LEASES, MAX_ACTIVE_TRANSACTIONS, MAX_GLOBAL_STAGED_ARTIFACT_BYTES, MAX_GLOBAL_STAGED_BLOCKS, MAX_GLOBAL_STAGED_SEGMENTS, MAX_RETIRED_HISTORY_BYTES, MAX_PINNED_MANIFEST_VERSION_LAG, MAX_PINNED_RETIRED_BLOCKS, MAX_PINNED_RETIRED_BYTES, MAX_TERMINAL_TRANSACTION_RECORDS, MAX_ACTIVE_COMPACTION_JOBS, MAX_ACTIVE_GARBAGE_COLLECTION_JOBS, MAX_TERMINAL_COMPACTION_JOB_RECORDS, MAX_COMPLETED_GARBAGE_COLLECTION_JOB_RECORDS, MAX_CATALOG_RECORDS, MAX_CATALOG_RETAINED_BYTES, MAX_SEGMENT_RECORDS, MAX_SEGMENT_RETAINED_BYTES, MAX_ACTIVE_FTS_BASE_BUILDS, MAX_ACTIVE_SECONDARY_INDEX_BUILDS, MAX_ACCELERATOR_BUILD_STAGED_BYTES_TOTAL, MAX_ACCELERATOR_BUILD_STAGED_ENTRIES_TOTAL, MAX_POSTING_BUILD_TTL_MS, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, MAX_SNAPSHOT_METADATA_FRAME_BYTES, SNAPSHOT_FRAME_KINDS, MAX_LEVEL_ZERO_SEGMENTS, MAX_AUTO_INCREMENT_EXCLUSIVE_END, MAX_ROW_ID, MAX_ROW_ID_EXCLUSIVE_END, StorageCorruptionError, StorageFormatVersionError, IndexedDbSchemaUpgradeBlockedError, StorageResourceLimitError, SnapshotManifestMissingError, SnapshotImportConflictError, PostingBuildConflictError, TableInUseError, TableRecordConflictError, TempOwnerConflictError, MAX_TEMP_OWNER_TTL_MS, MAX_ACTIVE_TEMP_OWNERS, MAX_TEMP_RUNS_PER_OWNER, MAX_TEMP_PAGES_PER_OWNER, MAX_TEMP_RUNS_TOTAL, MAX_TEMP_PAGES_TOTAL, MAX_TEMP_BYTES_PER_OWNER, MAX_TEMP_BYTES_TOTAL, TransactionRecordConflictError, UniqueKeyConflictError, UniqueKeyBuildConflictError, UniqueIndexCoverageError, SchemaConflictError, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord as updateCompactionJobRecordUnchecked, updateGarbageCollectionPlanningRecord, updateTransactionRecord as updateTransactionRecordUnchecked, validateColumnDefault, validateCatalogName, validateCanonicalManifestChangedTableIds, validateEnumValues, validateFtsOrderedReadLimits, validateFtsPostingQueries, validateStorageId, validateStorageDatabaseName, validateTableColumns, validateSecondaryIndexes, validateTableRecordBounds, secondaryIndexColumnIds, secondaryIndexWriteContractChanged, secondaryUniqueKeyNamespace, transactionCommitDeltaRetainedBytes, uniqueKeyBuildChunkRetainedBytes, WriteConflictError, } from "./types.js";
+import { CompactionJobConflictError, assertCompactionOutputProvenance, compactionOutputSegmentIds, CompactionBacklogError, createManifest, createGarbageCollectionJobRecord, storeNames, advanceGarbageCollectionJobRecord as advanceGarbageCollectionJobRecordUnchecked, BlockReadBatchTooLargeError, activePostingStorageColumnIds, assertTempRunPageBatchLimits, assertStorageBulkReadItems, assertTransactionArtifactBatchLimits, assertTransactionArtifactJournalLimits, boundedMaintenanceBatchItems, canonicalManifestChangedTableIds, catalogRecordRetainedBytes, manifestRecordRetainedReservationBytes, segmentRecordRetainedBytes, collectFtsPostings, ftsPostingQueryMatches, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, MAX_FTS_CANDIDATE_ROW_IDS, MAX_ACTIVE_UNIQUE_KEY_BUILDS, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL, MAX_UNIQUE_KEY_BUILD_CHUNK_BYTES, MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK, MAX_UNIQUE_KEY_BUILD_TTL_MS, MAX_FTS_BASE_CHUNKS, MAX_FTS_DELTA_CHUNKS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_TOKENS_PER_DOCUMENT, MAX_FTS_ORDERED_READ_BYTES, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MANIFEST_RECORDS, MAX_MANIFEST_RETAINED_BYTES, MAX_BLOCK_READ_BATCH_BYTES, MAX_STORAGE_ID_CHARACTERS, MAX_LEASE_TTL_MS, MAX_ACTIVE_LEASES, MAX_ACTIVE_TRANSACTIONS, MAX_GLOBAL_STAGED_ARTIFACT_BYTES, MAX_GLOBAL_STAGED_BLOCKS, MAX_GLOBAL_STAGED_SEGMENTS, MAX_RETIRED_HISTORY_BYTES, MAX_PINNED_MANIFEST_VERSION_LAG, MAX_PINNED_RETIRED_BLOCKS, MAX_PINNED_RETIRED_BYTES, MAX_TERMINAL_TRANSACTION_RECORDS, MAX_ACTIVE_COMPACTION_JOBS, MAX_ACTIVE_GARBAGE_COLLECTION_JOBS, MAX_TERMINAL_COMPACTION_JOB_RECORDS, MAX_COMPLETED_GARBAGE_COLLECTION_JOB_RECORDS, MAX_CATALOG_RECORDS, MAX_CATALOG_RETAINED_BYTES, MAX_SEGMENT_RECORDS, MAX_SEGMENT_RETAINED_BYTES, MAX_ACTIVE_FTS_BASE_BUILDS, MAX_ACTIVE_SECONDARY_INDEX_BUILDS, MAX_ACCELERATOR_BUILD_STAGED_BYTES_TOTAL, MAX_ACCELERATOR_BUILD_STAGED_ENTRIES_TOTAL, MAX_POSTING_BUILD_TTL_MS, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, MAX_SNAPSHOT_METADATA_FRAME_BYTES, SNAPSHOT_FRAME_KINDS, MAX_LEVEL_ZERO_SEGMENTS, MAX_AUTO_INCREMENT_EXCLUSIVE_END, MAX_ROW_ID, MAX_ROW_ID_EXCLUSIVE_END, StorageCorruptionError, StorageFormatVersionError, IndexedDbSchemaUpgradeBlockedError, StorageResourceLimitError, SnapshotManifestMissingError, SnapshotImportConflictError, PostingBuildConflictError, validateTableForeignKey, TableInUseError, TableRecordConflictError, TempOwnerConflictError, MAX_TEMP_OWNER_TTL_MS, MAX_ACTIVE_TEMP_OWNERS, MAX_TEMP_RUNS_PER_OWNER, MAX_TEMP_PAGES_PER_OWNER, MAX_TEMP_RUNS_TOTAL, MAX_TEMP_PAGES_TOTAL, MAX_TEMP_BYTES_PER_OWNER, MAX_TEMP_BYTES_TOTAL, TransactionRecordConflictError, UniqueKeyConflictError, UniqueKeyBuildConflictError, UniqueIndexCoverageError, SchemaConflictError, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord as updateCompactionJobRecordUnchecked, updateGarbageCollectionPlanningRecord, updateTransactionRecord as updateTransactionRecordUnchecked, validateColumnDefault, validateCatalogName, validateCanonicalManifestChangedTableIds, validateEnumValues, validateFtsOrderedReadLimits, validateFtsPostingQueries, validateStorageId, validateStorageDatabaseName, validateTableColumns, validateSecondaryIndexes, validateTableRecordBounds, secondaryIndexColumnIds, secondaryIndexWriteContractChanged, secondaryUniqueKeyNamespace, transactionCommitDeltaRetainedBytes, uniqueKeyBuildChunkRetainedBytes, WriteConflictError, } from "./types.js";
 import { crc32, verifyStoredBlock } from "../block-format/index.js";
 import { dateIsoString } from "../date-value.js";
 import { decodeSnapshotMetadataItems, encodeSnapshotMetadataPage, extendSnapshotFrameStreamChecksum, prepareSnapshotFrameStreamHeader, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity, } from "./snapshot-stream.js";
@@ -9678,7 +9678,7 @@ function asTableRecord(value, location = "catalog/table") {
         }
         for (const [index, foreignKey] of rawForeignKeys.entries()) {
             if (isRecord(foreignKey)) {
-                assertKnownFields(foreignKey, ["name", "columns", "parentTable", "parentColumns", "onDelete"], `${location}/foreignKeys/${String(index)}`);
+                assertKnownFields(foreignKey, ["name", "columns", "parentTable", "parentColumns", "onDelete", "enforced"], `${location}/foreignKeys/${String(index)}`);
             }
             if (!isRecord(foreignKey) ||
                 !isCatalogName(foreignKey.name) ||
@@ -9690,6 +9690,7 @@ function asTableRecord(value, location = "catalog/table") {
                 foreignKey.parentColumns.length === 0 ||
                 foreignKey.columns.length !== foreignKey.parentColumns.length ||
                 !["restrict", "cascade", "set null"].includes(String(foreignKey.onDelete)) ||
+                (foreignKey.enforced !== undefined && typeof foreignKey.enforced !== "boolean") ||
                 foreignKey.parentColumns.some((columnName) => !isCatalogName(columnName))) {
                 throw corruption(`${location}/foreignKeys/${String(index)}`, "foreign-key metadata is invalid");
             }
@@ -11965,16 +11966,7 @@ async function assertTableForeignKeysInTransaction(catalog, record) {
         if (parent === undefined) {
             throw new TypeError(`FOREIGN KEY ${key.name} references a missing table: ${key.parentTable}`);
         }
-        const addressIds = parent.primaryKeyColumnIds?.length
-            ? parent.primaryKeyColumnIds
-            : parent.uniqueKeyColumnId === undefined
-                ? []
-                : [parent.uniqueKeyColumnId];
-        const addressNames = addressIds.map((id) => parent.columns.find((column) => column.id === id)?.name ?? "");
-        if (addressNames.length !== key.parentColumns.length ||
-            addressNames.some((name, index) => name !== key.parentColumns[index])) {
-            throw new TypeError(`FOREIGN KEY ${key.name} must reference the parent primary or unique key`);
-        }
+        validateTableForeignKey(record, key, parent);
     }
 }
 async function updateRetiredHistoryLedger(store, deltaBytes) {