@minnowdb/core 0.2.1 → 0.3.0

package/dist/engine/query.js

@@ -3,9 +3,10 @@ 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, parseJsonPath } from "./sql-json.js";
+import { jsonAtPath, jsonConstructor, jsonIsValid, jsonValueOf, parseJsonPath, } from "./sql-json.js";
 import { optimizePlan } from "./optimizer.js";
-import { compareSqlValues as compareValues, compileLikePattern, encodeSqlEqualityValue, roundSqlNumber, } from "./sql-semantics.js";
+import { compareSqlValues as compareValues, compileLikePattern, compileSimilarPattern, encodeSqlEqualityValue, roundSqlNumber, } from "./sql-semantics.js";
+import { arrayDomainValue, collatedDomainValue, exactNumericBinary, exactNumericValue, externalSqlDomainValue, intervalDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue, } from "./sql-domains.js";
 import { columnarTableFromRows, prepareVectorQuery, } from "./vector.js";
 export const scalarFunctionNames = new Set([
     "ROUND",
@@ -46,6 +47,18 @@ export const scalarFunctionNames = new Set([
     "JSON_OBJECT",
     "JSON_ARRAY",
     "IS_JSON",
+    "ARRAY",
+    "MINNOW_TUPLE_KEY",
+    "MINNOW_COLLATE",
+    "NEXTVAL",
+    "CURRVAL",
+    "RANDOM",
+    "GEN_RANDOM_UUID",
+]);
+/** Functions whose answer can change without any catalog or input-row change. */
+export const volatileScalarFunctionNames = new Set([
+    "RANDOM",
+    "GEN_RANDOM_UUID",
 ]);
 /**
  * The niladic datetime functions (F051-06/07/08). Their value is the statement's own clock
@@ -103,7 +116,7 @@ function trimEnds(name, value, characters, side) {
             end -= unit.length;
         }
     }
-    return text.slice(start, end);
+    return protectedSqlTextValue(text.slice(start, end));
 }
 /**
  * CAST conversions between the four logical types, matching the strict common ground of
@@ -112,15 +125,30 @@ function trimEnds(name, value, characters, side) {
  * number cast to datetime reads as milliseconds since the epoch.
  */
 function castValue(value, target) {
+    if (target.startsWith("numeric")) {
+        const [, precision, scale] = target.split(":");
+        return exactNumericValue(value, precision === undefined || precision === "" ? undefined : Number(precision), scale === undefined || scale === "" ? undefined : Number(scale));
+    }
+    if (target === "json")
+        return jsonDomainValue(value, false);
+    if (target === "jsonb")
+        return jsonDomainValue(value, true);
+    if (target === "uuid")
+        return uuidDomainValue(value);
+    if (target === "time")
+        return timeDomainValue(value);
+    if (target === "interval")
+        return intervalDomainValue(value);
     if (target === "string") {
-        if (typeof value === "string")
-            return value;
+        const external = externalSqlDomainValue(value);
+        if (typeof external === "string")
+            return protectedSqlTextValue(external);
         if (typeof value === "number")
-            return String(value);
+            return protectedSqlTextValue(String(value));
         if (typeof value === "boolean")
-            return value ? "true" : "false";
+            return protectedSqlTextValue(value ? "true" : "false");
         if (value instanceof Date)
-            return value.toISOString();
+            return protectedSqlTextValue(value.toISOString());
     }
     if (target === "number" || target === "number-integer") {
         let parsed;
@@ -136,8 +164,15 @@ function castValue(value, target) {
             }
             parsed = candidate;
         }
-        if (parsed !== undefined)
-            return target === "number-integer" ? Math.trunc(parsed) : parsed;
+        if (parsed !== undefined) {
+            if (target !== "number-integer")
+                return parsed;
+            const integer = Math.trunc(parsed);
+            if (!Number.isSafeInteger(integer)) {
+                throw new RangeError(`Integer cast is outside the exact safe range: ${String(value)}`);
+            }
+            return integer;
+        }
     }
     if (target === "boolean") {
         if (typeof value === "boolean")
@@ -189,6 +224,10 @@ export function scalarFunctionValue(name, values) {
         // means a call survived that pass, which would silently give one statement two clocks.
         throw new TypeError(`${name} must be resolved before execution`);
     }
+    if (name === "RANDOM")
+        return Math.random();
+    if (name === "GEN_RANDOM_UUID")
+        return globalThis.crypto.randomUUID();
     if (name === "DATE_TRUNC")
         return dateTruncValue(values[0], values[1]);
     if (name === "DATE_ADD")
@@ -210,6 +249,21 @@ export function scalarFunctionValue(name, values) {
         // These build from every argument, so a NULL first one is data, not an early exit.
         return jsonConstructor(name, values);
     }
+    if (name === "ARRAY")
+        return arrayDomainValue(values);
+    if (name === "MINNOW_COLLATE")
+        return collatedDomainValue(values[0], values[1]);
+    if (name === "NEXTVAL" || name === "CURRVAL") {
+        throw new TypeError(`${name} must be resolved by the database catalog`);
+    }
+    if (name === "MINNOW_TUPLE_KEY") {
+        // SQL equality cannot match a tuple containing NULL. JSON stringification of the tagged
+        // scalar equality encodings is prefix-free and keeps strings, numbers, booleans, and
+        // datetimes distinct, so the ordinary single-key hash join can safely carry a composite.
+        if (values.some((value) => value === null || value === undefined))
+            return null;
+        return JSON.stringify(values.map(encodeSqlEqualityValue));
+    }
     const first = values[0];
     if (first === null || first === undefined)
         return null;
@@ -256,9 +310,7 @@ export function scalarFunctionValue(name, values) {
             const search = stringArgument("REPLACE", values[1]);
             if (search === "")
                 return stringArgument("REPLACE", first);
-            return stringArgument("REPLACE", first)
-                .split(search)
-                .join(stringArgument("REPLACE", values[2]));
+            return protectedSqlTextValue(stringArgument("REPLACE", first).split(search).join(stringArgument("REPLACE", values[2])));
         }
         case "INSTR": {
             if (values[1] === null || values[1] === undefined)
@@ -280,9 +332,9 @@ export function scalarFunctionValue(name, values) {
         case "ABS":
             return Math.abs(numeric(first));
         case "UPPER":
-            return stringArgument("UPPER", first).toUpperCase();
+            return protectedSqlTextValue(stringArgument("UPPER", first).toUpperCase());
         case "LOWER":
-            return stringArgument("LOWER", first).toLowerCase();
+            return protectedSqlTextValue(stringArgument("LOWER", first).toLowerCase());
         case "TRIM":
             // SQL TRIM removes spaces, not general whitespace.
             return trimEnds("TRIM", first, values[1], "both");
@@ -306,7 +358,7 @@ export function scalarFunctionValue(name, values) {
                 return null;
             if (typeof value === "object")
                 return null;
-            return typeof value === "string" ? value : JSON.stringify(value);
+            return protectedSqlTextValue(typeof value === "string" ? value : JSON.stringify(value));
         }
         case "JSON_QUERY": {
             const found = jsonAtPath(first, values[1], "JSON_QUERY");
@@ -335,12 +387,12 @@ export function scalarFunctionValue(name, values) {
             const filler = Array.from(fill);
             // An empty fill cannot pad, so the value passes through, matching PostgreSQL.
             if (filler.length === 0)
-                return text.join("");
+                return protectedSqlTextValue(text.join(""));
             const padding = [];
             while (padding.length < width - text.length) {
                 padding.push(filler[padding.length % filler.length] ?? "");
             }
-            return name === "LPAD" ? padding.join("") + text.join("") : text.join("") + padding.join("");
+            return protectedSqlTextValue(name === "LPAD" ? padding.join("") + text.join("") : text.join("") + padding.join(""));
         }
         case "OVERLAY": {
             // OVERLAY(s PLACING r FROM start [FOR length]) replaces `length` characters of `s`
@@ -360,16 +412,16 @@ export function scalarFunctionValue(name, values) {
             if (!Number.isInteger(span) || span < 0) {
                 throw new TypeError("OVERLAY length must be a non-negative integer");
             }
-            return [
+            return protectedSqlTextValue([
                 ...text.slice(0, start - 1),
                 ...replacement,
                 ...text.slice(Math.min(start - 1 + span, text.length)),
-            ].join("");
+            ].join(""));
         }
         case "CAST":
             return castValue(first, typeof values[1] === "string" ? values[1] : "");
         case "SUBSTR": {
-            // SQL:2023 6.32: the result is the characters whose positions fall in both the requested
+            // PostgreSQL SUBSTRING returns the characters whose positions fall in both the requested
             // window and the string, so a start before 1 shortens the result instead of shifting it,
             // and a window entirely off the string is empty rather than an error.
             const text = Array.from(stringArgument("SUBSTR", first));
@@ -390,7 +442,7 @@ export function scalarFunctionValue(name, values) {
             }
             const from = Math.max(start, 1);
             const to = Math.min(until, text.length + 1);
-            return to <= from ? "" : text.slice(from - 1, to - 1).join("");
+            return protectedSqlTextValue(to <= from ? "" : text.slice(from - 1, to - 1).join(""));
         }
     }
 }
@@ -512,8 +564,32 @@ export function windowOutputType(window, innerSchema) {
     if (carries && window.argumentAlias !== undefined) {
         return innerSchema.find(({ name }) => name === window.argumentAlias)?.type ?? "number";
     }
+    if ((window.name === "SUM" || window.name === "AVG") &&
+        window.argumentAlias !== undefined &&
+        innerSchema.find(({ name }) => name === window.argumentAlias)?.sqlDomain?.kind === "numeric") {
+        return "string";
+    }
     return "number";
 }
+/** Logical domain carried or produced by a window result, when its physical type is not enough. */
+export function windowOutputDomain(window, innerSchema) {
+    if (window.argumentAlias === undefined)
+        return undefined;
+    const domain = innerSchema.find(({ name }) => name === window.argumentAlias)?.sqlDomain;
+    if (domain === undefined)
+        return undefined;
+    if (window.name === "MIN" ||
+        window.name === "MAX" ||
+        window.name === "LAG" ||
+        window.name === "LEAD" ||
+        window.name === "FIRST_VALUE" ||
+        window.name === "LAST_VALUE" ||
+        window.name === "NTH_VALUE" ||
+        ((window.name === "SUM" || window.name === "AVG") && domain.kind === "numeric")) {
+        return domain;
+    }
+    return undefined;
+}
 const MAX_RECURSIVE_ITERATIONS = 10_000;
 const MAX_RECURSIVE_ROWS = 1_000_000;
 /**
@@ -535,8 +611,6 @@ const createTableTypeNames = new Map([
     ["SMALLINT", "number"],
     ["REAL", "number"],
     ["FLOAT", "number"],
-    ["NUMERIC", "number"],
-    ["DECIMAL", "number"],
     ["TEXT", "string"],
     ["VARCHAR", "string"],
     ["CHAR", "string"],
@@ -569,7 +643,15 @@ const clauseKeywords = new Set([
     "UNION",
     "RETURNING",
 ]);
-const aggregateNames = new Set(["COUNT", "SUM", "AVG", "MIN", "MAX"]);
+const aggregateNames = new Set([
+    "COUNT",
+    "SUM",
+    "AVG",
+    "MIN",
+    "MAX",
+    "JSON_ARRAYAGG",
+    "STRING_AGG",
+]);
 /** Set functions the parser builds from COUNT/SUM rather than from their own accumulator. */
 const statisticalAggregates = new Set([
     "VAR_POP",
@@ -638,26 +720,29 @@ export function compileQuery(sql, options = {}) {
         compiled.parameterCount = parser.parameterCount;
     if (parser.usesStatementDatetime)
         compiled.usesStatementDatetime = true;
+    if (parser.usesSequenceCalls)
+        compiled.usesSequenceCalls = true;
+    if (parser.usesVolatileFunctions)
+        compiled.usesVolatileFunctions = true;
     return compiled;
 }
 /**
- * Reads a column DEFAULT into the catalog's own representation: a constant, or the
- * CURRENT_TIMESTAMP family, which the catalog records as "now" and fills per inserted row.
+ * Reads a column DEFAULT into the catalog's own representation. Literal nodes stay structured;
+ * every other variable-free SQL expression is preserved as authored for catalog introspection.
  */
-function columnDefaultFor(expression) {
+function columnDefaultFor(expression, sql) {
     if (expression.kind === "literal") {
         const value = expression.value;
         if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
             return { kind: "literal", value };
         }
         if (value instanceof Date)
-            return { kind: "literal", value: value.toISOString() };
-    }
-    if (expression.kind === "call" &&
-        (expression.name === "CURRENT_TIMESTAMP" || expression.name === "CURRENT_DATE")) {
-        return { kind: "now" };
+            return { kind: "literal", value: new Date(value.getTime()) };
     }
-    throw new TypeError("DEFAULT takes a constant or CURRENT_TIMESTAMP");
+    return { kind: "expression", sql };
+}
+export function isDefaultInsertValue(value) {
+    return (typeof value === "object" && value !== null && !(value instanceof Date) && "default" in value);
 }
 /**
  * Parses CREATE TRIGGER name AFTER INSERT|UPDATE|DELETE ON table [FOR EACH ROW]
@@ -674,6 +759,37 @@ function columnDefaultFor(expression) {
  * mode a transaction could relax into.
  */
 function parseTransactionStatement(keyword, tokens) {
+    const identifierAt = (index) => {
+        const token = tokens[index];
+        if (token?.kind !== "identifier") {
+            throw new TypeError(`Expected savepoint name, found ${token?.text ?? "end of input"}`);
+        }
+        return token.text;
+    };
+    if (keyword === "SAVEPOINT") {
+        const name = identifierAt(1);
+        if (tokens[2]?.kind !== "eof")
+            throw new TypeError("Unexpected input after SAVEPOINT name");
+        return { kind: "transaction", action: "savepoint", name };
+    }
+    if (keyword === "RELEASE") {
+        const hasNoise = tokens[1]?.kind === "identifier" && tokens[1].text.toUpperCase() === "SAVEPOINT";
+        const name = identifierAt(hasNoise ? 2 : 1);
+        if (tokens[hasNoise ? 3 : 2]?.kind !== "eof") {
+            throw new TypeError("Unexpected input after RELEASE name");
+        }
+        return { kind: "transaction", action: "release", name };
+    }
+    if (keyword === "ROLLBACK" &&
+        tokens[1]?.kind === "identifier" &&
+        tokens[1].text.toUpperCase() === "TO") {
+        const hasNoise = tokens[2]?.kind === "identifier" && tokens[2].text.toUpperCase() === "SAVEPOINT";
+        const name = identifierAt(hasNoise ? 3 : 2);
+        if (tokens[hasNoise ? 4 : 3]?.kind !== "eof") {
+            throw new TypeError("Unexpected input after ROLLBACK TO name");
+        }
+        return { kind: "transaction", action: "rollback-to", name };
+    }
     const words = tokens
         .filter((token) => token.kind === "identifier")
         .map((token) => token.text.toUpperCase());
@@ -702,6 +818,50 @@ export function compileCheckExpression(sql, name) {
     }
     return expression;
 }
+/**
+ * Parses and type-checks one catalog default. PostgreSQL defaults are variable-free scalar
+ * expressions: functions and operators are allowed, while row references, parameters,
+ * aggregates, windows, and subqueries are not.
+ */
+export function validateDefaultExpression(sql, target) {
+    const parser = new Parser(tokenize(sql), sql);
+    const expression = parser.parseExpression();
+    const hasSubquery = (value) => value.kind === "subquery" ||
+        value.kind === "exists" ||
+        childExpressions(value).some(hasSubquery);
+    if (expressionColumns(expression).length > 0 ||
+        containsParameter(expression) ||
+        hasAggregate(expression) ||
+        containsWindow(expression) ||
+        hasSubquery(expression)) {
+        throw new TypeError(`DEFAULT ${target.name} takes a variable-free scalar SQL expression`);
+    }
+    const plan = {
+        sql: `(default ${target.name})`,
+        base: { table: DUAL_TABLE, alias: DUAL_TABLE },
+        joins: [],
+        select: [{ expression, alias: "value" }],
+        predicates: [],
+        groupBy: [],
+        having: [],
+        orderBy: [],
+    };
+    let inferred;
+    try {
+        inferred = inferBlockSchema(plan, new Map())[0]?.type;
+    }
+    catch (error) {
+        if (!(error instanceof TypeError) || !error.message.startsWith("Cannot infer a column type")) {
+            throw error;
+        }
+    }
+    // A bare NULL is polymorphic in PostgreSQL; the destination column supplies its type.
+    if (inferred !== undefined &&
+        inferred !== target.type &&
+        !(target.sqlDomain?.kind === "numeric" && inferred === "number")) {
+        throw new TypeError(`DEFAULT ${target.name} produces ${inferred}, but the column is ${target.type}`);
+    }
+}
 /**
  * CREATE [OR REPLACE] VIEW name AS <query>. The body is kept as the author's own text rather
  * than a re-rendered plan: the catalog stores what was written, and every read compiles it
@@ -872,7 +1032,9 @@ export function compileStatement(sql) {
         if (keyword === "BEGIN" ||
             keyword === "START" ||
             keyword === "COMMIT" ||
-            keyword === "ROLLBACK") {
+            keyword === "ROLLBACK" ||
+            keyword === "SAVEPOINT" ||
+            keyword === "RELEASE") {
             return parseTransactionStatement(keyword, tokens);
         }
         if (keyword === "MERGE") {
@@ -892,18 +1054,62 @@ export function compileStatement(sql) {
         if (keyword === "CREATE") {
             if (isTriggerDdl)
                 return parseCreateTrigger(text, tokens);
+            if (second?.kind === "identifier" && second.text.toUpperCase() === "TYPE") {
+                const name = tokens[2];
+                if (name?.kind !== "identifier")
+                    throw new TypeError("CREATE TYPE needs a name");
+                const as = tokens[3];
+                const enumToken = tokens[4];
+                if (as?.kind !== "identifier" ||
+                    as.text.toUpperCase() !== "AS" ||
+                    enumToken?.kind !== "identifier" ||
+                    enumToken.text.toUpperCase() !== "ENUM" ||
+                    tokens[5]?.text !== "(") {
+                    throw new TypeError("CREATE TYPE supports AS ENUM (...)");
+                }
+                const values = [];
+                let index = 6;
+                for (;;) {
+                    const value = tokens[index];
+                    if (value?.kind !== "string")
+                        throw new TypeError("ENUM values must be string literals");
+                    values.push(value.text);
+                    index += 1;
+                    if (tokens[index]?.text === ")")
+                        break;
+                    if (tokens[index]?.text !== ",")
+                        throw new TypeError("Expected comma in ENUM values");
+                    index += 1;
+                }
+                if (tokens[index + 1]?.kind !== "eof")
+                    throw new TypeError("Unexpected input after ENUM");
+                return { kind: "create-enum", name: name.text, values };
+            }
+            if (second?.kind === "identifier" && second.text.toUpperCase() === "SEQUENCE") {
+                const name = tokens[2];
+                if (name?.kind !== "identifier")
+                    throw new TypeError("CREATE SEQUENCE needs a name");
+                if (tokens[3]?.kind !== "eof") {
+                    throw new TypeError("CREATE SEQUENCE options are not supported yet");
+                }
+                return { kind: "create-sequence", name: name.text };
+            }
             const viewAt = second?.text.toUpperCase() === "OR" ? 3 : 1;
             if (tokens[viewAt]?.kind === "identifier" && tokens[viewAt].text.toUpperCase() === "VIEW") {
                 return parseCreateView(text, tokens, viewAt === 3);
             }
             parser = new Parser(tokens, text);
+            if (second?.kind === "identifier" &&
+                (second.text.toUpperCase() === "INDEX" || second.text.toUpperCase() === "UNIQUE")) {
+                return parser.parseCreateIndex();
+            }
             const statement = parser.parseCreateTable();
             if (parser.parameterCount > 0)
                 statement.parameterCount = parser.parameterCount;
             return statement;
         }
         if (keyword === "ALTER") {
-            parser = new Parser(tokens);
+            parser = new Parser(tokens, text);
             return parser.parseAlterTable();
         }
         if (keyword === "DROP") {
@@ -919,7 +1125,11 @@ export function compileStatement(sql) {
                 parser = new Parser(tokens);
                 return parser.parseDropTable();
             }
-            throw new TypeError("DROP supports: DROP TABLE name, DROP TRIGGER name");
+            if (second?.kind === "identifier" && second.text.toUpperCase() === "INDEX") {
+                parser = new Parser(tokens);
+                return parser.parseDropIndex();
+            }
+            throw new TypeError("DROP supports: DROP TABLE, DROP VIEW, DROP INDEX, DROP TRIGGER");
         }
         if (keyword === "WITH") {
             parser = new Parser(tokens);
@@ -1203,6 +1413,9 @@ function bindExpression(expression, values) {
     }
     if (expression.kind === "call") {
         expression.arguments = expression.arguments.map((argument) => bindExpression(argument, values));
+        for (const order of expression.aggregateOrderBy ?? []) {
+            order.expression = bindExpression(order.expression, values);
+        }
         return expression;
     }
     if (expression.kind === "list") {
@@ -1320,7 +1533,7 @@ export function bindPlanParameters(plan, params) {
     return clone;
 }
 function isParameterSlot(value) {
-    return typeof value === "object" && value !== null && !(value instanceof Date);
+    return (typeof value === "object" && value !== null && !(value instanceof Date) && "parameter" in value);
 }
 /** The mutation-statement counterpart of bindPlanParameters; SELECTs bind through their plan. */
 export function bindStatementParameters(statement, params) {
@@ -1332,6 +1545,8 @@ export function bindStatementParameters(statement, params) {
         throw new TypeError("SELECT parameters bind through the query pipeline, not the statement");
     }
     if (statement.kind === "create-table" ||
+        statement.kind === "create-enum" ||
+        statement.kind === "create-sequence" ||
         statement.kind === "create-trigger" ||
         statement.kind === "drop-trigger") {
         throw new TypeError("DDL statements take no parameters");
@@ -1343,6 +1558,14 @@ export function bindStatementParameters(statement, params) {
         if (clone.query !== undefined)
             bindBlock(clone.query, values);
         clone.rows = clone.rows.map((row) => row.map((value) => (isParameterSlot(value) ? (values[value.parameter] ?? null) : value)));
+        if (clone.onConflict?.assignments !== undefined) {
+            for (const assignment of clone.onConflict.assignments) {
+                assignment.expression = bindExpression(assignment.expression, values);
+            }
+        }
+        if (clone.onConflict?.where !== undefined) {
+            clone.onConflict.where = bindExpression(clone.onConflict.where, values);
+        }
         return clone;
     }
     if (clone.kind === "drop-table" ||
@@ -1392,9 +1615,13 @@ export function bindStatementParameters(statement, params) {
 export function inferBlockSchema(plan, schemas) {
     const sources = [plan.base, ...plan.joins];
     const multipleSources = sources.length > 1;
-    const wildcardSchema = (source) => (schemas.get(source.table) ?? []).map((column) => ({
+    const wildcardSchema = (source) => (schemas.get(source.table) ?? [])
+        .filter((column) => !column.name.startsWith("\0"))
+        .map((column) => ({
         name: multipleSources ? `${source.alias}.${column.name}` : column.name,
         type: column.type,
+        ...(column.integer === true ? { integer: true } : {}),
+        ...(column.sqlDomain === undefined ? {} : { sqlDomain: column.sqlDomain }),
     }));
     if (plan.select[0]?.expression.kind === "wildcard" &&
         plan.select[0].expression.table === undefined)
@@ -1417,6 +1644,84 @@ export function inferBlockSchema(plan, schemas) {
             throw new TypeError(`Ambiguous or missing column: ${reference}`);
         return matches[0] ?? "string";
     };
+    const resolveColumnInteger = (reference) => {
+        const parts = reference.split(".");
+        if (parts.length === 2) {
+            const source = sources.find(({ alias }) => alias === parts[0]);
+            return (source !== undefined &&
+                (schemas.get(source.table) ?? []).find(({ name }) => name === parts[1])?.integer === true);
+        }
+        const matches = sources.flatMap((source) => (schemas.get(source.table) ?? []).filter(({ name }) => name === parts[0]));
+        return matches.length === 1 && matches[0]?.integer === true;
+    };
+    const resolveColumnDomain = (reference) => {
+        const parts = reference.split(".");
+        if (parts.length === 2) {
+            const source = sources.find(({ alias }) => alias === parts[0]);
+            return source === undefined
+                ? undefined
+                : (schemas.get(source.table) ?? []).find(({ name }) => name === parts[1])?.sqlDomain;
+        }
+        const matches = sources.flatMap((source) => (schemas.get(source.table) ?? []).filter(({ name }) => name === parts[0]));
+        return matches.length === 1 ? matches[0]?.sqlDomain : undefined;
+    };
+    const castDomain = (target) => {
+        if (target.startsWith("numeric:")) {
+            const [, precisionWord = "", scaleWord = ""] = target.split(":");
+            const precision = precisionWord === "" ? undefined : Number(precisionWord);
+            const scale = scaleWord === "" ? undefined : Number(scaleWord);
+            return {
+                kind: "numeric",
+                ...(precision === undefined ? {} : { precision }),
+                ...(scale === undefined ? {} : { scale }),
+            };
+        }
+        if (target === "json" || target === "jsonb" || target === "uuid" || target === "time") {
+            return { kind: target };
+        }
+        if (target === "interval")
+            return { kind: "interval" };
+        return undefined;
+    };
+    const inferDomain = (expression) => {
+        if (expression.kind === "literal")
+            return expression.sqlDomain;
+        if (expression.kind === "column")
+            return resolveColumnDomain(expression.reference);
+        if (expression.kind === "binary") {
+            const left = inferDomain(expression.left);
+            const right = inferDomain(expression.right);
+            return left?.kind === "numeric" || right?.kind === "numeric"
+                ? { kind: "numeric" }
+                : undefined;
+        }
+        if (expression.kind === "case") {
+            const outcomes = [
+                ...expression.branches.map((branch) => branch.then),
+                ...(expression.otherwise === undefined ? [] : [expression.otherwise]),
+            ];
+            return outcomes.map(inferDomain).find((domain) => domain !== undefined);
+        }
+        if (expression.kind !== "call")
+            return undefined;
+        if (expression.name === "CAST") {
+            const target = expression.arguments[1];
+            return target?.kind === "literal" && typeof target.value === "string"
+                ? castDomain(target.value)
+                : undefined;
+        }
+        if (expression.name === "SUM" ||
+            expression.name === "AVG" ||
+            expression.name === "MIN" ||
+            expression.name === "MAX" ||
+            expression.name === "COALESCE" ||
+            expression.name === "NULLIF" ||
+            expression.name === "GREATEST" ||
+            expression.name === "LEAST") {
+            return expression.arguments.map(inferDomain).find((domain) => domain !== undefined);
+        }
+        return undefined;
+    };
     const infer = (expression) => {
         if (expression.kind === "subquery" || expression.kind === "list") {
             throw new TypeError("Subqueries must be resolved before schema inference");
@@ -1489,17 +1794,21 @@ export function inferBlockSchema(plan, schemas) {
                 }
                 return "string";
             }
+            const exactNumeric = inferDomain(expression)?.kind === "numeric";
             for (const side of [expression.left, expression.right]) {
                 const type = infer(side);
-                if (type === "string" || type === "boolean") {
+                if (type === "boolean" || (type === "string" && inferDomain(side)?.kind !== "numeric")) {
                     throw new TypeError(`Arithmetic requires numeric operands: ${plan.sql}`);
                 }
             }
-            return "number";
+            return exactNumeric ? "string" : "number";
         }
-        if (expression.name === "COUNT" || expression.name === "SUM" || expression.name === "AVG") {
+        if (expression.name === "COUNT") {
             return "number";
         }
+        if (expression.name === "SUM" || expression.name === "AVG") {
+            return inferDomain(expression)?.kind === "numeric" ? "string" : "number";
+        }
         if (expression.name === "ROUND" ||
             expression.name === "LENGTH" ||
             expression.name === "ABS" ||
@@ -1511,13 +1820,22 @@ export function inferBlockSchema(plan, schemas) {
             expression.name === "INSTR" ||
             expression.name === "EXTRACT" ||
             expression.name === "OCTET_LENGTH" ||
-            expression.name === "GROUPING") {
+            expression.name === "GROUPING" ||
+            expression.name === "NEXTVAL" ||
+            expression.name === "CURRVAL" ||
+            expression.name === "RANDOM") {
             return "number";
         }
-        if (expression.name === "JSON_VALUE" ||
+        if (expression.name === "JSON_ARRAYAGG" ||
+            expression.name === "STRING_AGG" ||
+            expression.name === "JSON_VALUE" ||
             expression.name === "JSON_QUERY" ||
             expression.name === "JSON_OBJECT" ||
-            expression.name === "JSON_ARRAY") {
+            expression.name === "JSON_ARRAY" ||
+            expression.name === "ARRAY" ||
+            expression.name === "MINNOW_TUPLE_KEY" ||
+            expression.name === "MINNOW_COLLATE" ||
+            expression.name === "GEN_RANDOM_UUID") {
             return "string";
         }
         if (expression.name === "JSON_EXISTS" || expression.name === "IS_JSON")
@@ -1527,8 +1845,8 @@ export function inferBlockSchema(plan, schemas) {
         if (expression.name === "CURRENT_DATE" || expression.name === "CURRENT_TIMESTAMP") {
             return "datetime";
         }
-        // The engine has no TIME type, so LOCALTIME reads as an 'HH:MM:SS' string, like SQLite's
-        // CURRENT_TIME.
+        // 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")
             return "string";
         if (expression.name === "NULLIF" ||
@@ -1552,6 +1870,8 @@ export function inferBlockSchema(plan, schemas) {
             const word = target?.kind === "literal" && typeof target.value === "string" ? target.value : "";
             if (word === "number-integer")
                 return "number";
+            if (castDomain(word) !== undefined)
+                return "string";
             if (word === "number" || word === "string" || word === "boolean" || word === "datetime") {
                 return word;
             }
@@ -1604,9 +1924,60 @@ export function inferBlockSchema(plan, schemas) {
         if (type === "null") {
             throw new TypeError(`Cannot infer a column type for output ${item.alias}`);
         }
-        return [{ name: item.alias, type }];
+        const integer = (item.expression.kind === "column" && resolveColumnInteger(item.expression.reference)) ||
+            (item.expression.kind === "call" &&
+                item.expression.name === "CAST" &&
+                item.expression.arguments[1]?.kind === "literal" &&
+                item.expression.arguments[1].value === "number-integer") ||
+            (item.expression.kind === "call" && item.expression.name === "COUNT");
+        const sqlDomain = inferDomain(item.expression);
+        return [
+            {
+                name: item.alias,
+                type,
+                ...(integer ? { integer: true } : {}),
+                ...(sqlDomain === undefined ? {} : { sqlDomain }),
+            },
+        ];
     });
 }
+/** 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,
+    // PostgreSQL permits an untyped NULL output and Minnow historically permits heterogeneous CASE
+    // results, so calling inferBlockSchema here would make execution stricter just because tagged
+    // domains exist elsewhere in the engine. Be conservative instead: externalization is a cheap
+    // prefix check, and only domain-bearing schemas or expressions pay it.
+    const createsDomain = (expression) => {
+        if (expression.kind === "literal" && expression.internalSqlValue === true)
+            return true;
+        if (expression.kind === "call") {
+            if (expression.name === "ARRAY" || expression.name === "MINNOW_COLLATE")
+                return true;
+            if (expression.name === "CAST") {
+                const target = expression.arguments[1];
+                if (target?.kind === "literal" &&
+                    typeof target.value === "string" &&
+                    (target.value.startsWith("numeric:") ||
+                        ["json", "jsonb", "uuid", "time", "interval"].includes(target.value))) {
+                    return true;
+                }
+            }
+        }
+        return childExpressions(expression).some(createsDomain);
+    };
+    try {
+        // Plain TEXT uses a protected execution-time wrapper when it happens to share the internal
+        // domain namespace, so string outputs cross the same boundary as logical SQL domains.
+        return inferBlockSchema(plan, schemas).some((column) => column.type === "string" || column.sqlDomain !== undefined);
+    }
+    catch {
+        // This flag must not make execution stricter for historically accepted shapes such as an
+        // untyped NULL or heterogeneous CASE. When exact inference cannot answer, scan if any source
+        // or expression could carry an internal string; externalization itself remains copy-on-change.
+        return ([...schemas.values()].some((columns) => columns.some((column) => column.type === "string" || column.sqlDomain !== undefined)) || plan.select.some(({ expression }) => createsDomain(expression)));
+    }
+}
 export function referencedColumns(plan, schemas) {
     const sources = [plan.base, ...plan.joins];
     const sourceAliases = sources.map((source) => source.alias);
@@ -1656,8 +2027,13 @@ export function referencedColumns(plan, schemas) {
             for (const source of sources) {
                 if (named !== undefined && source.alias !== named)
                     continue;
-                for (const column of schemas.get(source.table) ?? [])
+                for (const column of schemas.get(source.table) ?? []) {
+                    // Storage may carry unspellable NUL-prefixed locator columns for composite identity.
+                    // Explicit internal references can request one; SQL wildcards are public schema only.
+                    if (column.startsWith("\u0000"))
+                        continue;
                     requested.get(source.table)?.add(column);
+                }
             }
         }
     };
@@ -1746,12 +2122,16 @@ export function createPreparedQuery(plan, tables, options = {}) {
     const ties = withTiesPlan(plan);
     if (ties.plan !== plan)
         return trimPreparedResults(createPreparedQuery(ties.plan, tables, options), ties.trim);
+    // Rows passed to this low-level public entry point are public SQL values. Escape the private
+    // string-domain namespace before derived blocks add their own already-internal results. This
+    // comes after WITH TIES lowering because that lowering recursively prepares the same input.
+    tables = cloneRowTables(tables, true);
     // Every engine entry expands MATCH(*) exactly once, here against the row tables' own
     // columns; past this point no executor sees the "*" sentinel.
     plan = expandFtsColumns(plan, rowTableSearchableColumns(tables));
     const resolution = subqueryResolutionSteps(plan);
     for (const step of resolution.steps)
-        step.substitute(executeRowQuery(step.block, tables));
+        step.substitute(executeRowQueryInternal(step.block, tables));
     plan = resolution.plan;
     tables = resolveDerivedRowTables(plan, tables);
     plan = expandDistinctWildcard(plan, wildcardRowColumns(tables));
@@ -1764,7 +2144,7 @@ export function createPreparedQuery(plan, tables, options = {}) {
         return createPreparedRowQuery(plan, tables, memory);
     }
     try {
-        return createPreparedColumnarQuery(plan, normalizeColumnarTables(plan, tables), memory);
+        return trimPreparedResults(createPreparedColumnarQuery(plan, normalizeColumnarTables(plan, tables), memory), externalizeQueryResult);
     }
     catch (error) {
         memory.close();
@@ -1799,6 +2179,7 @@ export function createPreparedColumnarQuery(plan, tables, memory = new QueryMemo
         memory.close();
         throw error;
     }
+    const outputNeedsExternalization = options.outputNeedsExternalization;
     return {
         sql: plan.sql,
         tables: [plan.base.table, ...plan.joins.map((join) => join.table)],
@@ -1808,12 +2189,12 @@ export function createPreparedColumnarQuery(plan, tables, memory = new QueryMemo
         execute() {
             if (closed || prepared === undefined)
                 throw new Error("Prepared query is closed");
-            return prepared.execute();
+            return markExternalizationState(prepared.execute(), outputNeedsExternalization);
         },
         async executeAsync(options) {
             if (closed || prepared === undefined)
                 throw new Error("Prepared query is closed");
-            return prepared.executeAsync(options);
+            return markExternalizationState(await prepared.executeAsync(options), outputNeedsExternalization);
         },
         close() {
             if (closed)
@@ -1837,12 +2218,12 @@ function createPreparedRowQuery(plan, tables, memory) {
         execute() {
             if (closed || rows === undefined)
                 throw new Error("Prepared query is closed");
-            return executeRowQuery(plan, cloneRowTables(rows));
+            return externalizeQueryResult(executeRowQueryInternal(plan, cloneRowTables(rows)));
         },
         async executeAsync() {
             if (closed || rows === undefined)
                 throw new Error("Prepared query is closed");
-            return executeRowQuery(plan, cloneRowTables(rows));
+            return externalizeQueryResult(executeRowQueryInternal(plan, cloneRowTables(rows)));
         },
         close() {
             closed = true;
@@ -1851,19 +2232,23 @@ function createPreparedRowQuery(plan, tables, memory) {
         },
     };
 }
-function cloneRowTables(tables) {
+function cloneRowTables(tables, protectText = false) {
     return new Map([...tables].map(([name, rows]) => [
         name,
         rows.map((row) => Object.fromEntries(Object.entries(row).map(([column, value]) => [
             column,
-            value instanceof Date ? new Date(value.getTime()) : value,
+            value instanceof Date
+                ? new Date(value.getTime())
+                : protectText && typeof value === "string"
+                    ? protectedSqlTextValue(value)
+                    : value,
         ]))),
     ]));
 }
 export function executeQuery(plan, tables, options = {}) {
     const prepared = createPreparedQuery(plan, tables, options);
     try {
-        return prepared.execute();
+        return externalizeQueryResult(prepared.execute());
     }
     finally {
         prepared.close();
@@ -1993,8 +2378,12 @@ export function createRecursiveCteState(base, all) {
 export function childExpressions(expression) {
     if (expression.kind === "binary")
         return [expression.left, expression.right];
-    if (expression.kind === "call")
-        return [...expression.arguments];
+    if (expression.kind === "call") {
+        return [
+            ...expression.arguments,
+            ...(expression.aggregateOrderBy ?? []).map((order) => order.expression),
+        ];
+    }
     if (expression.kind === "list")
         return [...expression.items];
     if (expression.kind === "condition" || expression.kind === "logical") {
@@ -2035,7 +2424,18 @@ export function mapChildExpressions(expression, map) {
     if (expression.kind === "not")
         return { ...expression, operand: map(expression.operand) };
     if (expression.kind === "call") {
-        return { ...expression, arguments: expression.arguments.map(map) };
+        return {
+            ...expression,
+            arguments: expression.arguments.map(map),
+            ...(expression.aggregateOrderBy === undefined
+                ? {}
+                : {
+                    aggregateOrderBy: expression.aggregateOrderBy.map((order) => ({
+                        ...order,
+                        expression: map(order.expression),
+                    })),
+                }),
+        };
     }
     if (expression.kind === "list")
         return { ...expression, items: expression.items.map(map) };
@@ -2284,6 +2684,21 @@ function aggregateWindowMembers(window, values, members) {
     if (present.length === 0)
         return null;
     if (window.name === "SUM" || window.name === "AVG") {
+        const exact = present.some((member) => isExactNumeric(values[member]));
+        if (exact) {
+            let total = exactNumericValue(0);
+            for (const member of present) {
+                const value = values[member];
+                if (!isExactNumeric(value)) {
+                    throw new TypeError("Exact NUMERIC window input mixed with an approximate number");
+                }
+                const next = exactNumericBinary("+", total, value);
+                if (next === null || next === undefined)
+                    throw new Error("Exact NUMERIC sum disappeared");
+                total = next;
+            }
+            return window.name === "SUM" ? total : exactNumericBinary("/", total, present.length);
+        }
         const total = present.reduce((sum, member) => sum + numeric(values[member]), 0);
         return window.name === "SUM" ? total : total / present.length;
     }
@@ -2342,17 +2757,39 @@ function applyAggregateWindowPartition(rows, indexes, window, frame, sameOrderKe
         }
     }
     const values = [];
-    const prefixNonNull = new Float64Array(size + 1);
-    const prefixSum = new Float64Array(size + 1);
     const sums = window.name === "SUM" || window.name === "AVG";
     for (let position = 0; position < size; position += 1) {
         const value = window.argumentAlias === undefined
             ? undefined
             : (rows[indexes[start + position] ?? -1]?.[window.argumentAlias] ?? null);
         values.push(value);
+    }
+    const exactSums = sums && values.some((value) => isExactNumeric(value));
+    const prefixNonNull = new Float64Array(size + 1);
+    const prefixSum = exactSums ? undefined : new Float64Array(size + 1);
+    const prefixExact = exactSums ? new Array(size + 1) : undefined;
+    const exactZero = exactNumericValue(0);
+    if (exactZero === null)
+        throw new Error("Exact NUMERIC zero disappeared");
+    if (prefixExact !== undefined)
+        prefixExact[0] = exactZero;
+    for (let position = 0; position < size; position += 1) {
+        const value = values[position];
         const nonNull = window.argumentAlias !== undefined && value !== null && value !== undefined;
         prefixNonNull[position + 1] = (prefixNonNull[position] ?? 0) + (nonNull ? 1 : 0);
-        prefixSum[position + 1] = (prefixSum[position] ?? 0) + (sums && nonNull ? numeric(value) : 0);
+        if (prefixExact !== undefined) {
+            if (nonNull && !isExactNumeric(value)) {
+                throw new TypeError("Exact NUMERIC window input mixed with an approximate number");
+            }
+            const previous = prefixExact[position] ?? exactZero;
+            const next = nonNull ? exactNumericBinary("+", previous, value) : previous;
+            if (next === null || next === undefined)
+                throw new Error("Exact NUMERIC sum disappeared");
+            prefixExact[position + 1] = next;
+        }
+        else if (prefixSum !== undefined) {
+            prefixSum[position + 1] = (prefixSum[position] ?? 0) + (sums && nonNull ? numeric(value) : 0);
+        }
     }
     // GROUPS frames count peer groups rather than rows, so each position needs its group's
     // ordinal and the group boundaries to translate an offset back into row positions.
@@ -2459,8 +2896,17 @@ function applyAggregateWindowPartition(rows, indexes, window, frame, sameOrderKe
         }
         else if (sums) {
             const nonNull = (prefixNonNull[high] ?? 0) - (prefixNonNull[low] ?? 0);
-            const total = (prefixSum[high] ?? 0) - (prefixSum[low] ?? 0);
-            value = nonNull === 0 ? null : window.name === "SUM" ? total : total / nonNull;
+            if (nonNull === 0) {
+                value = null;
+            }
+            else if (prefixExact !== undefined) {
+                const total = exactNumericBinary("-", prefixExact[high] ?? exactZero, prefixExact[low] ?? exactZero);
+                value = window.name === "SUM" ? total : exactNumericBinary("/", total, nonNull);
+            }
+            else {
+                const total = (prefixSum?.[high] ?? 0) - (prefixSum?.[low] ?? 0);
+                value = window.name === "SUM" ? total : total / nonNull;
+            }
         }
         else {
             let best;
@@ -2681,28 +3127,28 @@ function resolveDerivedRowTables(plan, tables) {
     for (const source of sources) {
         if (source.recursive !== undefined) {
             const { reference, base, step, all } = source.recursive;
-            const state = createRecursiveCteState(executeRowQuery(base, tables), all);
+            const state = createRecursiveCteState(executeRowQueryInternal(base, tables), all);
             while (state.frontier.length > 0) {
                 const stepTables = new Map(tables);
                 stepTables.set(reference, state.frontier);
-                state.absorb(executeRowQuery(step, stepTables));
+                state.absorb(executeRowQueryInternal(step, stepTables));
             }
             resolved.set(source.table, state.rows);
             continue;
         }
         if (source.union !== undefined) {
-            const results = source.union.blocks.map((block) => executeRowQuery(block, tables));
+            const results = source.union.blocks.map((block) => executeRowQueryInternal(block, tables));
             resolved.set(source.table, combineUnionResults(results, source.union.ops).rows);
             continue;
         }
         if (source.windowed !== undefined) {
-            const inner = executeRowQuery(source.windowed.block, tables);
+            const inner = executeRowQueryInternal(source.windowed.block, tables);
             resolved.set(source.table, applyWindowFunctions(inner, source.windowed.windows).rows);
             continue;
         }
         if (source.derived === undefined)
             continue;
-        resolved.set(source.table, executeRowQuery(source.derived, tables).rows);
+        resolved.set(source.table, executeRowQueryInternal(source.derived, tables).rows);
     }
     return resolved;
 }
@@ -2717,11 +3163,14 @@ function normalizeColumnarTables(plan, tables) {
         .filter(([name]) => requiredTables.has(name))
         .map(([name, table]) => [
         name,
-        columnarTableFromRows(name, table, requestedColumns.get(name) ?? []),
+        columnarTableFromRows(name, table, requestedColumns.get(name) ?? [], false),
     ]));
 }
 /** Correctness reference retained while the vector executor matures. */
 export function executeRowQuery(plan, tables) {
+    return externalizeQueryResult(executeRowQueryInternal(plan, cloneRowTables(tables, true)));
+}
+function executeRowQueryInternal(plan, tables) {
     assertTailParametersBound(plan);
     validateGrouping(plan);
     plan = resolveStatementDatetimes(plan);
@@ -2732,8 +3181,9 @@ export function executeRowQuery(plan, tables) {
     plan = ties.plan;
     plan = expandFtsColumns(plan, rowTableSearchableColumns(tables));
     const resolution = subqueryResolutionSteps(plan);
-    for (const step of resolution.steps)
-        step.substitute(executeRowQuery(step.block, tables));
+    for (const step of resolution.steps) {
+        step.substitute(executeRowQueryInternal(step.block, tables));
+    }
     // Stats annotation writes into the plan; when resolution had nothing to clone, the plan is
     // still the caller's (possibly cached) object, and frozen statistics would survive into later
     // executions against different rows.
@@ -2785,12 +3235,13 @@ export function executeRowQuery(plan, tables) {
             : [];
         const sortColumns = plan.orderBy.map(({ expression, direction, nulls }) => ({
             outputName: orderOutputName(expression, plan.select, orderSources),
+            direction,
             multiplier: direction === "desc" ? -1 : 1,
             nulls,
         }));
         rows.sort((left, right) => {
-            for (const { outputName, multiplier, nulls } of sortColumns) {
-                const placed = explicitNullOrder(left[outputName], right[outputName], nulls);
+            for (const { outputName, direction, multiplier, nulls } of sortColumns) {
+                const placed = nullOrder(left[outputName], right[outputName], nulls, direction);
                 if (placed !== undefined && placed !== 0)
                     return placed;
                 const comparison = compareValues(left[outputName], right[outputName]);
@@ -2876,11 +3327,15 @@ function executeJoin(contexts, join, rows) {
                 const candidate = { ...context, [join.alias]: row };
                 if (evaluateBooleanExpression(condition, (nested) => evaluate(nested, candidate)) === true) {
                     matched = true;
-                    joined.push(candidate);
+                    if (join.kind !== "anti")
+                        joined.push(join.kind === "semi" ? context : candidate);
+                    if (join.kind === "semi" || join.kind === "anti")
+                        break;
                 }
             }
-            if (!matched && join.kind === "left")
-                joined.push({ ...context, [join.alias]: undefined });
+            if (!matched && (join.kind === "left" || join.kind === "anti")) {
+                joined.push(join.kind === "anti" ? context : { ...context, [join.alias]: undefined });
+            }
         }
         return joined;
     }
@@ -2905,11 +3360,16 @@ function executeJoin(contexts, join, rows) {
     for (const context of contexts) {
         const leftKey = comparable(evaluate(leftExpression, context));
         const matches = isSqlJoinKey(leftKey) ? (index.get(leftKey) ?? []) : [];
-        if (matches.length === 0 && join.kind === "left")
-            joined.push({ ...context, [join.alias]: undefined });
-        else
+        if (matches.length === 0 && (join.kind === "left" || join.kind === "anti")) {
+            joined.push(join.kind === "anti" ? context : { ...context, [join.alias]: undefined });
+        }
+        else if (matches.length > 0 && join.kind === "semi") {
+            joined.push(context);
+        }
+        else if (join.kind !== "anti") {
             for (const row of matches)
                 joined.push({ ...context, [join.alias]: row });
+        }
     }
     return joined;
 }
@@ -2929,7 +3389,9 @@ function project(select, context, group) {
 function evaluate(expression, context, group) {
     switch (expression.kind) {
         case "literal":
-            return expression.value;
+            return typeof expression.value === "string" && expression.internalSqlValue !== true
+                ? protectedSqlTextValue(expression.value)
+                : expression.value;
         case "parameter":
             throw new TypeError(`Placeholder $${String(expression.index + 1)} is unbound; pass parameters when executing`);
         case "wildcard":
@@ -2981,8 +3443,11 @@ function evaluate(expression, context, group) {
                 if (typeof left !== "string" || typeof right !== "string") {
                     throw new TypeError("|| requires string operands");
                 }
-                return left + right;
+                return protectedSqlTextValue(String(externalSqlDomainValue(left)) + String(externalSqlDomainValue(right)));
             }
+            const exact = exactNumericBinary(expression.operator, left, right);
+            if (exact !== undefined)
+                return exact;
             const a = numeric(left);
             const b = numeric(right);
             if (expression.operator === "+")
@@ -3001,11 +3466,69 @@ function evaluate(expression, context, group) {
                 if (group === undefined)
                     throw new TypeError(`${expression.name} requires grouped execution`);
                 const argument = expression.arguments[0] ?? { kind: "wildcard" };
+                if (expression.name === "STRING_AGG") {
+                    const delimiter = expression.arguments[1];
+                    if (delimiter === undefined)
+                        throw new TypeError("STRING_AGG requires a delimiter");
+                    let members = group.flatMap((row) => {
+                        const value = evaluate(argument, row);
+                        if (value === null || value === undefined)
+                            return [];
+                        if (typeof value !== "string") {
+                            throw new TypeError("STRING_AGG value must be a string");
+                        }
+                        const separator = evaluate(delimiter, row);
+                        if (separator !== null && separator !== undefined && typeof separator !== "string") {
+                            throw new TypeError("STRING_AGG delimiter must be a string");
+                        }
+                        return [
+                            {
+                                value,
+                                delimiter: separator ?? "",
+                                order: (expression.aggregateOrderBy ?? []).map((item) => evaluate(item.expression, row)),
+                            },
+                        ];
+                    });
+                    if (expression.distinct === true) {
+                        const seen = new Set();
+                        members = members.filter((member) => {
+                            const key = JSON.stringify([member.value, member.delimiter]);
+                            if (seen.has(key))
+                                return false;
+                            seen.add(key);
+                            return true;
+                        });
+                    }
+                    if ((expression.aggregateOrderBy?.length ?? 0) > 0) {
+                        members.sort((left, right) => {
+                            for (const [index, order] of (expression.aggregateOrderBy ?? []).entries()) {
+                                const a = left.order[index];
+                                const b = right.order[index];
+                                const placed = nullOrder(a, b, order.nulls, order.direction);
+                                if (placed !== undefined && placed !== 0)
+                                    return placed;
+                                const compared = compareValues(a, b);
+                                if (compared !== 0)
+                                    return order.direction === "desc" ? -compared : compared;
+                            }
+                            return 0;
+                        });
+                    }
+                    if (members.length === 0)
+                        return null;
+                    return protectedSqlTextValue(members
+                        .map((member, index) => index === 0
+                        ? String(externalSqlDomainValue(member.value))
+                        : String(externalSqlDomainValue(member.delimiter)) +
+                            String(externalSqlDomainValue(member.value)))
+                        .join(""));
+                }
                 let values = argument.kind === "wildcard"
                     ? group.map(() => 1)
-                    : group
-                        .map((row) => evaluate(argument, row))
-                        .filter((value) => value !== null && value !== undefined);
+                    : group.map((row) => evaluate(argument, row));
+                if (expression.name !== "JSON_ARRAYAGG") {
+                    values = values.filter((value) => value !== null && value !== undefined);
+                }
                 if (expression.distinct === true) {
                     const seen = new Set();
                     values = values.filter((value) => {
@@ -3019,13 +3542,19 @@ function evaluate(expression, context, group) {
                 if (expression.name === "COUNT")
                     return values.length;
                 if (expression.name === "SUM")
+                    return values.length === 0 ? null : sumNumericValues(values);
+                if (expression.name === "AVG")
                     return values.length === 0
                         ? null
-                        : values.reduce((sum, value) => sum + numeric(value), 0);
-                if (expression.name === "AVG")
+                        : (() => {
+                            const sum = sumNumericValues(values);
+                            return exactNumericBinary("/", sum, values.length) ?? numeric(sum) / values.length;
+                        })();
+                if (expression.name === "JSON_ARRAYAGG") {
                     return values.length === 0
                         ? null
-                        : values.reduce((sum, value) => sum + numeric(value), 0) / values.length;
+                        : JSON.stringify(values.map((value) => jsonValueOf(value ?? null)));
+                }
                 if (expression.name === "MIN")
                     return values.reduce((best, value) => (best === undefined || compareValues(value, best) < 0 ? value : best), undefined);
                 return values.reduce((best, value) => (best === undefined || compareValues(value, best) > 0 ? value : best), undefined);
@@ -3052,7 +3581,9 @@ function evaluatePredicate(predicate, context) {
     if (predicate.operator === "LIKE" ||
         predicate.operator === "NOT LIKE" ||
         predicate.operator === "ILIKE" ||
-        predicate.operator === "NOT ILIKE") {
+        predicate.operator === "NOT ILIKE" ||
+        predicate.operator === "SIMILAR TO" ||
+        predicate.operator === "NOT SIMILAR TO") {
         return (evaluateBooleanExpression({
             kind: "condition",
             operator: predicate.operator,
@@ -3271,7 +3802,7 @@ export function distinctFromComparison(left, right) {
     const rightNull = right === null || right === undefined;
     if (leftNull || rightNull)
         return leftNull !== rightNull;
-    return comparable(left) !== comparable(right);
+    return compareValues(comparable(left), comparable(right)) !== 0;
 }
 /**
  * Evaluates a boolean expression tree with SQL three-valued logic: comparisons over NULL are
@@ -3344,17 +3875,24 @@ export function evaluateBooleanExpression(expression, evaluateValue) {
         if (operator === "LIKE" ||
             operator === "NOT LIKE" ||
             operator === "ILIKE" ||
-            operator === "NOT ILIKE") {
-            const value = evaluateValue(expression.left);
-            const pattern = evaluateValue(expression.right);
+            operator === "NOT ILIKE" ||
+            operator === "SIMILAR TO" ||
+            operator === "NOT SIMILAR TO") {
+            const value = externalSqlDomainValue(evaluateValue(expression.left));
+            const pattern = externalSqlDomainValue(evaluateValue(expression.right));
             if (value === null || value === undefined || pattern === null || pattern === undefined) {
                 return null;
             }
             if (typeof value !== "string" || typeof pattern !== "string") {
                 throw new TypeError("LIKE requires string operands");
             }
-            const matched = likeMatches(pattern, value, operator === "ILIKE" || operator === "NOT ILIKE", expression.escape);
-            return operator === "LIKE" || operator === "ILIKE" ? matched : !matched;
+            const similar = operator === "SIMILAR TO" || operator === "NOT SIMILAR TO";
+            const matched = similar
+                ? compileSimilarPattern(pattern, expression.escape ?? "\\").test(value)
+                : likeMatches(pattern, value, operator === "ILIKE" || operator === "NOT ILIKE", expression.escape);
+            return operator === "LIKE" || operator === "ILIKE" || operator === "SIMILAR TO"
+                ? matched
+                : !matched;
         }
         if (operator === "IS DISTINCT FROM" || operator === "IS NOT DISTINCT FROM") {
             const distinct = distinctFromComparison(evaluateValue(expression.left), evaluateValue(expression.right));
@@ -3367,9 +3905,9 @@ export function evaluateBooleanExpression(expression, evaluateValue) {
         const a = comparable(left);
         const b = comparable(right);
         if (operator === "=")
-            return a === b;
+            return compareValues(a, b) === 0;
         if (operator === "!=" || operator === "<>")
-            return a !== b;
+            return compareValues(a, b) !== 0;
         const comparison = compareValues(a, b);
         if (operator === ">")
             return comparison > 0;
@@ -3401,7 +3939,11 @@ function comparisonHolds(operator, leftValue, rightValue) {
     if (operator === "LIKE" ||
         operator === "NOT LIKE" ||
         operator === "ILIKE" ||
-        operator === "NOT ILIKE") {
+        operator === "NOT ILIKE" ||
+        operator === "SIMILAR TO" ||
+        operator === "NOT SIMILAR TO") {
+        leftValue = externalSqlDomainValue(leftValue);
+        rightValue = externalSqlDomainValue(rightValue);
         if (leftValue === null ||
             leftValue === undefined ||
             rightValue === null ||
@@ -3411,8 +3953,13 @@ function comparisonHolds(operator, leftValue, rightValue) {
         if (typeof leftValue !== "string" || typeof rightValue !== "string") {
             throw new TypeError("LIKE requires string operands");
         }
-        const matched = likeMatches(rightValue, leftValue, operator === "ILIKE" || operator === "NOT ILIKE");
-        return operator === "LIKE" || operator === "ILIKE" ? matched : !matched;
+        const similar = operator === "SIMILAR TO" || operator === "NOT SIMILAR TO";
+        const matched = similar
+            ? compileSimilarPattern(rightValue).test(leftValue)
+            : likeMatches(rightValue, leftValue, operator === "ILIKE" || operator === "NOT ILIKE");
+        return operator === "LIKE" || operator === "ILIKE" || operator === "SIMILAR TO"
+            ? matched
+            : !matched;
     }
     if (leftValue === null ||
         leftValue === undefined ||
@@ -3422,9 +3969,9 @@ function comparisonHolds(operator, leftValue, rightValue) {
     const left = comparable(leftValue);
     const right = comparable(rightValue);
     if (operator === "=")
-        return left === right;
+        return compareValues(left, right) === 0;
     if (operator === "!=" || operator === "<>")
-        return left !== right;
+        return compareValues(left, right) !== 0;
     const comparison = compareValues(left, right);
     if (operator === ">")
         return comparison > 0;
@@ -3503,7 +4050,7 @@ function validateGrouping(plan) {
     for (const item of plan.select) {
         if (hasAggregate(item.expression))
             continue;
-        // A constant expression is the same for every group, as standard SQL allows. A full-text
+        // A constant expression is the same for every group, as PostgreSQL allows. A full-text
         // node is never constant — MATCH(*) carries no column children before expansion, but it
         // reads every searchable column of its row.
         if (expressionColumns(item.expression).length === 0 &&
@@ -3543,27 +4090,37 @@ function comparable(value) {
     return value instanceof Date ? value.getTime() : value;
 }
 /**
- * Resolves an explicit NULLS FIRST/LAST placement for one order term. Returns undefined when
- * no explicit placement applies (either none was requested or neither side is NULL); otherwise
- * the signed placement, which is absolute — direction negation must not apply to it. Two NULLs
- * return 0 so the comparison falls through to the next term.
+ * Resolves NULL placement for one order term. An omitted placement follows PostgreSQL: NULLS LAST
+ * for ASC and NULLS FIRST for DESC. Returns undefined when neither side is NULL; otherwise the
+ * signed placement is absolute, so direction negation must not apply to it. Two NULLs return 0
+ * so comparison falls through to the next term.
  */
-export function explicitNullOrder(left, right, nulls) {
-    if (nulls === undefined)
-        return undefined;
+export function nullOrder(left, right, nulls, direction) {
     const leftNull = left === null || left === undefined;
     const rightNull = right === null || right === undefined;
     if (!leftNull && !rightNull)
         return undefined;
     if (leftNull && rightNull)
         return 0;
-    return (leftNull ? -1 : 1) * (nulls === "first" ? 1 : -1);
+    const placement = nulls ?? (direction === "desc" ? "first" : "last");
+    return (leftNull ? -1 : 1) * (placement === "first" ? 1 : -1);
 }
 function numeric(value) {
     if (typeof value !== "number")
         throw new TypeError("Arithmetic and numeric aggregates require numbers");
     return value;
 }
+function sumNumericValues(values) {
+    let total = values[0];
+    if (total === undefined)
+        return null;
+    for (let index = 1; index < values.length; index += 1) {
+        const value = values[index];
+        const exact = exactNumericBinary("+", total, value);
+        total = exact === undefined ? numeric(total) + numeric(value) : exact;
+    }
+    return total;
+}
 function asQueryValue(value) {
     if (value === null ||
         typeof value === "boolean" ||
@@ -3575,6 +4132,83 @@ function asQueryValue(value) {
         return null;
     throw new TypeError("Query produced an unsupported value");
 }
+function asExternalQueryValue(value) {
+    return asQueryValue(externalSqlDomainValue(value));
+}
+const alreadyExternalResults = new WeakSet();
+function markExternalizationState(result, outputNeedsExternalization) {
+    if (outputNeedsExternalization === false)
+        alreadyExternalResults.add(result);
+    return result;
+}
+/** Carries the internal no-conversion proof across a defensive result copy. */
+export function copyQueryResultExternalization(source, copy) {
+    if (alreadyExternalResults.has(source))
+        alreadyExternalResults.add(copy);
+    return copy;
+}
+/** Removes internal domain tags only after every comparison, group, join, and sort is complete. */
+export function externalizeQueryResult(result) {
+    if (alreadyExternalResults.has(result))
+        return result;
+    let changed = false;
+    const rows = new Array(result.rows.length);
+    for (let rowIndex = 0; rowIndex < result.rows.length; rowIndex += 1) {
+        const row = result.rows[rowIndex] ?? {};
+        let output = row;
+        // Ordinary primitive results are already public values. Most queries never touch one of the
+        // tagged PostgreSQL domains, so keep their row objects and avoid rebuilding a large result
+        // set merely to discover that every value is unchanged.
+        for (const name of result.columns) {
+            const value = row[name];
+            if (value !== undefined && !isSqlDomainValue(value))
+                continue;
+            const external = asExternalQueryValue(value);
+            if (external === value)
+                continue;
+            if (output === row)
+                output = { ...row };
+            output[name] = external;
+            changed = true;
+        }
+        rows[rowIndex] = output;
+    }
+    const externalized = changed ? { columns: [...result.columns], 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.
+    alreadyExternalResults.add(externalized);
+    return externalized;
+}
+/** Gives bare conflict-update columns the target-row meaning SQL assigns them. */
+function rewriteUpsertExpression(expression, table) {
+    if (hasAggregate(expression)) {
+        throw new TypeError("ON CONFLICT DO UPDATE expressions cannot contain aggregates");
+    }
+    const rewrite = (node) => {
+        if (node.kind === "column") {
+            const parts = node.reference.split(".");
+            if (parts.length === 1)
+                return { ...node, reference: `${table}.${node.reference}` };
+            if (parts.length === 2 && parts[0]?.toUpperCase() === "EXCLUDED") {
+                return { ...node, reference: `EXCLUDED.${parts[1] ?? ""}` };
+            }
+            if (parts.length === 2 && parts[0]?.toUpperCase() === table.toUpperCase()) {
+                return { ...node, reference: `${table}.${parts[1] ?? ""}` };
+            }
+            return node;
+        }
+        if (node.kind === "subquery" ||
+            node.kind === "exists" ||
+            node.kind === "window" ||
+            node.kind === "fts" ||
+            node.kind === "wildcard") {
+            throw new TypeError("ON CONFLICT DO UPDATE expressions use target and EXCLUDED scalar values only");
+        }
+        return mapChildExpressions(node, rewrite);
+    };
+    return rewrite(expression);
+}
 class Parser {
     tokens;
     /** The statement text the tokens came from, for the clauses stored verbatim (CHECK bodies). */
@@ -3586,6 +4220,10 @@ class Parser {
     #highestNumberedParameter = 0;
     /** Set when the statement names CURRENT_DATE, CURRENT_TIMESTAMP, or LOCALTIME. */
     usesStatementDatetime = false;
+    /** Set when the statement names NEXTVAL or CURRVAL. */
+    usesSequenceCalls = false;
+    /** Set when the statement names a volatile scalar function. */
+    usesVolatileFunctions = false;
     /** Total parameter slots the statement expects; 0 when it has no placeholders. */
     get parameterCount() {
         return Math.max(this.#positionalParameters, this.#highestNumberedParameter);
@@ -3697,7 +4335,7 @@ class Parser {
                     this.#ctes.set(name, block);
             }
         }
-        // INTERSECT binds tighter than UNION and EXCEPT, per the SQL standard.
+        // INTERSECT binds tighter than UNION and EXCEPT, matching PostgreSQL.
         const firstTerm = this.#setTerm(sql);
         let plan = firstTerm.block;
         if (this.#isKeyword("UNION") || this.#isKeyword("EXCEPT")) {
@@ -3755,7 +4393,7 @@ class Parser {
                 throw new TypeError("ORDER BY or LIMIT in a UNION member requires parentheses");
             }
         }
-        // Standard SQL assigns a trailing ORDER BY or LIMIT to the whole compound. After an
+        // PostgreSQL assigns a trailing ORDER BY or LIMIT to the whole compound. After an
         // unparenthesized last member the clause was greedily parsed into that member and lifts
         // out; after a parenthesized member it is still unparsed.
         const last = members[members.length - 1];
@@ -3784,10 +4422,53 @@ class Parser {
         }
         return compoundSelectBlock(sql, members.map((member) => member.block), ops, tail, this.nextDerivedSequence);
     }
+    /** CREATE [UNIQUE] INDEX name ON table(column [ASC|DESC], ...). */
+    parseCreateIndex() {
+        this.#keyword("CREATE");
+        const unique = this.#isKeyword("UNIQUE");
+        if (unique)
+            this.#keyword("UNIQUE");
+        this.#keyword("INDEX");
+        let ifNotExists = false;
+        if (this.#isKeyword("IF")) {
+            this.#keyword("IF");
+            this.#keyword("NOT");
+            this.#keyword("EXISTS");
+            ifNotExists = true;
+        }
+        const index = this.#identifier();
+        this.#keyword("ON");
+        const table = this.#identifier();
+        this.#expectPunctuation("(");
+        const columns = [];
+        do {
+            if (columns.length > 0)
+                this.#expectPunctuation(",");
+            const name = this.#identifier();
+            let direction = "asc";
+            if (this.#isKeyword("ASC"))
+                this.#keyword("ASC");
+            else if (this.#isKeyword("DESC")) {
+                this.#keyword("DESC");
+                direction = "desc";
+            }
+            columns.push({ name, direction });
+        } while (this.#peek().text === ",");
+        this.#expectPunctuation(")");
+        this.#take("eof");
+        return {
+            kind: "create-index",
+            index,
+            table,
+            columns,
+            ...(unique ? { unique: true } : {}),
+            ...(ifNotExists ? { ifNotExists: true } : {}),
+        };
+    }
     /**
      * CREATE TABLE name (col TYPE [PRIMARY KEY | UNIQUE] [NOT NULL | NULL], ...). Standard type
-     * names map onto the engine's four logical types; widths in parentheses parse and are
-     * ignored, because numeric widths and encodings are the engine's job, not schema choices.
+     * names map onto the engine's four logical types. Integer spellings retain an exact-domain
+     * catalog guard; exact NUMERIC/DECIMAL is rejected until it has a distinct physical type.
      */
     parseCreateTable() {
         this.#keyword("CREATE");
@@ -3816,9 +4497,28 @@ class Parser {
         const columns = [];
         const checks = [];
         const foreignKeys = [];
-        let uniqueKey;
+        const uniqueConstraints = [];
+        let primaryKey;
+        const constraintColumns = () => {
+            this.#expectPunctuation("(");
+            const names = [];
+            for (;;) {
+                names.push(this.#identifier());
+                if (!this.#punctuation(","))
+                    break;
+            }
+            this.#expectPunctuation(")");
+            if (new Set(names).size !== names.length) {
+                throw new TypeError("Constraint columns must be unique");
+            }
+            return names;
+        };
         for (;;) {
-            if (this.#isKeyword("CONSTRAINT") || this.#isKeyword("CHECK") || this.#isKeyword("FOREIGN")) {
+            if (this.#isKeyword("CONSTRAINT") ||
+                this.#isKeyword("CHECK") ||
+                this.#isKeyword("FOREIGN") ||
+                this.#isKeyword("PRIMARY") ||
+                this.#isKeyword("UNIQUE")) {
                 // A table-level constraint, named or not.
                 let constraintName;
                 if (this.#isKeyword("CONSTRAINT")) {
@@ -3828,59 +4528,50 @@ class Parser {
                 if (this.#isKeyword("FOREIGN")) {
                     this.#keyword("FOREIGN");
                     this.#keyword("KEY");
-                    this.#expectPunctuation("(");
-                    const column = this.#identifier();
-                    if (this.#peek().text === ",") {
-                        throw new TypeError("FOREIGN KEY supports one column, the parent's unique key");
-                    }
-                    this.#expectPunctuation(")");
-                    foreignKeys.push(this.#references(constraintName ?? `${table}_${column}_fkey`, column));
+                    const names = constraintColumns();
+                    foreignKeys.push(this.#references(constraintName ?? `${table}_${names.join("_")}_fkey`, names));
                     if (!this.#punctuation(","))
                         break;
                     continue;
                 }
-                if (!this.#isKeyword("CHECK")) {
-                    throw new TypeError("Table constraints are CHECK and FOREIGN KEY");
-                }
-                checks.push(this.#checkConstraint(constraintName ?? `${table}_check_${String(checks.length + 1)}`));
-                if (!this.#punctuation(","))
-                    break;
-                continue;
-            }
-            if (this.#isKeyword("PRIMARY") || this.#isKeyword("UNIQUE")) {
-                // E141-08: the table-level spelling of the same single-column key.
                 if (this.#isKeyword("PRIMARY")) {
                     this.#keyword("PRIMARY");
                     this.#keyword("KEY");
+                    if (primaryKey !== undefined)
+                        throw new TypeError("CREATE TABLE has two PRIMARY KEYs");
+                    primaryKey = constraintColumns();
+                    if (!this.#punctuation(","))
+                        break;
+                    continue;
                 }
-                else
+                if (this.#isKeyword("UNIQUE")) {
                     this.#keyword("UNIQUE");
-                this.#expectPunctuation("(");
-                const keyColumn = this.#identifier();
-                if (this.#peek().text === ",") {
-                    throw new TypeError("CREATE TABLE supports one unique key column");
+                    const names = constraintColumns();
+                    uniqueConstraints.push({
+                        name: constraintName ?? `${table}_${names.join("_")}_key`,
+                        columns: names,
+                    });
+                    if (!this.#punctuation(","))
+                        break;
+                    continue;
                 }
-                this.#expectPunctuation(")");
-                if (uniqueKey !== undefined && uniqueKey !== keyColumn) {
-                    throw new TypeError("CREATE TABLE supports one unique key column");
+                if (!this.#isKeyword("CHECK")) {
+                    throw new TypeError("Expected PRIMARY KEY, UNIQUE, CHECK, or FOREIGN KEY");
                 }
-                uniqueKey = keyColumn;
+                checks.push(this.#checkConstraint(constraintName ?? `${table}_check_${String(checks.length + 1)}`));
                 if (!this.#punctuation(","))
                     break;
                 continue;
             }
             const name = this.#identifier();
-            const type = this.#columnType();
+            const columnType = this.#columnType();
             let nullable = true;
-            let explicitlyNullable = false;
             let defaultValue;
             for (;;) {
                 if (this.#isKeyword("DEFAULT")) {
-                    // E141-07. The catalog fills defaults at insert time, so they are constants: a
-                    // literal, or the CURRENT_TIMESTAMP family, which it stores as "now".
+                    // PostgreSQL-compatible variable-free scalar expression, retained in the catalog.
                     this.#keyword("DEFAULT");
-                    const expression = this.#expression();
-                    defaultValue = columnDefaultFor(expression);
+                    defaultValue = this.#columnDefault();
                     continue;
                 }
                 if (this.#isKeyword("CHECK")) {
@@ -3888,22 +4579,22 @@ class Parser {
                     continue;
                 }
                 if (this.#isKeyword("REFERENCES")) {
-                    foreignKeys.push(this.#references(`${table}_${name}_fkey`, name));
+                    foreignKeys.push(this.#references(`${table}_${name}_fkey`, [name]));
                     continue;
                 }
                 if (this.#isKeyword("PRIMARY") || this.#isKeyword("UNIQUE")) {
                     if (this.#isKeyword("PRIMARY")) {
                         this.#keyword("PRIMARY");
                         this.#keyword("KEY");
+                        if (primaryKey !== undefined)
+                            throw new TypeError("CREATE TABLE has two PRIMARY KEYs");
+                        primaryKey = [name];
+                        nullable = false;
                     }
                     else {
                         this.#keyword("UNIQUE");
+                        uniqueConstraints.push({ name: `${table}_${name}_key`, columns: [name] });
                     }
-                    if (uniqueKey !== undefined) {
-                        throw new TypeError("CREATE TABLE supports one unique key column");
-                    }
-                    uniqueKey = name;
-                    nullable = false;
                     continue;
                 }
                 if (this.#isKeyword("NOT")) {
@@ -3919,19 +4610,13 @@ class Parser {
                 if (this.#isKeyword("NULL")) {
                     this.#keyword("NULL");
                     nullable = true;
-                    explicitlyNullable = true;
                     continue;
                 }
                 break;
             }
-            // A default answers what an absent value means, so the column cannot also be nullable
-            // unless the author says so — and then the engine rejects the pair, since NULL and the
-            // default would both claim the same slot.
-            if (defaultValue !== undefined && !explicitlyNullable)
-                nullable = false;
             columns.push({
                 name,
-                type,
+                ...columnType,
                 ...(nullable ? { nullable: true } : {}),
                 ...(defaultValue === undefined ? {} : { defaultValue }),
             });
@@ -3943,10 +4628,14 @@ class Parser {
         if (new Set(columns.map((column) => column.name)).size !== columns.length) {
             throw new TypeError("CREATE TABLE column names must be unique");
         }
-        if (uniqueKey !== undefined && !columns.some((column) => column.name === uniqueKey)) {
-            throw new TypeError(`CREATE TABLE key column is not declared: ${uniqueKey}`);
-        }
         const declared = new Set(columns.map((column) => column.name));
+        for (const name of [
+            ...(primaryKey ?? []),
+            ...uniqueConstraints.flatMap((key) => key.columns),
+        ]) {
+            if (!declared.has(name))
+                throw new TypeError(`Constraint column is not declared: ${name}`);
+        }
         for (const check of checks) {
             for (const reference of expressionColumnNames(compileCheckExpression(check.sql, check.name))) {
                 const column = reference.split(".").at(-1) ?? reference;
@@ -3955,11 +4644,24 @@ class Parser {
                 }
             }
         }
+        // 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
+            ? uniqueConstraints.shift()
+            : undefined;
+        const uniqueKey = primaryKey?.length === 1 ? primaryKey[0] : promotedUnique?.columns[0];
+        const primaryNames = new Set(primaryKey ?? []);
         return {
             kind: "create-table",
             table,
-            columns: columns.map((column) => column.name === uniqueKey ? { ...column, nullable: false } : column),
+            columns: columns.map((column) => column.name === uniqueKey || primaryNames.has(column.name)
+                ? { ...column, nullable: false }
+                : column),
             ...(uniqueKey === undefined ? {} : { uniqueKey }),
+            ...(primaryKey === undefined || primaryKey.length < 2
+                ? {}
+                : { compositePrimaryKey: primaryKey }),
+            ...(uniqueConstraints.length === 0 ? {} : { uniqueConstraints }),
             ...(checks.length === 0 ? {} : { checks }),
             ...(foreignKeys.length === 0 ? {} : { foreignKeys }),
             ...(ifNotExists ? { ifNotExists: true } : {}),
@@ -3970,14 +4672,22 @@ class Parser {
      * key cannot change in this engine, so ON UPDATE has nothing to act on and only the
      * no-op actions parse; ON DELETE takes the three the engine can carry out.
      */
-    #references(name, column) {
+    #references(name, columns) {
         this.#keyword("REFERENCES");
         const parentTable = this.#identifier();
-        let parentColumn;
+        let parentColumns;
         if (this.#punctuation("(")) {
-            parentColumn = this.#identifier();
+            parentColumns = [];
+            for (;;) {
+                parentColumns.push(this.#identifier());
+                if (!this.#punctuation(","))
+                    break;
+            }
             this.#expectPunctuation(")");
         }
+        if (parentColumns !== undefined && parentColumns.length !== columns.length) {
+            throw new TypeError("FOREIGN KEY and REFERENCES must name the same number of columns");
+        }
         let onDelete = "restrict";
         while (this.#isKeyword("ON")) {
             this.#keyword("ON");
@@ -3994,9 +4704,10 @@ class Parser {
         }
         return {
             name,
-            column,
+            column: columns[0] ?? "",
+            ...(columns.length === 1 ? {} : { columns }),
             parentTable,
-            ...(parentColumn === undefined ? {} : { parentColumn }),
+            ...(parentColumns === undefined ? {} : { parentColumn: parentColumns[0], parentColumns }),
             onDelete,
         };
     }
@@ -4046,6 +4757,15 @@ class Parser {
         this.#take("eof");
         return expression;
     }
+    /** Reads one column DEFAULT while preserving its authored SQL for catalog introspection. */
+    #columnDefault() {
+        const start = this.#peek().start;
+        const expression = this.#expression();
+        const sql = this.text.slice(start, this.#peek().start).trim();
+        if (sql.length === 0)
+            throw new TypeError("DEFAULT requires an expression");
+        return columnDefaultFor(expression, sql);
+    }
     /** DROP VIEW [IF EXISTS] name (F031-16). */
     parseDropView() {
         this.#keyword("DROP");
@@ -4062,6 +4782,20 @@ class Parser {
         this.#take("eof");
         return { kind: "drop-view", view, ...(ifExists ? { ifExists: true } : {}) };
     }
+    /** DROP INDEX [IF EXISTS] name. */
+    parseDropIndex() {
+        this.#keyword("DROP");
+        this.#keyword("INDEX");
+        let ifExists = false;
+        if (this.#isKeyword("IF")) {
+            this.#keyword("IF");
+            this.#keyword("EXISTS");
+            ifExists = true;
+        }
+        const index = this.#identifier();
+        this.#take("eof");
+        return { kind: "drop-index", index, ...(ifExists ? { ifExists: true } : {}) };
+    }
     /** DROP TABLE [IF EXISTS] name (F031-13). */
     parseDropTable() {
         this.#keyword("DROP");
@@ -4083,22 +4817,46 @@ class Parser {
         this.#take("eof");
         return { kind: "drop-table", table, ...(ifExists ? { ifExists: true } : {}) };
     }
-    /** ALTER TABLE name ADD [COLUMN] col TYPE [NOT NULL] [DEFAULT v] (F031-04). */
+    /** ALTER TABLE name ADD/DROP [COLUMN] (F031). */
     parseAlterTable() {
         this.#keyword("ALTER");
         this.#keyword("TABLE");
         const table = this.#identifier();
+        if (this.#isKeyword("DROP")) {
+            this.#keyword("DROP");
+            if (this.#isKeyword("COLUMN"))
+                this.#keyword("COLUMN");
+            let ifExists = false;
+            if (this.#isKeyword("IF")) {
+                this.#keyword("IF");
+                this.#keyword("EXISTS");
+                ifExists = true;
+            }
+            const column = this.#identifier();
+            if (this.#isKeyword("RESTRICT"))
+                this.#keyword("RESTRICT");
+            else if (this.#isKeyword("CASCADE")) {
+                throw new TypeError("ALTER TABLE DROP COLUMN CASCADE is not supported; drop dependents explicitly");
+            }
+            this.#take("eof");
+            return {
+                kind: "drop-column",
+                table,
+                column,
+                ...(ifExists ? { ifExists: true } : {}),
+            };
+        }
         this.#keyword("ADD");
         if (this.#isKeyword("COLUMN"))
             this.#keyword("COLUMN");
         const name = this.#identifier();
-        const type = this.#columnType();
+        const columnType = this.#columnType();
         let nullable = true;
         let defaultValue;
         for (;;) {
             if (this.#isKeyword("DEFAULT")) {
                 this.#keyword("DEFAULT");
-                defaultValue = columnDefaultFor(this.#expression());
+                defaultValue = this.#columnDefault();
                 continue;
             }
             if (this.#isKeyword("NOT")) {
@@ -4120,7 +4878,7 @@ class Parser {
             table,
             column: {
                 name,
-                type,
+                ...columnType,
                 ...(nullable ? { nullable: true } : {}),
                 ...(defaultValue === undefined ? {} : { defaultValue }),
             },
@@ -4129,6 +4887,22 @@ class Parser {
     /** A CAST target: the SqlColumnType, or "number-integer" for the truncating integer names. */
     #castTarget() {
         const word = this.#identifier().toUpperCase();
+        if (word === "NUMERIC" || word === "DECIMAL") {
+            let precision;
+            let scale;
+            if (this.#punctuation("(")) {
+                precision = Number(this.#take("number").text);
+                if (this.#punctuation(","))
+                    scale = Number(this.#take("number").text);
+                else
+                    scale = 0;
+                this.#expectPunctuation(")");
+            }
+            return `numeric:${precision === undefined ? "" : String(precision)}:${scale === undefined ? "" : String(scale)}`;
+        }
+        if (["JSON", "JSONB", "UUID", "TIME", "INTERVAL"].includes(word)) {
+            return word.toLowerCase();
+        }
         if (word === "DOUBLE") {
             this.#keyword("PRECISION");
             return "number";
@@ -4146,22 +4920,50 @@ class Parser {
         return integer ? "number-integer" : mapped;
     }
     #columnType() {
-        const word = this.#identifier().toUpperCase();
+        const declared = this.#identifier();
+        const word = declared.toUpperCase();
+        if (word === "NUMERIC" || word === "DECIMAL") {
+            let precision;
+            let scale;
+            if (this.#punctuation("(")) {
+                precision = Number(this.#take("number").text);
+                scale = this.#punctuation(",") ? Number(this.#take("number").text) : 0;
+                this.#expectPunctuation(")");
+            }
+            return {
+                type: "string",
+                sqlDomain: {
+                    kind: "numeric",
+                    ...(precision === undefined ? {} : { precision }),
+                    ...(scale === undefined ? {} : { scale }),
+                },
+            };
+        }
+        if (["JSON", "JSONB", "UUID", "TIME", "INTERVAL"].includes(word)) {
+            return { type: "string", sqlDomain: { kind: word.toLowerCase() } };
+        }
         if (word === "DOUBLE") {
             this.#keyword("PRECISION");
-            return "number";
+            return { type: "number" };
         }
         const mapped = createTableTypeNames.get(word);
-        if (mapped === undefined)
-            throw new TypeError(`Unsupported column type: ${word}`);
-        // A width like VARCHAR(80) or NUMERIC(10, 2) parses and is discarded.
+        if (mapped === undefined) {
+            return { type: "string", sqlDomain: { kind: "enum", name: declared, values: [] } };
+        }
+        // Character widths document intent and do not truncate values.
         if (this.#punctuation("(")) {
             this.#take("number");
-            if (this.#punctuation(","))
-                this.#take("number");
+            if (this.#punctuation(",")) {
+                throw new TypeError(`${word} takes one width`);
+            }
             this.#expectPunctuation(")");
         }
-        return mapped;
+        if (this.#punctuation("[")) {
+            this.#expectPunctuation("]");
+            return { type: "string", sqlDomain: { kind: "array", element: word } };
+        }
+        const integer = word === "INTEGER" || word === "INT" || word === "BIGINT" || word === "SMALLINT";
+        return { type: mapped, ...(integer ? { integer: true } : {}) };
     }
     parseMutation(keyword) {
         const statement = keyword === "INSERT"
@@ -4176,23 +4978,37 @@ class Parser {
         this.#keyword("INSERT");
         this.#keyword("INTO");
         const table = this.#identifier();
-        this.#expectPunctuation("(");
         const columns = [];
-        for (;;) {
-            columns.push(this.#identifier());
-            if (!this.#punctuation(","))
-                break;
+        if (this.#punctuation("(")) {
+            for (;;) {
+                columns.push(this.#identifier());
+                if (!this.#punctuation(","))
+                    break;
+            }
+            this.#expectPunctuation(")");
         }
-        this.#expectPunctuation(")");
         if (new Set(columns).size !== columns.length) {
             throw new TypeError("INSERT columns must be unique");
         }
+        if (this.#isKeyword("DEFAULT")) {
+            this.#keyword("DEFAULT");
+            this.#keyword("VALUES");
+            return {
+                kind: "insert",
+                table,
+                columns,
+                rows: [[]],
+                defaultValues: true,
+                ...this.#onConflictClause(table),
+                ...this.#returningClause(),
+            };
+        }
         if (this.#isKeyword("SELECT")) {
             const query = optimizePlan(this.#selectBlock("(insert select)"));
             if (query.select.some((item) => item.expression.kind === "wildcard")) {
                 throw new TypeError("INSERT ... SELECT requires an explicit select list");
             }
-            if (query.select.length !== columns.length) {
+            if (columns.length > 0 && query.select.length !== columns.length) {
                 throw new TypeError("INSERT ... SELECT must produce exactly the insert column count");
             }
             return {
@@ -4215,7 +5031,7 @@ class Parser {
                     break;
             }
             this.#expectPunctuation(")");
-            if (values.length !== columns.length) {
+            if (columns.length > 0 && values.length !== columns.length) {
                 throw new TypeError("Each INSERT row must match the column list length");
             }
             rows.push(values);
@@ -4227,55 +5043,72 @@ class Parser {
             table,
             columns,
             rows,
-            ...this.#onConflictClause(columns),
+            ...this.#onConflictClause(table),
             ...this.#returningClause(),
         };
     }
-    #onConflictClause(columns) {
+    #onConflictClause(table) {
         if (!this.#isKeyword("ON"))
             return {};
         this.#keyword("ON");
         this.#keyword("CONFLICT");
         this.#expectPunctuation("(");
-        const column = this.#identifier();
+        const columns = [];
+        for (;;) {
+            columns.push(this.#identifier());
+            if (!this.#punctuation(","))
+                break;
+        }
         this.#expectPunctuation(")");
+        const column = columns[0];
+        if (column === undefined)
+            throw new TypeError("ON CONFLICT needs at least one column");
+        const target = columns.length === 1 ? {} : { columns };
         this.#keyword("DO");
         if (this.#isKeyword("NOTHING")) {
             this.#keyword("NOTHING");
-            return { onConflict: { column, action: "nothing" } };
+            return { onConflict: { column, ...target, action: "nothing" } };
+        }
+        // Minnow's concise whole-row upsert spelling. Unlike DO UPDATE SET, it also has an exact
+        // meaning for a table whose unique key is its only column.
+        if (this.#isKeyword("REPLACE")) {
+            this.#keyword("REPLACE");
+            return { onConflict: { column, ...target, action: "replace" } };
         }
         this.#keyword("UPDATE");
         this.#keyword("SET");
         const assigned = new Set();
+        const assignments = [];
         for (;;) {
             const target = this.#identifier();
             this.#operator("=");
-            const value = this.#expression();
-            const parts = value.kind === "column" ? value.reference.split(".") : [];
-            if (parts.length !== 2 || parts[0]?.toUpperCase() !== "EXCLUDED" || parts[1] !== target) {
-                throw new TypeError("ON CONFLICT DO UPDATE supports assignments of the form column = EXCLUDED.column");
-            }
             if (assigned.has(target)) {
                 throw new TypeError(`ON CONFLICT DO UPDATE sets a column twice: ${target}`);
             }
-            if (target === column) {
+            if (columns.includes(target)) {
                 throw new TypeError("ON CONFLICT DO UPDATE cannot reassign the conflict key");
             }
             assigned.add(target);
+            assignments.push({
+                column: target,
+                expression: rewriteUpsertExpression(this.#expression(), table),
+            });
             if (!this.#punctuation(","))
                 break;
         }
-        for (const name of assigned) {
-            if (!columns.includes(name)) {
-                throw new TypeError(`ON CONFLICT DO UPDATE sets a column that is not inserted: ${name}`);
-            }
+        let where;
+        if (this.#isKeyword("WHERE")) {
+            this.#keyword("WHERE");
+            where = rewriteUpsertExpression(this.#expression(), table);
         }
-        // Every inserted column assigned is a whole-row upsert; a subset merges into existing rows.
-        const complete = columns.every((name) => name === column || assigned.has(name));
         return {
-            onConflict: complete
-                ? { column, action: "replace" }
-                : { column, action: "update", columns: [...assigned] },
+            onConflict: {
+                column,
+                ...target,
+                action: "update",
+                assignments,
+                ...(where === undefined ? {} : { where }),
+            },
         };
     }
     /** RETURNING * or RETURNING col, ... — the engine's runStatement implements the semantics. */
@@ -4463,6 +5296,10 @@ class Parser {
         return predicates;
     }
     #insertValue(label) {
+        if (this.#isKeyword("DEFAULT")) {
+            this.#keyword("DEFAULT");
+            return { default: true };
+        }
         const expression = this.#expression();
         // A bare placeholder stays a slot; the batch write binds it later. Placeholders nested in
         // arithmetic would need expression retention through the batch path, so they stay rejected.
@@ -4907,14 +5744,18 @@ class Parser {
     }
     #selectList() {
         const items = [];
+        const explicitAliases = [];
         for (;;) {
             const expression = this.#expression();
             let alias = defaultAlias(expression);
+            let explicitAlias = false;
             if (this.#isKeyword("AS")) {
                 this.#keyword("AS");
                 alias = this.#identifier();
+                explicitAlias = true;
             }
             items.push({ expression, alias });
+            explicitAliases.push(explicitAlias);
             if (!this.#punctuation(","))
                 break;
         }
@@ -4923,15 +5764,23 @@ class Parser {
             throw new TypeError("SELECT * cannot be mixed with other expressions");
         }
         const aliases = new Set();
-        for (const item of items) {
+        for (const [index, item] of items.entries()) {
             if (item.expression.kind === "list") {
                 throw new TypeError("A row constructor is only allowed in a comparison or IN list");
             }
             // A qualified wildcard has no single output name until expansion resolves its columns.
             if (item.expression.kind === "wildcard" && item.expression.table !== undefined)
                 continue;
-            if (aliases.has(item.alias))
-                throw new TypeError(`Duplicate output column: ${item.alias}`);
+            if (aliases.has(item.alias)) {
+                if (explicitAliases[index] === true) {
+                    throw new TypeError(`Duplicate output column: ${item.alias}`);
+                }
+                const base = item.alias;
+                let suffix = 2;
+                while (aliases.has(`${base}_${String(suffix)}`))
+                    suffix++;
+                item.alias = `${base}_${String(suffix)}`;
+            }
             aliases.add(item.alias);
         }
         return items;
@@ -5087,15 +5936,126 @@ class Parser {
             return this.#derivedSource(derived, alias);
         }
         const table = this.#identifier();
+        if (table.toUpperCase() === "LATERAL") {
+            this.#expectPunctuation("(");
+            const derived = this.#queryExpression("(lateral)");
+            this.#expectPunctuation(")");
+            const alias = this.#sourceAlias();
+            if (alias === undefined)
+                throw new TypeError("A LATERAL derived table requires an alias");
+            if (this.#punctuation("("))
+                this.#applyColumnAliases(derived);
+            return { ...this.#derivedSource(derived, alias), lateral: true };
+        }
         if (this.#peek().text === "(") {
             // Two row-producing sources the executors have no operator for; both parse far enough to
             // say so, rather than failing on the punctuation that follows.
             const upper = table.toUpperCase();
-            if (upper === "LATERAL") {
-                throw new TypeError("LATERAL sources are not supported");
-            }
             if (upper === "JSON_TABLE") {
-                throw new TypeError("JSON_TABLE is not supported; JSON_VALUE and JSON_QUERY read one value");
+                this.#expectPunctuation("(");
+                const document = this.#expression();
+                if (containsParameter(document) ||
+                    expressionColumns(document).length > 0 ||
+                    hasAggregate(document)) {
+                    throw new TypeError("JSON_TABLE currently requires a constant document");
+                }
+                this.#expectPunctuation(",");
+                const rowPath = this.#take("string").text;
+                this.#keyword("COLUMNS");
+                this.#expectPunctuation("(");
+                const columns = [];
+                for (;;) {
+                    const name = this.#identifier();
+                    const columnType = this.#columnType();
+                    this.#keyword("PATH");
+                    columns.push({ name, ...columnType, path: this.#take("string").text });
+                    if (!this.#punctuation(","))
+                        break;
+                }
+                this.#expectPunctuation(")");
+                this.#expectPunctuation(")");
+                const alias = this.#sourceAlias();
+                if (alias === undefined)
+                    throw new TypeError("JSON_TABLE requires an alias");
+                const raw = externalSqlDomainValue(evaluate(document, {}));
+                if (typeof raw !== "string")
+                    throw new TypeError("JSON_TABLE document must be JSON text");
+                let parsed;
+                try {
+                    parsed = JSON.parse(raw);
+                }
+                catch {
+                    throw new TypeError("JSON_TABLE document is invalid JSON");
+                }
+                const members = rowPath === "$"
+                    ? [parsed]
+                    : rowPath === "$[*]" && Array.isArray(parsed)
+                        ? parsed
+                        : (() => {
+                            throw new TypeError("JSON_TABLE row path supports $ and $[*]");
+                        })();
+                const blockFor = (member, empty = false) => ({
+                    sql: "(json table row)",
+                    base: { table: DUAL_TABLE, alias: DUAL_TABLE },
+                    joins: [],
+                    select: columns.map((column) => {
+                        const selected = jsonAtPath(JSON.stringify(member), column.path, "JSON_TABLE");
+                        const value = empty
+                            ? column.sqlDomain?.kind === "numeric"
+                                ? jsonTableColumnValue(column, 0)
+                                : column.type === "number"
+                                    ? 0
+                                    : column.type === "boolean"
+                                        ? false
+                                        : column.type === "datetime"
+                                            ? new Date(0)
+                                            : ""
+                            : jsonTableColumnValue(column, selected.found ? selected.value : null);
+                        return {
+                            expression: {
+                                kind: "literal",
+                                value,
+                                ...(column.sqlDomain === undefined
+                                    ? {}
+                                    : { internalSqlValue: true, sqlDomain: column.sqlDomain }),
+                            },
+                            alias: column.name,
+                        };
+                    }),
+                    predicates: empty
+                        ? [
+                            {
+                                left: { kind: "literal", value: false },
+                                operator: "IS TRUE",
+                                right: { kind: "literal", value: true },
+                            },
+                        ]
+                        : [],
+                    groupBy: [],
+                    having: [],
+                    orderBy: [],
+                });
+                const blocks = members.length === 0 ? [blockFor(null, true)] : members.map((member) => blockFor(member));
+                const firstBlock = blocks[0];
+                if (firstBlock === undefined)
+                    throw new TypeError("JSON_TABLE requires a row source");
+                const derived = blocks.length === 1
+                    ? firstBlock
+                    : {
+                        sql: "(json table)",
+                        base: {
+                            table: `(json table ${String(this.nextDerivedSequence())})`,
+                            alias: "json_table",
+                            union: { blocks, ops: blocks.slice(1).map(() => "union all") },
+                        },
+                        joins: [],
+                        select: [{ expression: { kind: "wildcard" }, alias: "*" }],
+                        predicates: [],
+                        groupBy: [],
+                        having: [],
+                        orderBy: [],
+                    };
+                return this.#derivedSource(derived, alias);
             }
         }
         const candidate = this.#recursiveCandidate;
@@ -5385,14 +6345,13 @@ class Parser {
         // After a value expression, NOT can only introduce NOT BETWEEN / NOT IN / NOT LIKE.
         let negated = false;
         if (this.#isKeyword("NOT")) {
+            const next = this.tokens[this.#index + 1];
+            const nextWord = next?.kind === "identifier" && next.quoted !== true ? next.text.toUpperCase() : "";
+            // In a column definition, `DEFAULT <expression> NOT NULL` ends the expression here.
+            if (!["BETWEEN", "IN", "LIKE", "ILIKE", "SIMILAR"].includes(nextWord))
+                return left;
             this.#keyword("NOT");
             negated = true;
-            if (!this.#isKeyword("BETWEEN") &&
-                !this.#isKeyword("IN") &&
-                !this.#isKeyword("LIKE") &&
-                !this.#isKeyword("ILIKE")) {
-                throw new TypeError(`Expected BETWEEN, IN, LIKE, or ILIKE after NOT`);
-            }
         }
         if (this.#isKeyword("BETWEEN")) {
             this.#keyword("BETWEEN");
@@ -5469,6 +6428,26 @@ class Parser {
                 ...(escape === undefined ? {} : { escape }),
             };
         }
+        if (this.#isKeyword("SIMILAR")) {
+            this.#keyword("SIMILAR");
+            this.#keyword("TO");
+            const pattern = this.#additive();
+            let escape;
+            if (this.#isKeyword("ESCAPE")) {
+                this.#keyword("ESCAPE");
+                escape = this.#take("string").text;
+                if (Array.from(escape).length !== 1) {
+                    throw new TypeError("SIMILAR TO ESCAPE takes a single character");
+                }
+            }
+            return {
+                kind: "condition",
+                operator: negated ? "NOT SIMILAR TO" : "SIMILAR TO",
+                left,
+                right: pattern,
+                ...(escape === undefined ? {} : { escape }),
+            };
+        }
         const token = this.#peek();
         if (token.kind === "operator" && ["=", "!=", "<>", ">", ">=", "<", "<="].includes(token.text)) {
             const operator = this.#comparison();
@@ -5495,6 +6474,15 @@ class Parser {
     #additive(minimumPrecedence = 0) {
         let left = this.#primary();
         for (;;) {
+            if (this.#isKeyword("COLLATE")) {
+                this.#keyword("COLLATE");
+                left = {
+                    kind: "call",
+                    name: "MINNOW_COLLATE",
+                    arguments: [left, { kind: "literal", value: this.#identifier() }],
+                };
+                continue;
+            }
             const operator = this.#peek().text;
             // || binds loosest, matching PostgreSQL: concatenation applies to whole arithmetic terms.
             const precedence = operator === "*" || operator === "/" || operator === "%"
@@ -5559,7 +6547,11 @@ class Parser {
             return this.#parameterExpression();
         if (token.kind === "number") {
             this.#index += 1;
-            return { kind: "literal", value: Number(token.text) };
+            const value = Number(token.text);
+            if (!token.text.includes(".") && !Number.isSafeInteger(value)) {
+                throw new SqlCompileError(`Integer literal is outside the exact safe range: ${token.text}`, token.start, token.end - token.start);
+            }
+            return { kind: "literal", value };
         }
         if (token.kind === "string") {
             this.#index += 1;
@@ -5804,6 +6796,30 @@ class Parser {
         if ((upper === "TIMESTAMP" || upper === "DATETIME") && this.#peek().kind === "string") {
             return { kind: "literal", value: timestampLiteral(this.#take("string").text) };
         }
+        if (upper === "TIME" && this.#peek().kind === "string") {
+            return {
+                kind: "literal",
+                value: timeDomainValue(this.#take("string").text),
+                internalSqlValue: true,
+                sqlDomain: { kind: "time" },
+            };
+        }
+        if (upper === "INTERVAL" && this.#peek().kind === "string") {
+            return {
+                kind: "literal",
+                value: intervalDomainValue(this.#take("string").text),
+                internalSqlValue: true,
+                sqlDomain: { kind: "interval" },
+            };
+        }
+        if (upper === "ARRAY" && this.#punctuation("[")) {
+            const arguments_ = [];
+            if (!this.#punctuation("]")) {
+                arguments_.push(...this.#expressionList());
+                this.#expectPunctuation("]");
+            }
+            return { kind: "call", name: "ARRAY", arguments: arguments_ };
+        }
         if (this.#punctuation("(")) {
             if (upper === "ROW_NUMBER" ||
                 upper === "RANK" ||
@@ -5936,8 +6952,15 @@ class Parser {
             // canonical plan names. ANY_VALUE picks an implementation-dependent row of the group
             // (T626); MIN is one such choice and reuses its accumulator exactly.
             const name = (upper === "ANY_VALUE" ? "MIN" : (functionSpellings.get(upper) ?? upper));
+            if (name === "MINNOW_TUPLE_KEY" || name === "MINNOW_COLLATE") {
+                throw new TypeError(`Unsupported function: ${identifier}`);
+            }
             if (!aggregateNames.has(name) && !scalarFunctionNames.has(name))
                 throw new TypeError(`Unsupported function: ${identifier}`);
+            if (name === "NEXTVAL" || name === "CURRVAL")
+                this.usesSequenceCalls = true;
+            if (volatileScalarFunctionNames.has(name))
+                this.usesVolatileFunctions = true;
             let distinct = false;
             if (this.#isKeyword("DISTINCT")) {
                 if (!aggregateNames.has(name)) {
@@ -5951,15 +6974,32 @@ class Parser {
                 this.#keyword("ALL");
             }
             const args = [];
+            let aggregateOrderBy;
             if (!this.#punctuation(")")) {
-                args.push(...this.#expressionList());
+                if (name === "STRING_AGG") {
+                    args.push(this.#expression());
+                    this.#expectPunctuation(",");
+                    args.push(this.#expression());
+                    if (this.#isKeyword("ORDER"))
+                        aggregateOrderBy = this.#orderByClause();
+                }
+                else {
+                    args.push(...this.#expressionList());
+                }
                 this.#expectPunctuation(")");
             }
-            if (distinct && (args.length !== 1 || args[0]?.kind === "wildcard")) {
+            const distinctArity = name === "STRING_AGG" ? 2 : 1;
+            if (distinct && (args.length !== distinctArity || args[0]?.kind === "wildcard")) {
                 throw new TypeError(`${name}(DISTINCT) requires exactly one scalar argument`);
             }
-            if (aggregateNames.has(name) && args.length !== 1)
+            if (name === "STRING_AGG" && args.length !== 2) {
+                throw new TypeError("STRING_AGG requires a value and delimiter");
+            }
+            if (aggregateNames.has(name) && name !== "STRING_AGG" && args.length !== 1)
                 throw new TypeError(`${name} requires exactly one argument`);
+            if (name === "JSON_ARRAYAGG" && args[0]?.kind === "wildcard") {
+                throw new TypeError("JSON_ARRAYAGG requires a scalar value expression");
+            }
             if (name === "ROUND" && (args.length < 1 || args.length > 2))
                 throw new TypeError("ROUND requires one or two arguments");
             if (name === "COALESCE" && args.length < 1)
@@ -5988,6 +7028,9 @@ class Parser {
             if (statementDatetimeNames.has(name) && args.length !== 0) {
                 throw new TypeError(`${name} takes no arguments`);
             }
+            if (volatileScalarFunctionNames.has(name) && args.length !== 0) {
+                throw new TypeError(`${name} takes no arguments`);
+            }
             if ((name === "JSON_VALUE" || name === "JSON_QUERY" || name === "JSON_EXISTS") &&
                 args.length !== 2) {
                 throw new TypeError(`${name} requires a JSON document and a path`);
@@ -6028,6 +7071,9 @@ class Parser {
                 }
             }
             if (aggregateNames.has(name) && this.#isKeyword("FILTER")) {
+                if (name === "JSON_ARRAYAGG") {
+                    throw new TypeError("JSON_ARRAYAGG FILTER is not supported; filter rows in WHERE");
+                }
                 // FILTER (WHERE cond) desugars into the aggregate's argument: rows failing the filter
                 // contribute NULL, which every aggregate skips — COUNT(*) counts a CASE over 1.
                 this.#keyword("FILTER");
@@ -6048,6 +7094,12 @@ class Parser {
                 });
             }
             if (aggregateNames.has(name) && this.#isKeyword("OVER")) {
+                if (name === "JSON_ARRAYAGG") {
+                    throw new TypeError("JSON_ARRAYAGG window use is not supported");
+                }
+                if (name === "STRING_AGG") {
+                    throw new TypeError("STRING_AGG window use is not supported");
+                }
                 if (distinct)
                     throw new TypeError("DISTINCT window aggregates are not supported");
                 this.#keyword("OVER");
@@ -6065,7 +7117,13 @@ class Parser {
                     ...(frame === undefined ? {} : { frame }),
                 };
             }
-            return { kind: "call", name, arguments: args, ...(distinct ? { distinct: true } : {}) };
+            return {
+                kind: "call",
+                name,
+                arguments: args,
+                ...(distinct ? { distinct: true } : {}),
+                ...(aggregateOrderBy === undefined ? {} : { aggregateOrderBy }),
+            };
         }
         let reference = identifier;
         if (this.#punctuation(".")) {
@@ -6655,7 +7713,9 @@ export function expandDistinctWildcard(plan, columnsOf) {
         if (columns === undefined || columns.length === 0) {
             throw new TypeError(`SELECT DISTINCT * requires known columns for: ${source.table}`);
         }
-        return columns.map((name) => {
+        return columns
+            .filter((name) => !name.startsWith("\0"))
+            .map((name) => {
             const output = multiple ? `${source.alias}.${name}` : name;
             return { expression: { kind: "column", reference: output }, alias: output };
         });
@@ -6669,16 +7729,20 @@ export function expandDistinctWildcard(plan, columnsOf) {
  * table's columns positionally (E051-09). The table's own column order is only known here, so
  * the parser records the names and this pass — one per execution entry — applies them.
  */
-/** Whether any block of the plan reads a table name the catalog answers with a view. */
-export function planReadsViews(plan, isView) {
-    if ([plan.base, ...plan.joins].some((source) => source.derived === undefined && isView(source.table)))
+/** Whether any block of the plan reads a table accepted by the supplied catalog predicate. */
+export function planReadsTable(plan, matches) {
+    if ([plan.base, ...plan.joins].some((source) => source.derived === undefined && matches(source.table)))
         return true;
     let nested = false;
     forEachNestedBlock(plan, (inner) => {
-        nested ||= planReadsViews(inner, isView);
+        nested ||= planReadsTable(inner, matches);
     });
     return nested;
 }
+/** Whether any block of the plan reads a table name the catalog answers with a view. */
+export function planReadsViews(plan, isView) {
+    return planReadsTable(plan, isView);
+}
 /**
  * Replaces every reference to a view with the query it stands for, as a derived table under the
  * reference's own alias (F031-02). A view whose body reads another view expands too, up to a
@@ -6778,11 +7842,13 @@ export function withTiesPlan(plan) {
  */
 function sourceWildcardColumns(source, columnsOf) {
     if (source.derived !== undefined)
-        return source.derived.select.map((item) => item.alias);
+        return source.derived.select.map((item) => item.alias).filter((name) => !name.startsWith("\0"));
     if (source.union !== undefined) {
-        return source.union.blocks[0]?.select.map((item) => item.alias);
+        return source.union.blocks[0]?.select
+            .map((item) => item.alias)
+            .filter((name) => !name.startsWith("\0"));
     }
-    return columnsOf(source.table);
+    return columnsOf(source.table)?.filter((name) => !name.startsWith("\0"));
 }
 /** Whether any block of the plan still carries an unresolved NATURAL join marker. */
 export function planHasNaturalJoins(plan) {
@@ -7104,7 +8170,7 @@ export function transparentProjectionSource(plan) {
 }
 /** Projects a result to a wrapper's visible aliases, preserving row order. */
 export function projectResultColumns(result, aliases) {
-    return {
+    return copyQueryResultExternalization(result, {
         columns: [...aliases],
         rows: result.rows.map((row) => {
             const projected = {};
@@ -7112,7 +8178,7 @@ export function projectResultColumns(result, aliases) {
                 projected[alias] = row[alias] ?? null;
             return projected;
         }),
-    };
+    });
 }
 /** Names a derived (subquery or expanded CTE) source under the shared sequence. */
 export function derivedTableSource(derived, alias, nextSequence) {
@@ -7146,6 +8212,43 @@ function renameBlockOutputs(block, columns, name) {
  * writes a T and leaves the time off entirely for midnight. A literal without a zone is UTC, the
  * same reading `DATE` already takes and the same one every datetime in a Minnow database has.
  */
+function jsonTableColumnValue(column, value) {
+    if (value === null || value === undefined)
+        return null;
+    if (column.sqlDomain !== undefined) {
+        const input = column.sqlDomain.kind === "array" && typeof value !== "string"
+            ? JSON.stringify(value)
+            : value;
+        return normalizeSqlDomainValue(column.sqlDomain, input);
+    }
+    if (column.type === "string") {
+        return typeof value === "string" ? value : JSON.stringify(value);
+    }
+    if (column.type === "boolean") {
+        if (typeof value !== "boolean")
+            throw new TypeError("JSON_TABLE boolean column needs a boolean");
+        return value;
+    }
+    if (column.type === "number") {
+        const number = typeof value === "number" ? value : Number(value);
+        if (!Number.isFinite(number) || (column.integer === true && !Number.isSafeInteger(number))) {
+            throw new TypeError("JSON_TABLE numeric column has an invalid value");
+        }
+        return number;
+    }
+    let date;
+    if (value instanceof Date)
+        date = value;
+    else if (typeof value === "string")
+        date = new Date(value);
+    else if (typeof value === "number")
+        date = new Date(value);
+    else
+        throw new TypeError("JSON_TABLE datetime is invalid");
+    if (!Number.isFinite(date.getTime()))
+        throw new TypeError("JSON_TABLE datetime is invalid");
+    return date;
+}
 export function timestampLiteral(text) {
     const trimmed = text.trim();
     const match = /^(\d{4}-\d{2}-\d{2})(?:[ T](\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?))?(Z|[+-]\d{2}:?\d{2})?$/.exec(trimmed);
@@ -7465,7 +8568,7 @@ function tokenize(sql) {
         }
         if (["+", "-", "*", "/", "%", "=", ">", "<"].includes(character))
             tokens.push({ kind: "operator", text: character, start: index, end: index + 1 });
-        else if (["(", ")", ",", "."].includes(character))
+        else if (["(", ")", "[", "]", ",", "."].includes(character))
             tokens.push({ kind: "punctuation", text: character, start: index, end: index + 1 });
         else
             throw new SqlCompileError(`Unsupported SQL character: ${character}`, index, 1);