@minnowdb/core 0.6.8 → 0.7.0

package/dist/engine/query.js

@@ -1,4 +1,4 @@
-import { copyDate, dateIsoString, dateMilliseconds, dateUtcDate, dateUtcDay, dateUtcFullYear, dateUtcHours, dateUtcMinutes, dateUtcMonth, dateUtcSeconds, setDateUtcDate, setDateUtcMonth, } from "../date-value.js";
+import { civilFromDays, copyDate, dateIsoString, dateMilliseconds, daysFromCivil, epochDays, dateUtcDate, dateUtcFullYear, dateUtcMonth, setDateUtcDate, setDateUtcMonth, } from "../date-value.js";
 import { crossJoinPlan } from "../plan/model.js";
 import { assertWellFormedString, wellFormedUtf8ByteLength } from "../block-format/unicode.js";
 import { MAX_SQL_NESTING_DEPTH, MAX_SQL_PARAMETERS, MAX_SQL_SCALAR_RESULT_CHARACTERS, MAX_SQL_TEXT_CHARACTERS, MAX_SQL_TOKENS, } from "./cache-limits.js";
@@ -6,7 +6,8 @@ import { SqlCompileError } from "./errors.js";
 import { cachedQueryTerms, ftsBm25Row, FtsStatsAccumulator, ftsMatchTruth, renderDocumentValue, tokenize as ftsTokenize, validateFtsQuery, } from "./fts.js";
 import { QueryMemoryContext } from "./memory.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
-import { stringArgument } from "./sql-semantics.js";
+import { coerceComparisonOperands, coercedComparable, parseSqlTimestampText, stringArgument, } from "./sql-semantics.js";
+import { simpleScalarFunctions } from "./sql-functions.js";
 import { jsonArrowStep, jsonAtPath, jsonConstructor, jsonIsValid, parseJsonPath, } from "./sql-json.js";
 import { optimizePlan } from "./optimizer.js";
 import { compareSqlValues as compareValues, compileLikePattern, compileSimilarPattern, encodeSqlEqualityValue, roundSqlNumber, } from "./sql-semantics.js";
@@ -71,6 +72,7 @@ export const scalarFunctionNames = new Set([
     "CURRVAL",
     "RANDOM",
     "GEN_RANDOM_UUID",
+    ...Array.from(simpleScalarFunctions.keys()),
 ]);
 /** Functions whose answer can change without any catalog or input-row change. */
 export const volatileScalarFunctionNames = new Set([
@@ -95,6 +97,8 @@ const statementDatetimeNames = new Set([
 /** Standard function spellings that share one canonical plan name. */
 const functionSpellings = new Map([
     ["SUBSTRING", "SUBSTR"],
+    // DATE_PART('field', value) is EXTRACT(field FROM value) with the field as a string.
+    ["DATE_PART", "EXTRACT"],
     ["CEILING", "CEIL"],
     ["CHAR_LENGTH", "LENGTH"],
     ["CHARACTER_LENGTH", "LENGTH"],
@@ -103,6 +107,8 @@ const statementDatetimeAliases = new Map([
     ["CURRENT_DATE", "CURRENT_DATE"],
     ["CURRENT_TIMESTAMP", "CURRENT_TIMESTAMP"],
     ["LOCALTIMESTAMP", "CURRENT_TIMESTAMP"],
+    // PostgreSQL's now() is transaction_timestamp(): one reading per statement, like the rest.
+    ["NOW", "CURRENT_TIMESTAMP"],
     ["CURRENT_TIME", "LOCALTIME"],
     ["LOCALTIME", "LOCALTIME"],
 ]);
@@ -190,7 +196,10 @@ function castValue(value, target) {
         if (parsed !== undefined) {
             if (target !== "number-integer")
                 return parsed;
-            const integer = Math.trunc(parsed);
+            // PostgreSQL rounds a double precision value cast to an integer type to the nearest
+            // integer, ties to even (2.5 -> 2, 3.5 -> 4, -2.5 -> -2); SQLite truncates. A stored
+            // number is double precision, so the engine follows PostgreSQL's float8 cast.
+            const integer = roundHalfToEven(parsed);
             if (!Number.isSafeInteger(integer)) {
                 throw new RangeError(`Integer cast is outside the exact safe range: ${String(value)}`);
             }
@@ -222,7 +231,7 @@ function castValue(value, target) {
             return value;
         const external = externalSqlDomainValue(value);
         if (typeof external === "string" || typeof external === "number") {
-            const parsed = new Date(external);
+            const parsed = typeof external === "string" ? datetimeText(external) : new Date(external);
             if (Number.isFinite(dateMilliseconds(parsed)))
                 return parsed;
             throw new TypeError(`Cannot cast this value to a datetime: ${String(value)}`);
@@ -230,6 +239,16 @@ function castValue(value, target) {
     }
     throw new TypeError(`Unsupported CAST: ${typeof value} to ${target}`);
 }
+/** Nearest integer with ties to even, the rounding PostgreSQL applies to float8 -> integer. */
+function roundHalfToEven(value) {
+    const floor = Math.floor(value);
+    const fraction = value - floor;
+    if (fraction < 0.5)
+        return floor;
+    if (fraction > 0.5)
+        return floor + 1;
+    return floor % 2 === 0 ? floor : floor + 1;
+}
 /**
  * Evaluates one scalar function over already-evaluated argument values. Every executor calls
  * through here, so a function behaves identically in the row executor, the vectorized executor,
@@ -238,6 +257,97 @@ function castValue(value, target) {
  * SUBSTR count characters, not UTF-16 units, matching SQLite and PostgreSQL.
  */
 export function scalarFunctionValue(name, values) {
+    return scalarFunctionEvaluator(name)(values);
+}
+const scalarFunctionEvaluators = new Map();
+/**
+ * The evaluator for one function name, resolved once. A call site that keeps the evaluator
+ * skips the name dispatch on every row; the registry functions and the hottest built-ins get
+ * a closure of their own, everything else a closure over the general dispatch.
+ */
+export function scalarFunctionEvaluator(name) {
+    let evaluator = scalarFunctionEvaluators.get(name);
+    if (evaluator === undefined) {
+        evaluator = buildScalarFunctionEvaluator(name);
+        scalarFunctionEvaluators.set(name, evaluator);
+    }
+    return evaluator;
+}
+function anyNull(values) {
+    for (const value of values)
+        if (value === null || value === undefined)
+            return true;
+    return false;
+}
+function buildScalarFunctionEvaluator(name) {
+    const simple = simpleScalarFunctions.get(name);
+    if (simple !== undefined) {
+        return simple.nullOnNull === false
+            ? simple.evaluate
+            : (values) => (anyNull(values) ? null : simple.evaluate(values));
+    }
+    // The specialised closures below repeat the general dispatch's rules for their name: a NULL
+    // first argument is NULL, then the case body. Names are disjoint, so the earlier name checks
+    // in scalarFunctionValueGeneric can never claim one of these.
+    switch (name) {
+        case "DATE_TRUNC":
+            return (values) => dateTruncValue(values[0], values[1]);
+        case "EXTRACT":
+            return (values) => {
+                const first = values[0];
+                if (first === null || first === undefined)
+                    return null;
+                return extractDatePart(typeof first === "string" ? first : "", values[1]);
+            };
+        case "ROUND":
+            return (values) => {
+                const first = values[0];
+                if (first === null || first === undefined)
+                    return null;
+                if (values.length > 1 && (values[1] === null || values[1] === undefined))
+                    return null;
+                const digits = values.length > 1 ? numeric(values[1]) : 0;
+                if (isExactNumeric(first) && Number.isInteger(digits) && digits >= 0) {
+                    return exactNumericValue(first, undefined, digits);
+                }
+                return roundSqlNumber(numeric(first), digits);
+            };
+        case "FLOOR":
+            return (values) => values[0] === null || values[0] === undefined ? null : Math.floor(numeric(values[0]));
+        case "CEIL":
+            return (values) => values[0] === null || values[0] === undefined ? null : Math.ceil(numeric(values[0]));
+        case "ABS":
+            return (values) => values[0] === null || values[0] === undefined ? null : Math.abs(numeric(values[0]));
+        case "UPPER":
+            return (values) => {
+                const first = values[0];
+                if (first === null || first === undefined)
+                    return null;
+                const source = stringArgument("UPPER", first);
+                assertScalarInputLength(source, "UPPER input");
+                return boundedScalarResult(source.toUpperCase(), "UPPER result");
+            };
+        case "LOWER":
+            return (values) => {
+                const first = values[0];
+                if (first === null || first === undefined)
+                    return null;
+                const source = stringArgument("LOWER", first);
+                assertScalarInputLength(source, "LOWER input");
+                return boundedScalarResult(source.toLowerCase(), "LOWER result");
+            };
+        case "LENGTH":
+            return (values) => {
+                const first = values[0];
+                if (first === null || first === undefined)
+                    return null;
+                return codePointLength(stringArgument("LENGTH", first));
+            };
+        default:
+            return (values) => scalarFunctionValueGeneric(name, values);
+    }
+}
+function scalarFunctionValueGeneric(name, values) {
     if (name === "GROUPING") {
         // T433. The grouping-sets desugar knows which columns each member aggregates away and
         // replaces every GROUPING call with its constant; reaching here means there was no
@@ -281,6 +391,14 @@ export function scalarFunctionValue(name, values) {
     if (name === "NEXTVAL" || name === "CURRVAL") {
         throw new TypeError(`${name} must be resolved by the database catalog`);
     }
+    const simple = simpleScalarFunctions.get(name);
+    if (simple !== undefined) {
+        if (simple.nullOnNull !== false &&
+            values.some((value) => value === null || value === undefined)) {
+            return null;
+        }
+        return simple.evaluate(values);
+    }
     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
@@ -358,6 +476,11 @@ export function scalarFunctionValue(name, values) {
             if (values.length > 1 && (values[1] === null || values[1] === undefined))
                 return null;
             const digits = values.length > 1 ? numeric(values[1]) : 0;
+            // An exact NUMERIC rounds exactly, to the requested scale, half away from zero as
+            // PostgreSQL's numeric ROUND does; a double takes the float path.
+            if (isExactNumeric(first) && Number.isInteger(digits) && digits >= 0) {
+                return exactNumericValue(first, undefined, digits);
+            }
             return roundSqlNumber(numeric(first), digits);
         }
         case "ABS":
@@ -691,45 +814,47 @@ function dateAddValue(value, months, milliseconds) {
         ? dateDomainValue(dateIsoString(result).slice(0, 10))
         : result;
 }
-function dateTruncValue(unit, value) {
+export function dateTruncValue(unit, value) {
     if (typeof unit !== "string" || !dateTruncUnits.has(unit.toLowerCase())) {
         throw new TypeError("DATE_TRUNC requires a unit of year, quarter, month, week, day, hour, minute, or second");
     }
     if (value === null || value === undefined)
         return null;
     const external = externalSqlDomainValue(value);
-    const input = value instanceof Date
-        ? value
+    const milliseconds = value instanceof Date
+        ? dateMilliseconds(value)
         : isDateDomainValue(value) && typeof external === "string"
-            ? new Date(`${external}T00:00:00.000Z`)
+            ? Date.parse(`${external}T00:00:00.000Z`)
             : undefined;
-    if (input === undefined)
+    if (milliseconds === undefined)
         throw new TypeError("DATE_TRUNC requires a date or datetime value");
+    if (!Number.isFinite(milliseconds))
+        return new Date(Number.NaN);
+    // Everything is UTC arithmetic on the epoch value: no Date is built until the answer, and the
+    // calendar fields come from the civil-date conversion rather than intrinsic getters.
     const normalized = unit.toLowerCase();
-    const year = dateUtcFullYear(input);
-    const month = dateUtcMonth(input);
-    const day = dateUtcDate(input);
-    switch (normalized) {
-        case "year":
-            return new Date(Date.UTC(year, 0, 1));
-        case "quarter":
-            return new Date(Date.UTC(year, Math.floor(month / 3) * 3, 1));
-        case "month":
-            return new Date(Date.UTC(year, month, 1));
-        case "week": {
-            const start = new Date(Date.UTC(year, month, day));
-            setDateUtcDate(start, dateUtcDate(start) - ((dateUtcDay(start) + 6) % 7));
-            return start;
-        }
-        case "day":
-            return new Date(Date.UTC(year, month, day));
-        case "hour":
-            return new Date(Date.UTC(year, month, day, dateUtcHours(input)));
-        case "minute":
-            return new Date(Date.UTC(year, month, day, dateUtcHours(input), dateUtcMinutes(input)));
-        default:
-            return new Date(Date.UTC(year, month, day, dateUtcHours(input), dateUtcMinutes(input), dateUtcSeconds(input)));
-    }
+    const day = 86_400_000;
+    if (normalized === "second")
+        return new Date(Math.floor(milliseconds / 1000) * 1000);
+    if (normalized === "minute")
+        return new Date(Math.floor(milliseconds / 60_000) * 60_000);
+    if (normalized === "hour")
+        return new Date(Math.floor(milliseconds / 3_600_000) * 3_600_000);
+    const days = epochDays(milliseconds);
+    if (normalized === "day")
+        return new Date(days * day);
+    if (normalized === "week") {
+        // 1970-01-01 was a Thursday; weeks start on Monday.
+        const weekday = (((days + 3) % 7) + 7) % 7;
+        return new Date((days - weekday) * day);
+    }
+    const [year, month] = civilFromDays(days);
+    if (normalized === "month")
+        return new Date(daysFromCivil(year, month, 1) * day);
+    if (normalized === "quarter") {
+        return new Date(daysFromCivil(year, Math.floor(month / 3) * 3, 1) * day);
+    }
+    return new Date(daysFromCivil(year, 0, 1) * day);
 }
 /** The output column type of one window: rankings and most aggregates count, MIN/MAX carry. */
 export function windowOutputType(window, innerSchema) {
@@ -890,7 +1015,11 @@ export function compileQuery(sql, options = {}) {
     let compiled;
     try {
         resolvePlanExactNumericConstants(plan);
-        compiled = options.optimize === false ? plan : optimizePlan(plan);
+        if (options.optimize === false && planHasPendingSelectShapes(plan)) {
+            plan.preserveUnoptimizedShape = true;
+        }
+        compiled =
+            options.optimize === false || planHasPendingSelectShapes(plan) ? plan : optimizePlan(plan);
     }
     catch (error) {
         // Compile-time rewrites (for example decorrelation) reject unsupported shapes; those
@@ -899,12 +1028,18 @@ export function compileQuery(sql, options = {}) {
     }
     if (parser.parameterCount > 0)
         compiled.parameterCount = parser.parameterCount;
-    if (parser.usesStatementDatetime)
-        compiled.usesStatementDatetime = true;
-    if (parser.usesSequenceCalls)
-        compiled.usesSequenceCalls = true;
-    if (parser.usesVolatileFunctions)
-        compiled.usesVolatileFunctions = true;
+    // The ORDER-BY-expression desugar wraps the parsed block in a projection, and execution paths
+    // run that inner block on its own. The flags have to travel with it, or CURRENT_TIMESTAMP in a
+    // WHERE clause would reach the executor unresolved whenever the query sorts by a hidden column.
+    const flagged = [compiled, transparentProjectionSource(compiled)?.inner].filter((block) => block !== undefined);
+    for (const block of flagged) {
+        if (parser.usesStatementDatetime)
+            block.usesStatementDatetime = true;
+        if (parser.usesSequenceCalls)
+            block.usesSequenceCalls = true;
+        if (parser.usesVolatileFunctions)
+            block.usesVolatileFunctions = true;
+    }
     return compiled;
 }
 /**
@@ -925,6 +1060,9 @@ function columnDefaultFor(expression, sql) {
 export function isDefaultInsertValue(value) {
     return (typeof value === "object" && value !== null && !(value instanceof Date) && "default" in value);
 }
+export function isDeferredInsertExpression(value) {
+    return (typeof value === "object" && value !== null && !(value instanceof Date) && "expression" in value);
+}
 /**
  * Parses CREATE TRIGGER name AFTER INSERT|UPDATE|DELETE ON table [FOR EACH ROW]
  * BEGIN insert; ... END. Body statements are INSERT ... VALUES with NEW.col / OLD.col
@@ -1914,6 +2052,11 @@ export function inferBlockSchema(plan, schemas) {
             return undefined;
         if (expression.name === "CURRENT_DATE")
             return { kind: "date" };
+        const simple = simpleScalarFunctions.get(expression.name);
+        if (simple?.returns === "date")
+            return { kind: "date" };
+        if (simple?.returns === "interval")
+            return { kind: "interval" };
         if (expression.name === "CAST") {
             const target = expression.arguments[1];
             return target?.kind === "literal" && typeof target.value === "string"
@@ -2016,11 +2159,10 @@ export function inferBlockSchema(plan, schemas) {
         }
         if (expression.kind === "binary") {
             if (expression.operator === "||") {
-                for (const side of [expression.left, expression.right]) {
-                    const type = infer(side);
-                    if (type !== "string" && type !== "null") {
-                        throw new TypeError("|| requires string operands");
-                    }
+                // PostgreSQL's text || anynonarray: one side must be text, the other renders as text.
+                const types = [expression.left, expression.right].map(infer);
+                if (!types.some((type) => type === "string" || type === "null")) {
+                    throw new TypeError("|| requires a string operand");
                 }
                 return "string";
             }
@@ -2072,6 +2214,15 @@ export function inferBlockSchema(plan, schemas) {
         }
         if (expression.name === "JSON_EXISTS" || expression.name === "IS_JSON")
             return "boolean";
+        const simple = simpleScalarFunctions.get(expression.name);
+        if (simple !== undefined) {
+            if (simple.returns === "argument") {
+                const argument = expression.arguments[0];
+                return argument === undefined ? "null" : infer(argument);
+            }
+            // DATE and INTERVAL results are logical domains carried as strings.
+            return simple.returns === "date" || simple.returns === "interval" ? "string" : simple.returns;
+        }
         if (expression.name === "DATE_TRUNC")
             return "datetime";
         if (expression.name === "DATE_ADD") {
@@ -2365,8 +2516,9 @@ function trimPreparedResults(prepared, trim) {
 }
 export function createPreparedQuery(plan, tables, options = {}) {
     assertTailParametersBound(plan);
-    validateGrouping(plan);
     plan = resolveStatementDatetimes(plan);
+    plan = bindPendingSelectShapes(plan, wildcardRowColumns(tables));
+    validateGrouping(plan);
     // The schema-dependent rewrites run before derived sources materialize, because both can
     // turn a scanned table into one more derived block.
     plan = expandSourceColumnAliases(plan, wildcardRowColumns(tables));
@@ -2411,16 +2563,17 @@ export function createPreparedQuery(plan, tables, options = {}) {
 /** Internal columnar entry point used after MinnowDatabase materializes a stable snapshot. */
 export function createPreparedColumnarQuery(plan, tables, memory = new QueryMemoryContext(), preparedOptions = {}) {
     plan = resolveStatementDatetimes(plan);
-    const ties = withTiesPlan(plan);
-    if (ties.plan !== plan) {
-        return trimPreparedResults(createPreparedColumnarQuery(ties.plan, tables, memory, preparedOptions), ties.trim);
-    }
     const columnarColumns = (tableName) => {
         const table = tables.get(tableName);
         return table === undefined
             ? undefined
             : [...table.columns.keys()].filter((name) => !name.startsWith("\0"));
     };
+    plan = bindPendingSelectShapes(plan, columnarColumns);
+    const ties = withTiesPlan(plan);
+    if (ties.plan !== plan) {
+        return trimPreparedResults(createPreparedColumnarQuery(ties.plan, tables, memory, preparedOptions), ties.trim);
+    }
     plan = expandSourceColumnAliases(plan, columnarColumns);
     plan = expandNaturalJoins(plan, columnarColumns);
     plan = expandQualifiedWildcards(plan, columnarColumns);
@@ -3691,8 +3844,9 @@ export function executeRowQuery(plan, tables) {
 }
 function executeRowQueryInternal(plan, tables, memory) {
     assertTailParametersBound(plan);
-    validateGrouping(plan);
     plan = resolveStatementDatetimes(plan);
+    plan = bindPendingSelectShapes(plan, wildcardRowColumns(tables));
+    validateGrouping(plan);
     plan = expandSourceColumnAliases(plan, wildcardRowColumns(tables));
     plan = expandNaturalJoins(plan, wildcardRowColumns(tables));
     plan = expandQualifiedWildcards(plan, wildcardRowColumns(tables));
@@ -4004,12 +4158,8 @@ function evaluate(expression, context, group) {
             const right = evaluate(expression.right, context, group);
             if (left === null || left === undefined || right === null || right === undefined)
                 return null;
-            if (expression.operator === "||") {
-                if (typeof left !== "string" || typeof right !== "string") {
-                    throw new TypeError("|| requires string operands");
-                }
+            if (expression.operator === "||")
                 return concatenatedSqlValue(left, right);
-            }
             const exact = exactNumericBinary(expression.operator, left, right);
             if (exact !== undefined)
                 return exact;
@@ -4202,6 +4352,11 @@ function evaluatePredicate(predicate, context) {
                 return false;
             if (membership.set.has(comparable(value)))
                 return predicate.operator === "IN";
+            // A typed value beside text members reads them in its own type (`id IN ('1', '2')`),
+            // which the hashed set cannot see; the per-item path coerces as comparisons do.
+            if (typeof value !== "string" && membership.hasText) {
+                return inListHolds(predicate.operator, value, predicate.right.items.map((item) => evaluate(item, context)));
+            }
             return predicate.operator === "NOT IN" && !membership.hasNull;
         }
         return inListHolds(predicate.operator, evaluate(predicate.left, context), predicate.right.items.map((item) => evaluate(item, context)));
@@ -4230,7 +4385,8 @@ function inListHolds(operator, value, items) {
             hasNull = true;
             continue;
         }
-        if (comparable(value) === comparable(item))
+        const member = typeof item === "string" && typeof value !== "string" ? coercedComparable(item, value) : item;
+        if (comparable(value) === comparable(member))
             return operator === "IN";
     }
     return operator === "NOT IN" && !hasNull;
@@ -4249,13 +4405,17 @@ export function cachedListMembership(node, items) {
         if (items.every((item) => item.kind === "literal")) {
             const set = new Set();
             let hasNull = false;
+            let hasText = false;
             for (const item of items) {
                 if (item.value === null || item.value === undefined)
                     hasNull = true;
-                else
+                else {
+                    if (typeof item.value === "string")
+                        hasText = true;
                     set.add(comparable(item.value));
+                }
             }
-            cached = { set, hasNull };
+            cached = { set, hasNull, hasText };
         }
         else {
             cached = null;
@@ -4275,6 +4435,14 @@ const extractFields = new Set([
     "second",
     "epoch",
     "dow",
+    "doy",
+    "isodow",
+    "isoyear",
+    "decade",
+    "century",
+    "millennium",
+    "milliseconds",
+    "microseconds",
 ]);
 /**
  * EXTRACT(field FROM datetime), in UTC. `week` is the ISO 8601 week number and `dow` counts
@@ -4287,34 +4455,73 @@ function extractDatePart(field, value) {
     }
     if (value === null || value === undefined)
         return null;
-    if (!(value instanceof Date))
-        throw new TypeError("EXTRACT requires a datetime value");
+    let milliseconds;
+    if (value instanceof Date)
+        milliseconds = dateMilliseconds(value);
+    else {
+        // A DATE value is a midnight instant for every field; other text is not a datetime.
+        const external = isDateDomainValue(value) ? externalSqlDomainValue(value) : undefined;
+        if (typeof external !== "string")
+            throw new TypeError("EXTRACT requires a datetime value");
+        milliseconds = Date.parse(`${external}T00:00:00.000Z`);
+    }
+    if (!Number.isFinite(milliseconds))
+        return Number.NaN;
+    if (normalized === "epoch")
+        return milliseconds / 1000;
+    // Time-of-day fields are modular arithmetic on the epoch value; calendar fields come from the
+    // civil-date conversion of the day count. No Date is allocated on this path.
+    const day = 86_400_000;
+    const days = epochDays(milliseconds);
+    const timeOfDay = milliseconds - days * day;
     switch (normalized) {
-        case "year":
-            return dateUtcFullYear(value);
-        case "quarter":
-            return Math.floor(dateUtcMonth(value) / 3) + 1;
-        case "month":
-            return dateUtcMonth(value) + 1;
-        case "week": {
-            const date = new Date(Date.UTC(dateUtcFullYear(value), dateUtcMonth(value), dateUtcDate(value)));
-            // ISO week: shift to the Thursday of this week, then count weeks from January 1st.
-            setDateUtcDate(date, dateUtcDate(date) + 4 - (dateUtcDay(date) || 7));
-            const yearStart = Date.UTC(dateUtcFullYear(date), 0, 1);
-            return Math.ceil(((dateMilliseconds(date) - yearStart) / 86_400_000 + 1) / 7);
-        }
-        case "day":
-            return dateUtcDate(value);
         case "hour":
-            return dateUtcHours(value);
+            return Math.floor(timeOfDay / 3_600_000);
         case "minute":
-            return dateUtcMinutes(value);
+            return Math.floor(timeOfDay / 60_000) % 60;
         case "second":
-            return dateUtcSeconds(value);
-        case "epoch":
-            return dateMilliseconds(value) / 1000;
+            return Math.floor(timeOfDay / 1000) % 60;
+        case "milliseconds":
+            return timeOfDay % 60_000;
+        case "microseconds":
+            return (timeOfDay % 60_000) * 1000;
+        case "dow":
+            return (((days + 4) % 7) + 7) % 7;
+        case "isodow": {
+            const dow = (((days + 4) % 7) + 7) % 7;
+            return dow === 0 ? 7 : dow;
+        }
         default:
-            return dateUtcDay(value);
+            break;
+    }
+    const [year, month, dayOfMonth] = civilFromDays(days);
+    switch (normalized) {
+        case "year":
+            return year;
+        case "month":
+            return month + 1;
+        case "day":
+            return dayOfMonth;
+        case "quarter":
+            return Math.floor(month / 3) + 1;
+        case "doy":
+            return days - daysFromCivil(year, 0, 1) + 1;
+        case "decade":
+            return Math.floor(year / 10);
+        case "century":
+            return Math.ceil(year / 100);
+        case "millennium":
+            return Math.ceil(year / 1000);
+        default: {
+            // ISO week and ISO year: the Thursday of this week decides both.
+            const dow = (((days + 4) % 7) + 7) % 7;
+            const thursday = days + 4 - (dow || 7);
+            const [isoYear] = civilFromDays(thursday);
+            if (normalized === "isoyear")
+                return isoYear;
+            const yearStart = daysFromCivil(isoYear, 0, 1);
+            return Math.ceil((thursday - yearStart + 1) / 7);
+        }
     }
 }
 /**
@@ -4530,6 +4737,9 @@ export function comparisonHolds(operator, leftValue, rightValue) {
         rightValue === null ||
         rightValue === undefined)
         return false;
+    // An untyped string beside a datetime, number, or boolean reads in that value's type, as
+    // PostgreSQL types an unknown-typed literal by its context (`joined >= '2026-01-01'`).
+    [leftValue, rightValue] = coerceComparisonOperands(leftValue, rightValue);
     const left = comparable(leftValue);
     const right = comparable(rightValue);
     if (operator === "=")
@@ -4615,6 +4825,23 @@ function hasWindow(expression) {
 export function isAggregateCall(expression) {
     return expression.kind === "call" && aggregateNames.has(expression.name);
 }
+/**
+ * Whether a non-aggregate select expression is a function of the grouping expressions: it is one
+ * of them, or every column it reads sits inside a subexpression that is one of them. PostgreSQL
+ * accepts `FLOOR(amount / 25) * 25` grouped by `FLOOR(amount / 25)` on exactly this rule.
+ */
+function groupedExpression(expression, grouped) {
+    if (grouped.has(JSON.stringify(expression)))
+        return true;
+    // A full-text node reads its row's searchable columns even when MATCH(*) lists none, so it
+    // is only grouped when the GROUP BY names it outright.
+    if (expression.kind === "column" || containsFtsExpression(expression))
+        return false;
+    const children = childExpressions(expression);
+    if (children.length === 0)
+        return expressionColumns(expression).length === 0;
+    return children.every((child) => expressionColumns(child).length === 0 || groupedExpression(child, grouped));
+}
 function validateGrouping(plan) {
     const grouped = plan.groupBy.length > 0 || plan.select.some((item) => hasAggregate(item.expression));
     if (!grouped)
@@ -4630,7 +4857,7 @@ function validateGrouping(plan) {
             !containsFtsExpression(item.expression)) {
             continue;
         }
-        if (!groupExpressions.has(JSON.stringify(item.expression))) {
+        if (!groupedExpression(item.expression, groupExpressions)) {
             throw new TypeError(`Selected column must appear in GROUP BY: ${item.alias}`);
         }
     }
@@ -4797,6 +5024,12 @@ class Parser {
     /** Placeholders seen so far: positional `?` count, and the highest `$n` number. */
     #positionalParameters = 0;
     #highestNumberedParameter = 0;
+    /**
+     * Set while a set-operation member's SELECT parses. The member leaves a trailing ORDER BY,
+     * LIMIT, OFFSET, or FETCH unparsed: PostgreSQL applies that tail to the whole compound, and a
+     * member that swallowed it would resolve the ordering against its own select list instead.
+     */
+    #compoundMember = false;
     /** Set when the statement names CURRENT_DATE, CURRENT_TIMESTAMP, or LOCALTIME. */
     usesStatementDatetime = false;
     /** Set when the statement names NEXTVAL or CURRVAL. */
@@ -4915,7 +5148,7 @@ class Parser {
             }
         }
         // INTERSECT binds tighter than UNION and EXCEPT, matching PostgreSQL.
-        const firstTerm = this.#setTerm(sql);
+        const firstTerm = this.#setTerm(sql, false);
         let plan = firstTerm.block;
         if (this.#isKeyword("UNION") || this.#isKeyword("EXCEPT")) {
             const members = [firstTerm];
@@ -4939,14 +5172,38 @@ class Parser {
                     else
                         ops.push("except");
                 }
-                members.push(this.#setTerm("(union member)"));
+                members.push(this.#setTerm("(union member)", true));
+            }
+            // PostgreSQL assigns a trailing ORDER BY or LIMIT to the whole compound, so every member
+            // after the first parsed without one and the tail is still unparsed here.
+            plan = this.#compoundBlock(sql, members, ops, this.#compoundTail());
+        }
+        else if (firstTerm.values === true && !firstTerm.parenthesized) {
+            // A bare VALUES list desugars into a UNION ALL of one-row selects; a trailing ORDER BY
+            // or LIMIT applies to that compound, with ordinals resolving against the row shape.
+            const tail = this.#compoundTail();
+            if (tail.orderBy.length > 0 || tail.limit !== undefined || tail.offset !== undefined) {
+                const union = plan.base.union;
+                plan =
+                    union === undefined
+                        ? compoundSelectBlock(sql, [plan], [], tail, this.nextDerivedSequence)
+                        : compoundSelectBlock(sql, union.blocks, union.ops, tail, this.nextDerivedSequence);
             }
-            plan = this.#compoundBlock(sql, members, ops);
         }
         return plan;
     }
-    #setTerm(sql) {
-        const first = this.#unionMember(sql);
+    /** The clauses that close a query expression: ORDER BY, then LIMIT/OFFSET or OFFSET/FETCH. */
+    #compoundTail() {
+        return { orderBy: this.#orderByClause(), ...this.#tailClauses() };
+    }
+    /**
+     * One UNION/EXCEPT term: a member, or an INTERSECT chain of members. `member` marks a term
+     * that follows a set operator, whose trailing clauses belong to the enclosing compound; the
+     * first term of a statement parses its own tail, which is where a lone INTERSECT chain's
+     * ORDER BY lands.
+     */
+    #setTerm(sql, member) {
+        const first = this.#unionMember(sql, member);
         if (!this.#isKeyword("INTERSECT"))
             return first;
         const members = [first];
@@ -4959,46 +5216,20 @@ class Parser {
             }
             else
                 ops.push("intersect");
-            members.push(this.#unionMember("(intersect member)"));
+            members.push(this.#unionMember("(intersect member)", true));
         }
-        return { block: this.#compoundBlock(sql, members, ops), parenthesized: false };
+        const tail = member ? { orderBy: [] } : this.#compoundTail();
+        return { block: this.#compoundBlock(sql, members, ops, tail), parenthesized: false };
     }
-    #compoundBlock(sql, members, ops) {
-        for (const [index, member] of members.entries()) {
-            const last = index === members.length - 1;
+    #compoundBlock(sql, members, ops, tail) {
+        // Only the first member can have parsed a tail of its own (later members skip theirs), and
+        // a member-level ORDER BY or LIMIT is legal only inside parentheses.
+        for (const member of members) {
             if (!member.parenthesized &&
-                !last &&
                 (member.block.orderBy.length > 0 || member.block.limit !== undefined)) {
                 throw new TypeError("ORDER BY or LIMIT in a UNION member requires parentheses");
             }
         }
-        // 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];
-        let tail;
-        if (last !== undefined && !last.parenthesized) {
-            tail = {
-                orderBy: last.block.orderBy,
-                ...(last.block.limit === undefined ? {} : { limit: last.block.limit }),
-                ...(last.block.offset === undefined ? {} : { offset: last.block.offset }),
-                ...(last.block.limitWithTies === true ? { limitWithTies: true } : {}),
-                ...(last.block.limitParameter === undefined
-                    ? {}
-                    : { limitParameter: last.block.limitParameter }),
-                ...(last.block.offsetParameter === undefined
-                    ? {}
-                    : { offsetParameter: last.block.offsetParameter }),
-            };
-            last.block.orderBy = [];
-            delete last.block.limit;
-            delete last.block.offset;
-            delete last.block.limitParameter;
-            delete last.block.offsetParameter;
-        }
-        else {
-            tail = { orderBy: this.#orderByClause(), ...this.#tailClauses() };
-        }
         return compoundSelectBlock(sql, members.map((member) => member.block), ops, tail, this.nextDerivedSequence);
     }
     /** CREATE [UNIQUE] INDEX name ON table(column [ASC|DESC], ...). */
@@ -5143,9 +5374,9 @@ class Parser {
                 continue;
             }
             const name = this.#identifier();
-            const columnType = this.#columnType();
-            let nullable = true;
-            let defaultValue;
+            const { serial, ...columnType } = this.#columnType();
+            let nullable = serial !== true;
+            let defaultValue = serial === true ? { kind: "autoincrement" } : undefined;
             let generatedValue;
             for (;;) {
                 if (this.#isKeyword("DEFAULT")) {
@@ -5155,9 +5386,29 @@ class Parser {
                     continue;
                 }
                 if (this.#isKeyword("GENERATED")) {
+                    if (this.#identityClause()) {
+                        // GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY: PostgreSQL's identity column, the
+                        // same auto-increment default a SERIAL column carries.
+                        if (columnType.type !== "number" || columnType.integer !== true) {
+                            throw new TypeError(`Identity column ${name} must be an integer type`);
+                        }
+                        defaultValue = { kind: "autoincrement" };
+                        nullable = false;
+                        continue;
+                    }
                     generatedValue = this.#generatedColumn();
                     continue;
                 }
+                if (this.#isKeyword("AUTOINCREMENT")) {
+                    // SQLite's spelling, after PRIMARY KEY.
+                    this.#keyword("AUTOINCREMENT");
+                    if (columnType.type !== "number" || columnType.integer !== true) {
+                        throw new TypeError(`AUTOINCREMENT column ${name} must be an integer type`);
+                    }
+                    defaultValue = { kind: "autoincrement" };
+                    nullable = false;
+                    continue;
+                }
                 if (this.#isKeyword("CHECK")) {
                     checks.push(this.#checkConstraint(`${table}_${name}_check`));
                     continue;
@@ -5369,6 +5620,44 @@ class Parser {
         return columnDefaultFor(expression, sql);
     }
     /** GENERATED [ALWAYS] AS (expression) STORED. */
+    /**
+     * Consumes `GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY` and answers true; leaves the
+     * tokens alone and answers false for the stored generated-column form.
+     */
+    #identityClause() {
+        const start = this.#index;
+        this.#keyword("GENERATED");
+        if (this.#isKeyword("BY")) {
+            this.#keyword("BY");
+            this.#keyword("DEFAULT");
+        }
+        else if (this.#isKeyword("ALWAYS")) {
+            this.#keyword("ALWAYS");
+        }
+        if (this.#isKeyword("AS")) {
+            this.#keyword("AS");
+            if (this.#isKeyword("IDENTITY")) {
+                this.#keyword("IDENTITY");
+                // Sequence options in parentheses are accepted and ignored; the counter starts at 1.
+                if (this.#punctuation("(")) {
+                    let depth = 1;
+                    while (depth > 0) {
+                        const token = this.#peek();
+                        if (token.kind === "eof")
+                            throw new TypeError("Unterminated identity options");
+                        this.#index += 1;
+                        if (token.kind === "punctuation" && token.text === "(")
+                            depth += 1;
+                        if (token.kind === "punctuation" && token.text === ")")
+                            depth -= 1;
+                    }
+                }
+                return true;
+            }
+        }
+        this.#index = start;
+        return false;
+    }
     #generatedColumn() {
         this.#keyword("GENERATED");
         if (this.#isKeyword("ALWAYS"))
@@ -5492,6 +5781,10 @@ class Parser {
             break;
         }
         this.#take("eof");
+        // PostgreSQL fills existing rows with a constant DEFAULT when the column is added, which is
+        // also what lets the column be NOT NULL. An expression default (NOW(), nextval) is evaluated
+        // per write, so it fills only the rows written afterwards.
+        const backfill = defaultValue?.kind === "literal" ? defaultValue.value : undefined;
         return {
             kind: "add-column",
             table,
@@ -5500,7 +5793,9 @@ class Parser {
                 ...columnType,
                 ...(nullable ? { nullable: true } : {}),
                 ...(defaultValue === undefined ? {} : { defaultValue }),
+                ...(backfill === undefined ? {} : { backfill }),
             },
+            ...(backfill === undefined ? {} : { allowNonNullableWithBackfill: true }),
         };
     }
     /** A type name's precision, scale, or width: plain digits, as PostgreSQL requires there. */
@@ -5549,6 +5844,10 @@ class Parser {
     #columnType() {
         const declared = this.#identifier();
         const word = declared.toUpperCase();
+        if (word === "SERIAL" || word === "BIGSERIAL" || word === "SMALLSERIAL") {
+            // PostgreSQL's serial pseudo-types: an integer column fed by an auto-increment default.
+            return { type: "number", integer: true, serial: true };
+        }
         if (word === "NUMERIC" || word === "DECIMAL") {
             let precision;
             let scale;
@@ -5631,14 +5930,20 @@ class Parser {
                 ...this.#returningClause(table),
             };
         }
-        if (this.#isKeyword("SELECT")) {
-            const insertSource = this.#selectBlock("(insert select)");
+        if (this.#isKeyword("SELECT") || this.#isKeyword("WITH") || this.#peek().text === "(") {
+            // Any query expression feeds INSERT: a plain SELECT, a WITH, a set operation, or a
+            // parenthesized member; ON CONFLICT then applies to the produced rows as it does to VALUES.
+            const insertSource = this.#queryExpression("(insert select)");
             resolvePlanExactNumericConstants(insertSource);
-            const query = optimizePlan(insertSource);
-            if (query.select.some((item) => item.expression.kind === "wildcard")) {
-                throw new TypeError("INSERT ... SELECT requires an explicit select list");
-            }
-            if (columns.length > 0 && query.select.length !== columns.length) {
+            const query = planHasPendingSelectShapes(insertSource)
+                ? insertSource
+                : optimizePlan(insertSource);
+            // A set operation or VALUES source projects `*` over its members until execution; the
+            // materialized result is checked against the column list then, like every other source.
+            if (!planHasPendingSelectShapes(query) &&
+                !query.select.some((item) => item.expression.kind === "wildcard") &&
+                columns.length > 0 &&
+                query.select.length !== columns.length) {
                 throw new TypeError("INSERT ... SELECT must produce exactly the insert column count");
             }
             return {
@@ -5647,6 +5952,7 @@ class Parser {
                 columns,
                 rows: [],
                 query,
+                ...this.#onConflictClause(table),
                 ...this.#returningClause(table),
             };
         }
@@ -5682,6 +5988,13 @@ class Parser {
             return {};
         this.#keyword("ON");
         this.#keyword("CONFLICT");
+        if (this.#isKeyword("DO")) {
+            // PostgreSQL lets DO NOTHING omit the conflict target (any unique key); DO UPDATE has to
+            // name one. Kysely's `onConflict((oc) => oc.doNothing())` emits exactly this spelling.
+            this.#keyword("DO");
+            this.#keyword("NOTHING");
+            return { onConflict: { column: "", anyTarget: true, action: "nothing" } };
+        }
         this.#expectPunctuation("(");
         const columns = [];
         for (;;) {
@@ -5742,7 +6055,13 @@ class Parser {
         };
     }
     /** RETURNING *, target.*, or [target.]col, ... — execution owns the row semantics. */
-    #returningClause(table) {
+    /**
+     * RETURNING: `*`, `target.*`, or a list of items. A list of plain (optionally target-qualified)
+     * columns keeps the column form; any other item — an expression, a function call, an
+     * aliased column — is carried as an expression list that the executor evaluates over the
+     * affected rows through an ordinary SELECT, with the statement text of each item.
+     */
+    #returningClause(table, alias) {
         if (!this.#isKeyword("RETURNING"))
             return {};
         this.#keyword("RETURNING");
@@ -5750,29 +6069,67 @@ class Parser {
             this.#index += 1;
             return { returning: "*" };
         }
-        const columns = [];
+        const items = [];
+        let plain = true;
         for (;;) {
-            const first = this.#identifier();
-            if (this.#punctuation(".")) {
-                if (first !== table) {
-                    throw new TypeError(`RETURNING qualifier must name the target table: ${table}`);
+            const start = this.#peek();
+            if (start.kind === "identifier" &&
+                this.tokens[this.#index + 1]?.text === "." &&
+                this.tokens[this.#index + 2]?.text === "*") {
+                this.#index += 3;
+                if (start.text !== table && start.text !== alias) {
+                    throw new TypeError(`RETURNING qualifier must name the target table: ${alias ?? table}`);
                 }
-                if (this.#peek().text === "*") {
-                    this.#index += 1;
-                    if (columns.length > 0 || this.#peek().text === ",") {
-                        throw new TypeError("RETURNING target.* must be the only returned item");
-                    }
-                    return { returning: "*" };
+                if (items.length > 0 || this.#peek().text === ",") {
+                    throw new TypeError("RETURNING target.* must be the only returned item");
                 }
-                columns.push(this.#identifier());
+                return { returning: "*" };
             }
-            else {
-                columns.push(first);
+            const expression = this.#expression();
+            const end = this.tokens[this.#index - 1] ?? start;
+            let outputAlias = defaultAlias(expression);
+            let explicit = false;
+            if (this.#isKeyword("AS")) {
+                this.#keyword("AS");
+                outputAlias = this.#identifier();
+                explicit = true;
+            }
+            let column;
+            if (expression.kind === "column") {
+                const parts = expression.reference.split(".");
+                if (parts.length === 1)
+                    column = parts[0];
+                else if (parts.length === 2 && (parts[0] === table || parts[0] === alias))
+                    column = parts[1];
+                else {
+                    throw new TypeError(`RETURNING qualifier must name the target table: ${alias ?? table}`);
+                }
             }
+            if (column === undefined || explicit)
+                plain = false;
+            items.push({
+                sql: this.text.slice(start.start, end.end),
+                alias: outputAlias,
+                expression,
+                ...(column === undefined ? {} : { column }),
+            });
             if (!this.#punctuation(","))
                 break;
         }
-        return { returning: columns };
+        if (plain)
+            return { returning: items.map((item) => item.column ?? item.alias) };
+        for (const item of items) {
+            if (hasAggregate(item.expression)) {
+                throw new TypeError("RETURNING cannot use aggregate functions");
+            }
+        }
+        const aliases = new Set();
+        for (const item of items) {
+            if (aliases.has(item.alias))
+                throw new TypeError(`Duplicate output column: ${item.alias}`);
+            aliases.add(item.alias);
+        }
+        return { returningItems: items };
     }
     /**
      * MERGE INTO target USING source ON condition WHEN [NOT] MATCHED [AND …] THEN … (F312).
@@ -5904,15 +6261,19 @@ class Parser {
     #updateStatement() {
         this.#keyword("UPDATE");
         const table = this.#identifier();
+        const alias = this.#mutationAlias("SET");
         this.#keyword("SET");
         const assignments = [];
         for (;;) {
-            const column = this.#identifier();
+            const column = this.#mutationTargetColumn(table, alias);
             this.#operator("=");
             const expression = this.#expression();
             if (hasAggregate(expression)) {
                 throw new TypeError("Aggregate functions are not allowed in UPDATE assignments");
             }
+            if (containsWindow(expression)) {
+                throw new TypeError("Window functions are not allowed in UPDATE assignments");
+            }
             assignments.push({ column, expression });
             if (!this.#punctuation(","))
                 break;
@@ -5921,14 +6282,54 @@ class Parser {
             throw new TypeError("UPDATE assignments must set each column once");
         }
         const predicates = this.#mutationPredicates();
-        return { kind: "update", table, assignments, predicates, ...this.#returningClause(table) };
+        return {
+            kind: "update",
+            table,
+            ...(alias === undefined ? {} : { alias }),
+            assignments,
+            predicates,
+            ...this.#returningClause(table, alias),
+        };
     }
     #deleteStatement() {
         this.#keyword("DELETE");
         this.#keyword("FROM");
         const table = this.#identifier();
+        const alias = this.#mutationAlias("WHERE", "RETURNING");
         const predicates = this.#mutationPredicates();
-        return { kind: "delete", table, predicates, ...this.#returningClause(table) };
+        return {
+            kind: "delete",
+            table,
+            ...(alias === undefined ? {} : { alias }),
+            predicates,
+            ...this.#returningClause(table, alias),
+        };
+    }
+    /**
+     * `UPDATE t AS u` / `DELETE FROM t u`: PostgreSQL's mutation alias. A bare identifier that is
+     * not one of the clause keywords that may follow the table is the alias.
+     */
+    #mutationAlias(...clauses) {
+        if (this.#isKeyword("AS")) {
+            this.#keyword("AS");
+            return this.#identifier();
+        }
+        const token = this.#peek();
+        if (token.kind !== "identifier")
+            return undefined;
+        if (token.quoted !== true && clauses.includes(token.text.toUpperCase()))
+            return undefined;
+        return this.#identifier();
+    }
+    /** An assignment target, optionally qualified by the table or its alias (`SET u.total = …`). */
+    #mutationTargetColumn(table, alias) {
+        const first = this.#identifier();
+        if (!this.#punctuation("."))
+            return first;
+        if (first !== table && first !== alias) {
+            throw new TypeError(`SET qualifier must name the target table: ${alias ?? table}`);
+        }
+        return this.#identifier();
     }
     #mutationPredicates() {
         const predicates = [];
@@ -5959,17 +6360,30 @@ class Parser {
         if (hasAggregate(expression) || expressionColumns(expression).length > 0) {
             throw new TypeError(`${label} must be constant expressions`);
         }
+        // A scalar subquery is a value the statement reads when it runs, like the statement clock.
+        const needsExecution = (value) => value.kind === "subquery" ||
+            value.kind === "exists" ||
+            (value.kind === "call" &&
+                (statementDatetimeNames.has(value.name) ||
+                    value.name === "NEXTVAL" ||
+                    value.name === "CURRVAL" ||
+                    volatileScalarFunctionNames.has(value.name))) ||
+            childExpressions(value).some(needsExecution);
+        if (needsExecution(expression)) {
+            return { expression: resolveExactNumericConstants(expression) };
+        }
         return asQueryValue(evaluate(resolveExactNumericConstants(expression), {}));
     }
-    #unionMember(sql) {
+    #unionMember(sql, member) {
         if (this.#punctuation("(")) {
             const block = this.#isKeyword("VALUES") ? this.#valuesBlock() : this.#queryExpression(sql);
             this.#expectPunctuation(")");
             return { block, parenthesized: true };
         }
         if (this.#isKeyword("VALUES")) {
-            return { block: this.#valuesBlock(), parenthesized: false };
+            return { block: this.#valuesBlock(), parenthesized: false, values: true };
         }
+        this.#compoundMember = member;
         return { block: this.#selectBlock(sql), parenthesized: false };
     }
     #orderByClause() {
@@ -6146,6 +6560,10 @@ class Parser {
         return windows;
     }
     #selectBlockBody(sql) {
+        // Captured and cleared first, so a derived table or subquery inside this block parses its
+        // own tail: only the member's outermost SELECT leaves the compound's clauses alone.
+        const compoundMember = this.#compoundMember;
+        this.#compoundMember = false;
         this.#keyword("SELECT");
         let distinct = false;
         if (this.#isKeyword("DISTINCT")) {
@@ -6302,8 +6720,6 @@ class Parser {
         const having = [];
         if (this.#isKeyword("HAVING")) {
             this.#keyword("HAVING");
-            if (distinct)
-                throw new TypeError("SELECT DISTINCT cannot be combined with HAVING");
             having.push(...splitCondition(this.#expression()));
         }
         if (this.#isKeyword("WINDOW")) {
@@ -6318,7 +6734,7 @@ class Parser {
                     break;
             }
         }
-        const orderBy = this.#orderByClause();
+        const orderBy = compoundMember ? [] : this.#orderByClause();
         return assembleSelectBlock({
             sql,
             base,
@@ -6329,7 +6745,7 @@ class Parser {
             groupBy,
             having,
             orderBy,
-            ...this.#tailClauses(),
+            ...(compoundMember ? {} : this.#tailClauses()),
             ...(groupingSets === undefined ? {} : { groupingSets }),
         }, this.nextDerivedSequence);
     }
@@ -6394,10 +6810,6 @@ class Parser {
             if (!this.#punctuation(","))
                 break;
         }
-        if (items.some((item) => item.expression.kind === "wildcard" && item.expression.table === undefined) &&
-            items.length > 1) {
-            throw new TypeError("SELECT * cannot be mixed with other expressions");
-        }
         const aliases = new Set();
         for (const [index, item] of items.entries()) {
             if (item.expression.kind === "list") {
@@ -6515,18 +6927,7 @@ class Parser {
                 break;
         }
         this.#expectPunctuation(")");
-        // Set-operation output takes the first member's aliases, so renaming targets it.
-        const target = derived.base.union !== undefined && derived.select[0]?.expression.kind === "wildcard"
-            ? derived.base.union.blocks[0]
-            : derived;
-        if (target?.select.length !== names.length) {
-            throw new TypeError("Column alias list must match the derived table's column count");
-        }
-        names.forEach((name, index) => {
-            const item = target.select[index];
-            if (item !== undefined)
-                item.alias = name;
-        });
+        renameBlockOutputs(derived, names, "derived table");
     }
     /**
      * `JOIN t USING (a, b)`: the named columns must exist on both sides, and the join condition
@@ -7134,16 +7535,48 @@ class Parser {
             }
             // || and the JSON arrows share PostgreSQL's loosest "any other operator" level, applying
             // left-to-right to whole arithmetic terms: `'a' || d ->> 'k'` is `('a' || d) ->> 'k'`.
-            const precedence = operator === "*" || operator === "/" || operator === "%"
-                ? 20
-                : operator === "+" || operator === "-"
-                    ? 10
-                    : operator === "||" || operator === "->" || operator === "->>"
-                        ? 5
-                        : -1;
+            const regexOperator = operator === "~" || operator === "~*" || operator === "!~" || operator === "!~*";
+            const precedence = operator === "::"
+                ? 30
+                : operator === "^"
+                    ? 25
+                    : operator === "*" || operator === "/" || operator === "%"
+                        ? 20
+                        : operator === "+" || operator === "-"
+                            ? 10
+                            : operator === "||" || operator === "->" || operator === "->>" || regexOperator
+                                ? 5
+                                : -1;
             if (precedence < minimumPrecedence)
                 break;
             this.#index += 1;
+            if (operator === "^") {
+                // Exponentiation binds above * and / and, as in PostgreSQL, associates to the left:
+                // 2 ^ 3 ^ 2 is (2 ^ 3) ^ 2.
+                const exponent = this.#additive(precedence + 1);
+                left = { kind: "call", name: "POWER", arguments: [left, exponent] };
+                continue;
+            }
+            if (regexOperator) {
+                const pattern = this.#additive(precedence + 1);
+                const match = {
+                    kind: "call",
+                    name: "MINNOW_REGEX_MATCH",
+                    arguments: [left, pattern, { kind: "literal", value: operator.endsWith("*") ? "i" : "" }],
+                };
+                left = operator.startsWith("!") ? { kind: "not", operand: match } : match;
+                continue;
+            }
+            if (operator === "::") {
+                // PostgreSQL's postfix cast binds tighter than every binary operator, so it applies to
+                // the term just parsed and rides the same CAST call as the standard spelling.
+                left = {
+                    kind: "call",
+                    name: "CAST",
+                    arguments: [left, { kind: "literal", value: this.#castTarget() }],
+                };
+                continue;
+            }
             if (operator === "->" || operator === "->>") {
                 const key = this.#additive(precedence + 1);
                 // A key fixed at compile time fails here rather than per row, like SQL/JSON paths.
@@ -7656,7 +8089,8 @@ class Parser {
                 name === "MINNOW_COLLATE" ||
                 name === "MINNOW_SINGLE_VALUE" ||
                 name === "MINNOW_JSON_GET" ||
-                name === "MINNOW_JSON_GET_TEXT") {
+                name === "MINNOW_JSON_GET_TEXT" ||
+                name === "MINNOW_REGEX_MATCH") {
                 throw new TypeError(`Unsupported function: ${identifier}`);
             }
             if (!aggregateNames.has(name) && !scalarFunctionNames.has(name))
@@ -7709,6 +8143,25 @@ class Parser {
             if (name === "JSON_ARRAYAGG" && args[0]?.kind === "wildcard") {
                 throw new TypeError("JSON_ARRAYAGG requires a scalar value expression");
             }
+            const simple = simpleScalarFunctions.get(name);
+            if (simple !== undefined) {
+                if (name === "AGE" && args.length === 1) {
+                    // AGE(x) is AGE(CURRENT_DATE, x): the statement clock, resolved once per statement.
+                    this.usesStatementDatetime = true;
+                    args.unshift({ kind: "call", name: "CURRENT_DATE", arguments: [] });
+                }
+                if (args.length < simple.minArgs || args.length > simple.maxArgs) {
+                    const range = simple.minArgs === simple.maxArgs
+                        ? `exactly ${String(simple.minArgs)}`
+                        : simple.maxArgs === Number.POSITIVE_INFINITY
+                            ? `at least ${String(simple.minArgs)}`
+                            : `${String(simple.minArgs)} to ${String(simple.maxArgs)}`;
+                    throw new TypeError(`${name} takes ${range} argument${simple.maxArgs === 1 ? "" : "s"}`);
+                }
+                if (args.some((argument) => argument.kind === "wildcard")) {
+                    throw new TypeError(`${name} takes scalar arguments`);
+                }
+            }
             if (name === "ROUND" && (args.length < 1 || args.length > 2))
                 throw new TypeError("ROUND requires one or two arguments");
             if (name === "COALESCE" && args.length < 1)
@@ -8202,23 +8655,33 @@ function desugarGroupingSets(parts, nextSequence) {
             if (hasAggregate(item.expression))
                 return item;
             const signature = signatureOf(item.expression);
-            if (setSignatures.has(signature) || !universe.has(signature))
+            if (setSignatures.has(signature) || expressionColumns(item.expression).length === 0) {
+                return item;
+            }
+            // A grouping expression this set aggregated away is NULL in every one of its groups.
+            // NULLIF(e, e) is that NULL typed like e, and it substitutes for the expression wherever
+            // it appears: bare (`region`) or inside a wider select expression
+            // (`COALESCE(region, 'all')`, the usual rollup label). MIN over the result keeps the
+            // member block grouped; the value is the same for every row of the group.
+            const away = { count: 0 };
+            const nullify = (expression) => {
+                const inner = signatureOf(expression);
+                if (universe.has(inner) && !setSignatures.has(inner)) {
+                    away.count += 1;
+                    return {
+                        kind: "call",
+                        name: "NULLIF",
+                        arguments: [structuredClone(expression), structuredClone(expression)],
+                    };
+                }
+                return mapChildExpressions(expression, nullify);
+            };
+            const nullified = nullify(structuredClone(item.expression));
+            if (away.count === 0)
                 return item;
-            // MIN over an always-NULL argument: legal in a grouped select, NULL in every group, and
-            // typed like the original expression through MIN's carry and NULLIF's first argument.
             return {
                 alias: item.alias,
-                expression: {
-                    kind: "call",
-                    name: "MIN",
-                    arguments: [
-                        {
-                            kind: "call",
-                            name: "NULLIF",
-                            arguments: [structuredClone(item.expression), structuredClone(item.expression)],
-                        },
-                    ],
-                },
+                expression: { kind: "call", name: "MIN", arguments: [nullified] },
             };
         });
         return assembleSelectBlock({
@@ -8258,6 +8721,80 @@ function resolveOrderByOrdinals(orderBy, select) {
         return { ...order, expression: { kind: "column", reference: item.alias } };
     });
 }
+/**
+ * `SELECT id FROM people AS p ORDER BY p.id`: a qualified sort key that names the same source
+ * column the select list carries unqualified sorts by that output. Only a qualifier that is one
+ * of the block's own sources counts, and only when exactly one selected column matches, so an
+ * ambiguous or misspelled reference still fails in resolution.
+ */
+function resolveOrderQualifiers(orderBy, select, sourceAliases) {
+    return orderBy.map((order) => {
+        const expression = order.expression;
+        if (expression.kind !== "column")
+            return order;
+        const separator = expression.reference.indexOf(".");
+        if (separator === -1)
+            return order;
+        // A selected column referenced exactly as written orders by that output column: a wildcard
+        // expansion reads `p.name` but names the output `name`.
+        const exact = select.find((item) => item.expression.kind === "column" && item.expression.reference === expression.reference);
+        if (exact !== undefined) {
+            return exact.alias === expression.reference
+                ? order
+                : { ...order, expression: { kind: "column", reference: exact.alias } };
+        }
+        const qualifier = expression.reference.slice(0, separator);
+        const column = expression.reference.slice(separator + 1);
+        if (!sourceAliases.includes(qualifier))
+            return order;
+        const matches = select.filter((item) => item.expression.kind === "column" &&
+            !item.expression.reference.includes(".") &&
+            item.expression.reference === column);
+        const match = matches.length === 1 ? matches[0] : undefined;
+        if (match === undefined)
+            return order;
+        return { ...order, expression: { kind: "column", reference: match.alias } };
+    });
+}
+/**
+ * Resolves GROUP BY items the way PostgreSQL does: an integer literal is a select-list ordinal,
+ * and a bare name that is an output alias — but not itself the selected column of that name —
+ * stands for the aliased expression. `GROUP BY 1` and `GROUP BY bucket` over
+ * `SELECT FLOOR(amount / 25) AS bucket` therefore group by the expression. A name that is both
+ * an alias and a source column keeps its source-column meaning, as it does in PostgreSQL.
+ */
+function resolveGroupByReferences(groupBy, select) {
+    return groupBy.map((expression) => {
+        if (expression.kind === "literal" && typeof expression.value === "number") {
+            const ordinal = expression.value;
+            const item = Number.isInteger(ordinal) ? select[ordinal - 1] : undefined;
+            if (item === undefined) {
+                throw new TypeError(`GROUP BY ordinal is out of range: ${String(ordinal)}`);
+            }
+            if (hasAggregate(item.expression) || containsWindow(item.expression)) {
+                throw new TypeError("GROUP BY ordinals cannot name an aggregate or window column");
+            }
+            return structuredClone(item.expression);
+        }
+        if (expression.kind !== "column" || expression.reference.includes("."))
+            return expression;
+        const aliased = select.filter((item) => item.alias === expression.reference);
+        const item = aliased.length === 1 ? aliased[0] : undefined;
+        if (item === undefined ||
+            item.expression.kind === "wildcard" ||
+            hasAggregate(item.expression) ||
+            containsWindow(item.expression)) {
+            return expression;
+        }
+        // `SELECT region AS r ... GROUP BY r` groups by region. Were r also a source column,
+        // PostgreSQL would group by that column and then reject the ungrouped region, so reading
+        // the alias never changes an answer PostgreSQL gives.
+        if (item.expression.kind === "column" && item.expression.reference === expression.reference) {
+            return expression;
+        }
+        return structuredClone(item.expression);
+    });
+}
 /**
  * FULL OUTER JOIN desugars into UNION ALL of two left joins: the plain left join carries every
  * base row (matched or not), and the swapped left join filtered to a NULL-extended base side
@@ -8341,7 +8878,47 @@ function desugarFullJoin(parts, nextSequence) {
     }, nextSequence);
 }
 export function assembleSelectBlock(parts, nextSequence) {
-    parts = { ...parts, orderBy: resolveOrderByOrdinals(parts.orderBy, parts.select) };
+    if (parts.select.some((item) => item.expression.kind === "wildcard")) {
+        if (parts.joins.some((join) => join.full === true)) {
+            throw new TypeError("FULL JOIN cannot be combined with SELECT *");
+        }
+        // A wildcard's width and names come from source schemas, but ordinals, hidden ORDER BY
+        // columns, DISTINCT grouping, windows, grouping sets, and FULL JOIN lowering all depend on
+        // that width. Preserve the raw block until schema binding instead of teaching each lowering
+        // a different late wildcard exception.
+        return {
+            sql: parts.sql,
+            base: parts.base,
+            joins: parts.joins,
+            select: parts.select,
+            predicates: parts.predicates,
+            groupBy: parts.groupBy,
+            having: parts.having,
+            orderBy: parts.orderBy,
+            ...(parts.limit === undefined ? {} : { limit: parts.limit }),
+            ...(parts.offset === undefined ? {} : { offset: parts.offset }),
+            ...(parts.limitParameter === undefined ? {} : { limitParameter: parts.limitParameter }),
+            ...(parts.offsetParameter === undefined ? {} : { offsetParameter: parts.offsetParameter }),
+            ...(parts.limitWithTies === true ? { limitWithTies: true } : {}),
+            pendingSelectShape: {
+                distinct: parts.distinct,
+                ...(parts.groupingSets === undefined
+                    ? {}
+                    : { groupingSets: structuredClone(parts.groupingSets) }),
+            },
+            ...(parts.distinct ? { distinctWildcard: true } : {}),
+        };
+    }
+    parts = {
+        ...parts,
+        orderBy: resolveOrderQualifiers(resolveOrderByOrdinals(parts.orderBy, parts.select), parts.select, [parts.base, ...parts.joins].map((source) => source.alias)),
+        groupBy: resolveGroupByReferences(parts.groupBy, parts.select),
+        ...(parts.groupingSets === undefined
+            ? {}
+            : {
+                groupingSets: parts.groupingSets.map((set) => resolveGroupByReferences(set, parts.select)),
+            }),
+    };
     if (parts.joins.some((join) => join.full === true)) {
         return desugarFullJoin(parts, nextSequence);
     }
@@ -8359,15 +8936,41 @@ export function assembleSelectBlock(parts, nextSequence) {
     const { limitParameter, offsetParameter } = parts;
     const groupBy = [...parts.groupBy];
     let distinctWildcard = false;
+    if (distinct &&
+        (groupBy.length > 0 ||
+            having.length > 0 ||
+            select.some((item) => hasAggregate(item.expression) || hasWindow(item.expression)))) {
+        // DISTINCT over a grouped, aggregated, or windowed block applies to that block's output:
+        // run the block as written inside a derived table and take the distinct rows of it,
+        // carrying the ORDER BY and paging outward, which is where they act in PostgreSQL too.
+        const inner = assembleSelectBlock({ ...parts, distinct: false, orderBy: [] }, nextSequence);
+        delete inner.limit;
+        delete inner.offset;
+        delete inner.limitParameter;
+        delete inner.offsetParameter;
+        delete inner.limitWithTies;
+        const source = derivedTableSource(inner, "(distinct)", nextSequence);
+        return assembleSelectBlock({
+            sql,
+            base: source,
+            joins: [],
+            select: inner.select.map((item) => ({
+                expression: { kind: "column", reference: item.alias },
+                alias: item.alias,
+            })),
+            distinct: true,
+            predicates: [],
+            groupBy: [],
+            having: [],
+            orderBy: parts.orderBy,
+            ...(limit === undefined ? {} : { limit }),
+            ...(offset === undefined ? {} : { offset }),
+            ...(limitParameter === undefined ? {} : { limitParameter }),
+            ...(offsetParameter === undefined ? {} : { offsetParameter }),
+            ...(parts.limitWithTies === true ? { limitWithTies: true } : {}),
+        }, nextSequence);
+    }
     if (distinct) {
-        if (select.some((item) => hasAggregate(item.expression)))
-            throw new TypeError("SELECT DISTINCT cannot be combined with aggregate functions");
-        if (select.some((item) => hasWindow(item.expression)))
-            throw new TypeError("SELECT DISTINCT cannot be combined with window functions");
-        if (groupBy.length > 0)
-            throw new TypeError("SELECT DISTINCT cannot be combined with GROUP BY");
-        if (having.length > 0)
-            throw new TypeError("SELECT DISTINCT cannot be combined with HAVING");
         if (select.some((item) => item.expression.kind === "wildcard")) {
             // The wildcard's columns are unknown until input schemas exist; executor entries
             // expand the flag into a concrete select list plus GROUP BY (expandDistinctWildcard).
@@ -8450,15 +9053,19 @@ function expandDistinctWildcard(plan, columnsOf) {
         columns: sourceWildcardColumns(source, columnsOf),
     }));
     const visible = shaped.filter(({ columns }) => (columns?.length ?? 0) > 0);
-    const multiple = visible.length > 1;
+    const contributed = new Map();
+    for (const { columns } of visible) {
+        for (const name of columns ?? [])
+            contributed.set(name, (contributed.get(name) ?? 0) + 1);
+    }
     const select = visible.flatMap(({ source, columns }) => {
         if (columns === undefined) {
             throw new TypeError(`SELECT DISTINCT * requires known columns for: ${source.table}`);
         }
-        return columns.map((name) => {
-            const output = multiple ? `${source.alias}.${name}` : name;
-            return { expression: { kind: "column", reference: output }, alias: output };
-        });
+        return columns.map((name) => ({
+            expression: { kind: "column", reference: `${source.alias}.${name}` },
+            alias: (contributed.get(name) ?? 0) > 1 ? `${source.alias}.${name}` : name,
+        }));
     });
     const { distinctWildcard, ...rest } = plan;
     void distinctWildcard;
@@ -8583,6 +9190,12 @@ function withTiesPlan(plan) {
  * table's own aliases, a set operation's first member's, and otherwise the input table's.
  */
 function sourceWildcardColumns(source, columnsOf) {
+    if (source.derived?.base.union !== undefined &&
+        source.derived.select[0]?.expression.kind === "wildcard") {
+        return source.derived.base.union.blocks[0]?.select
+            .map((item) => item.alias)
+            .filter((name) => !name.startsWith("\0"));
+    }
     if (source.derived !== undefined)
         return source.derived.select.map((item) => item.alias).filter((name) => !name.startsWith("\0"));
     if (source.union !== undefined) {
@@ -8590,8 +9203,202 @@ function sourceWildcardColumns(source, columnsOf) {
             .map((item) => item.alias)
             .filter((name) => !name.startsWith("\0"));
     }
+    if (source.windowed !== undefined) {
+        return [
+            ...source.windowed.block.select.map((item) => item.alias),
+            ...source.windowed.windows.map((window) => window.alias),
+        ].filter((name) => !name.startsWith("\0"));
+    }
+    if (source.recursive !== undefined) {
+        return source.recursive.base.select
+            .map((item) => item.alias)
+            .filter((name) => !name.startsWith("\0"));
+    }
     return columnsOf(source.table)?.filter((name) => !name.startsWith("\0"));
 }
+/** Whether any block still needs source schemas before its SELECT shape can be lowered. */
+export function planHasPendingSelectShapes(plan) {
+    if (plan.pendingSelectShape !== undefined ||
+        plan.pendingOutputAliases !== undefined ||
+        plan.pendingSetOrder === true) {
+        return true;
+    }
+    let pending = false;
+    forEachNestedBlock(plan, (nested) => {
+        pending ||= planHasPendingSelectShapes(nested);
+    });
+    const inspect = (expression) => {
+        if (expression.kind === "subquery" || expression.kind === "exists") {
+            pending ||= planHasPendingSelectShapes(expression.block);
+            return;
+        }
+        childExpressions(expression).forEach(inspect);
+    };
+    forEachBlockExpression(plan, inspect);
+    return pending;
+}
+/**
+ * Expands schema-dependent SELECT wildcards, then sends the now-concrete block through the same
+ * lowering used by ordinary named select lists. This is the single boundary at which wildcard
+ * width becomes plan shape: DISTINCT, windows, ORDER BY expressions/ordinals, set operations,
+ * CTE/derived column lists, grouping sets, and FULL JOIN therefore cannot disagree about it.
+ */
+export function bindPendingSelectShapes(plan, columnsOf) {
+    if (!planHasPendingSelectShapes(plan))
+        return plan;
+    const bound = structuredClone(plan);
+    const preserveUnoptimizedShape = bound.preserveUnoptimizedShape === true;
+    delete bound.preserveUnoptimizedShape;
+    let sequence = 0;
+    const scanSequence = (block) => {
+        for (const source of [block.base, ...block.joins]) {
+            const match = /\((?:derived|window|union) (\d+)\)/.exec(source.table);
+            if (match?.[1] !== undefined)
+                sequence = Math.max(sequence, Number(match[1]));
+        }
+        forEachNestedBlock(block, scanSequence);
+    };
+    scanSequence(bound);
+    const nextSequence = () => {
+        sequence += 1;
+        return sequence;
+    };
+    const bindExpressionBlocks = (expression) => {
+        if (expression.kind === "subquery" || expression.kind === "exists") {
+            return { ...expression, block: bindBlock(expression.block) };
+        }
+        if (expression.kind === "window") {
+            return {
+                ...expression,
+                partitionBy: expression.partitionBy.map(bindExpressionBlocks),
+                orderBy: expression.orderBy.map((order) => ({
+                    ...order,
+                    expression: bindExpressionBlocks(order.expression),
+                })),
+                ...(expression.argument === undefined
+                    ? {}
+                    : { argument: bindExpressionBlocks(expression.argument) }),
+            };
+        }
+        return mapChildExpressions(expression, bindExpressionBlocks);
+    };
+    const bindSource = (source) => {
+        if (source.derived !== undefined)
+            source.derived = bindBlock(source.derived);
+        if (source.union !== undefined) {
+            source.union.blocks = source.union.blocks.map(bindBlock);
+        }
+        if (source.windowed !== undefined) {
+            source.windowed.block = bindBlock(source.windowed.block);
+        }
+        if (source.recursive !== undefined) {
+            source.recursive.base = bindBlock(source.recursive.base);
+            source.recursive.step = bindBlock(source.recursive.step);
+        }
+    };
+    const expandedSelect = (block) => {
+        const sources = [block.base, ...block.joins];
+        const shaped = sources.map((source) => ({
+            source,
+            columns: source.columnAliases ?? sourceWildcardColumns(source, columnsOf),
+        }));
+        const unknown = shaped.find(({ columns }) => columns === undefined);
+        if (unknown !== undefined) {
+            throw new TypeError(`SELECT * requires known columns for: ${unknown.source.table}`);
+        }
+        // Wildcard outputs keep their bare column names, as PostgreSQL returns them; only a name
+        // that two sources both contribute (`SELECT *` over a join on `id`) is alias-qualified, since
+        // a result row cannot carry two columns named `id`.
+        const contributed = new Map();
+        for (const item of block.select) {
+            if (item.expression.kind !== "wildcard")
+                continue;
+            const table = item.expression.table;
+            for (const { source, columns } of shaped) {
+                if (table !== undefined && source.alias !== table)
+                    continue;
+                for (const name of columns ?? [])
+                    contributed.set(name, (contributed.get(name) ?? 0) + 1);
+            }
+        }
+        const items = block.select.flatMap((item) => {
+            if (item.expression.kind !== "wildcard")
+                return [item];
+            const table = item.expression.table;
+            const selected = table === undefined ? shaped : shaped.filter(({ source }) => source.alias === table);
+            if (table !== undefined && selected.length === 0) {
+                throw new TypeError(`Unknown table for ${table}.*: ${table}`);
+            }
+            return selected.flatMap(({ source, columns }) => (columns ?? []).map((name) => ({
+                expression: { kind: "column", reference: `${source.alias}.${name}` },
+                alias: (contributed.get(name) ?? 0) > 1 ? `${source.alias}.${name}` : name,
+            })));
+        });
+        const aliases = new Set();
+        for (const item of items) {
+            if (aliases.has(item.alias))
+                throw new TypeError(`Duplicate output column: ${item.alias}`);
+            aliases.add(item.alias);
+        }
+        return items;
+    };
+    const carryPlanFlags = (from, to) => {
+        for (const key of [
+            "parameterCount",
+            "usesStatementDatetime",
+            "usesSequenceCalls",
+            "usesVolatileFunctions",
+        ]) {
+            const value = from[key];
+            if (value !== undefined)
+                Object.assign(to, { [key]: value });
+        }
+    };
+    function bindBlock(block) {
+        for (const source of [block.base, ...block.joins])
+            bindSource(source);
+        mapBlockExpressions(block, bindExpressionBlocks);
+        let lowered = block;
+        const pending = block.pendingSelectShape;
+        if (pending !== undefined) {
+            const { pendingSelectShape, pendingOutputAliases, distinctWildcard, ...rest } = block;
+            void pendingSelectShape;
+            void pendingOutputAliases;
+            void distinctWildcard;
+            lowered = assembleSelectBlock({
+                sql: rest.sql,
+                base: rest.base,
+                joins: rest.joins,
+                select: expandedSelect(block),
+                distinct: pending.distinct,
+                predicates: rest.predicates,
+                groupBy: rest.groupBy,
+                having: rest.having,
+                orderBy: rest.orderBy,
+                ...(rest.limit === undefined ? {} : { limit: rest.limit }),
+                ...(rest.offset === undefined ? {} : { offset: rest.offset }),
+                ...(rest.limitParameter === undefined ? {} : { limitParameter: rest.limitParameter }),
+                ...(rest.offsetParameter === undefined ? {} : { offsetParameter: rest.offsetParameter }),
+                ...(rest.limitWithTies === true ? { limitWithTies: true } : {}),
+                ...(pending.groupingSets === undefined ? {} : { groupingSets: pending.groupingSets }),
+            }, nextSequence);
+            carryPlanFlags(block, lowered);
+        }
+        if (lowered.pendingSetOrder === true) {
+            const first = lowered.base.union?.blocks[0];
+            lowered.orderBy = resolveOrderByOrdinals(lowered.orderBy, first?.select ?? []);
+            delete lowered.pendingSetOrder;
+        }
+        const aliases = block.pendingOutputAliases;
+        if (aliases !== undefined) {
+            renameBlockOutputs(lowered, aliases.columns, aliases.sourceName);
+            delete lowered.pendingOutputAliases;
+        }
+        return lowered;
+    }
+    const lowered = bindBlock(bound);
+    return preserveUnoptimizedShape ? lowered : optimizePlan(lowered);
+}
 /** Whether any block of the plan still carries an unresolved NATURAL join marker. */
 export function planHasNaturalJoins(plan) {
     if (plan.joins.some((join) => join.natural === true))
@@ -8751,7 +9558,13 @@ function expandQualifiedWildcards(plan, columnsOf) {
             }
             return columns.map((name) => {
                 const output = multiple ? `${source.alias}.${name}` : name;
-                return { expression: { kind: "column", reference: output }, alias: output };
+                // Keep the source-qualified input reference even though one source exposes a bare output
+                // name. ORDER BY can legally spell either form (`id` or `orders.id`), and the latter must
+                // still match this select item after the wildcard has expanded.
+                return {
+                    expression: { kind: "column", reference: `${source.alias}.${name}` },
+                    alias: output,
+                };
             });
         });
         const aliases = new Set();
@@ -8768,7 +9581,10 @@ function expandQualifiedWildcards(plan, columnsOf) {
 /** Wraps compound members into the set-operation source the executor folds left to right. */
 export function compoundSelectBlock(sql, blocks, ops, tail, nextSequence) {
     // Set-operation output columns are the first member's, so ordinals resolve against them.
-    tail = { ...tail, orderBy: resolveOrderByOrdinals(tail.orderBy, blocks[0]?.select ?? []) };
+    const pendingSetOrder = blocks.some(planHasPendingSelectShapes);
+    if (!pendingSetOrder) {
+        tail = { ...tail, orderBy: resolveOrderByOrdinals(tail.orderBy, blocks[0]?.select ?? []) };
+    }
     return {
         sql,
         base: {
@@ -8782,9 +9598,12 @@ export function compoundSelectBlock(sql, blocks, ops, tail, nextSequence) {
         groupBy: [],
         having: [],
         orderBy: tail.orderBy,
+        ...(pendingSetOrder ? { pendingSetOrder: true } : {}),
         ...(tail.limit === undefined ? {} : { limit: tail.limit }),
         ...(tail.offset === undefined ? {} : { offset: tail.offset }),
         ...(tail.limitWithTies === true ? { limitWithTies: true } : {}),
+        ...(tail.limitParameter === undefined ? {} : { limitParameter: tail.limitParameter }),
+        ...(tail.offsetParameter === undefined ? {} : { offsetParameter: tail.offsetParameter }),
     };
 }
 /**
@@ -8792,9 +9611,10 @@ export function compoundSelectBlock(sql, blocks, ops, tail, nextSequence) {
  * either reuses a structurally identical select item's alias or becomes a hidden "(order N)"
  * select item, the ordering (and LIMIT/OFFSET) applies inside that block, and an outer block
  * projects only the visible aliases away from a derived source. Runs in the shared assembly,
- * so the builder and SQL front ends produce identical plans. A wildcard select has no named
- * output list to hide items behind, and DISTINCT's output would change if hidden expressions
- * joined its grouping, so both keep the named-column restriction.
+ * so the builder and SQL front ends produce identical plans. Schema-bound wildcard blocks reach
+ * this function with concrete items; only a manually constructed unresolved wildcard plan keeps
+ * the named-column restriction. DISTINCT's output would change if hidden expressions joined its
+ * grouping, so it keeps the selected-column restriction.
  */
 /**
  * Whether an ORDER BY item has to travel as a hidden select item: any expression, and also a
@@ -8851,17 +9671,39 @@ function assembleOrderByExpressionBlock(parts, nextSequence) {
             expression: { kind: "column", reference: alias },
         };
     });
-    const inner = assembleSelectBlock({ ...parts, select: [...parts.select, ...hiddenItems], orderBy: rewrittenOrder }, nextSequence);
     // Every ordering expression matched a visible select item — no hidden columns, no wrap.
-    if (hiddenItems.length === 0)
-        return inner;
+    if (hiddenItems.length === 0) {
+        return assembleSelectBlock({ ...parts, orderBy: rewrittenOrder }, nextSequence);
+    }
+    // Once hidden columns exist, the visible projection is wrapped in a derived table. Visible
+    // output names such as `people.id` are legal result labels but are not legal internal column
+    // references there — the dot would be read as the vanished `people` source qualifier. Carry
+    // every visible value through a private dot-free name and restore its public label outside.
+    const visibleInner = parts.select.map((item, index) => ({
+        ...item,
+        alias: item.alias.includes(".") ? `(order visible ${String(index + 1)})` : item.alias,
+    }));
+    const visibleAlias = new Map(parts.select.map((item, index) => [item.alias, visibleInner[index]?.alias ?? item.alias]));
+    const innerOrder = rewrittenOrder.map((order) => {
+        if (order.expression.kind !== "column" || order.expression.reference.includes(".")) {
+            return order;
+        }
+        const alias = visibleAlias.get(order.expression.reference);
+        return alias === undefined
+            ? order
+            : { ...order, expression: { kind: "column", reference: alias } };
+    });
+    const inner = assembleSelectBlock({ ...parts, select: [...visibleInner, ...hiddenItems], orderBy: innerOrder }, nextSequence);
     const source = derivedTableSource(inner, "(ordered)", nextSequence);
     return {
         sql: parts.sql,
         base: source,
         joins: [],
-        select: parts.select.map((item) => ({
-            expression: { kind: "column", reference: item.alias },
+        select: parts.select.map((item, index) => ({
+            expression: {
+                kind: "column",
+                reference: visibleInner[index]?.alias ?? item.alias,
+            },
             alias: item.alias,
         })),
         predicates: [],
@@ -8933,8 +9775,10 @@ export function derivedTableSource(derived, alias, nextSequence) {
 }
 /** The parser's LIMIT range contract, shared with the typed builder. */
 export function validateLimit(limit) {
-    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100_000)
-        throw new RangeError("LIMIT must be between 1 and 100,000");
+    // LIMIT 0 is a legal, empty page: PostgreSQL returns no rows, and clients use it to read a
+    // result's column shape without fetching data.
+    if (!Number.isSafeInteger(limit) || limit < 0 || limit > 100_000)
+        throw new RangeError("LIMIT must be between 0 and 100,000");
     return limit;
 }
 /**
@@ -8943,10 +9787,28 @@ export function validateLimit(limit) {
  * which is later than this.
  */
 function renameBlockOutputs(block, columns, name) {
+    // Set-operation output names come from the first member. Its width may itself be pending on a
+    // wildcard, so preserve the alias list on the compound until all members have schema-bound.
+    if (block.base.union !== undefined && block.select[0]?.expression.kind === "wildcard") {
+        const first = block.base.union.blocks[0];
+        if (first === undefined || planHasPendingSelectShapes(first)) {
+            block.pendingOutputAliases = { columns: [...columns], sourceName: name };
+            return;
+        }
+        renameBlockOutputs(first, columns, name);
+        return;
+    }
+    if (block.pendingSelectShape !== undefined) {
+        block.pendingOutputAliases = { columns: [...columns], sourceName: name };
+        return;
+    }
     if (block.select.some((item) => item.expression.kind === "wildcard")) {
-        throw new TypeError(`A column list needs named columns in the CTE body: ${name}`);
+        throw new TypeError(`A column list needs named columns in the query body: ${name}`);
     }
     if (block.select.length !== columns.length) {
+        if (name === "derived table") {
+            throw new TypeError("Column alias list must match the derived table's column count");
+        }
         throw new TypeError(`CTE ${name} declares ${String(columns.length)} columns but selects ${String(block.select.length)}`);
     }
     block.select = block.select.map((item, index) => ({
@@ -8987,7 +9849,7 @@ function jsonTableColumnValue(column, value) {
     if (value instanceof Date)
         date = value;
     else if (typeof value === "string")
-        date = new Date(value);
+        date = datetimeText(value);
     else if (typeof value === "number")
         date = new Date(value);
     else
@@ -8998,18 +9860,20 @@ function jsonTableColumnValue(column, value) {
     return date;
 }
 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);
-    if (match === null)
+    const date = parseSqlTimestampText(text);
+    if (date === undefined)
         throw new TypeError(`Invalid TIMESTAMP literal: ${text}`);
-    const [, day, time = "00:00:00", zone = "Z"] = match;
-    const seconds = time.length === 5 ? `${time}:00` : time;
-    const date = new Date(`${String(day)}T${seconds}${zone === "Z" ? "Z" : zone}`);
-    if (!Number.isFinite(dateMilliseconds(date))) {
-        throw new TypeError(`Invalid TIMESTAMP literal: ${text}`);
-    }
     return date;
 }
+/**
+ * Reads datetime text the way the TIMESTAMP literal does — a zoneless `2026-01-02 03:04:05` is
+ * UTC, never the host's zone — and falls back to the JavaScript parser for other spellings.
+ * `new Date("2026-01-02 03:04:05")` alone would read the same text in local time, so a CAST
+ * would answer differently on two machines.
+ */
+export function datetimeText(text) {
+    return parseSqlTimestampText(text) ?? new Date(text);
+}
 /** The parser's OFFSET range contract, shared with the typed builder. */
 export function validateOffset(offset) {
     if (!Number.isSafeInteger(offset) || offset < 0 || offset > 100_000_000)
@@ -9037,7 +9901,10 @@ function desugarWindows(sql, base, joins, select, predicates, groupBy, having, t
     const readableWhenGrouped = (expression) => hasAggregate(expression) ||
         expressionColumns(expression).length === 0 ||
         groupExpressions.has(JSON.stringify(expression));
-    const innerSelect = select.filter((item) => !containsWindow(item.expression));
+    const internalAliases = select.map((item, index) => item.alias.includes(".") ? `(window visible ${String(index + 1)})` : item.alias);
+    const innerSelect = select.flatMap((item, index) => containsWindow(item.expression)
+        ? []
+        : [{ ...item, alias: internalAliases[index] ?? item.alias }]);
     const windows = [];
     let hidden = 0;
     /** A name for one more column the inner block computes for the wrapper to read back. */
@@ -9099,21 +9966,52 @@ function desugarWindows(sql, base, joins, select, predicates, groupBy, having, t
         }
         return mapChildExpressions(expression, split);
     };
-    const projections = select.map((item) => {
+    const projections = select.map((item, index) => {
+        const internalAlias = internalAliases[index] ?? item.alias;
         if (!containsWindow(item.expression)) {
-            return { expression: { kind: "column", reference: item.alias }, alias: item.alias };
+            return {
+                expression: { kind: "column", reference: internalAlias },
+                alias: item.alias,
+            };
         }
-        // A window that is the whole select item keeps carrying that item's own name, which is what
-        // the executor's windowed source and every existing plan already expect.
+        // A window that is the whole select item carries a private source-safe name through the
+        // windowed source, then the wrapper restores the public output alias.
         if (item.expression.kind === "window") {
-            registerWindow(item.expression, item.alias);
-            return { expression: { kind: "column", reference: item.alias }, alias: item.alias };
+            registerWindow(item.expression, internalAlias);
+            return {
+                expression: { kind: "column", reference: internalAlias },
+                alias: item.alias,
+            };
         }
         return { expression: split(item.expression), alias: item.alias };
     });
     if (innerSelect.length === 0) {
         innerSelect.push({ expression: { kind: "literal", value: 1 }, alias: "(window 0)" });
     }
+    // Window evaluation replaces the FROM sources with one synthetic source. A qualified ORDER
+    // BY that names a selected column must therefore follow that value through its output alias;
+    // leaving `a.id` in the wrapper would try to resolve the vanished table alias `a`.
+    const windowTail = {
+        ...tail,
+        orderBy: tail.orderBy.map((order) => {
+            if (order.expression.kind !== "column")
+                return order;
+            const reference = order.expression.reference;
+            const bare = reference.split(".").at(-1) ?? reference;
+            const selectedIndex = select.findIndex((item) => item.alias === reference ||
+                item.alias === bare ||
+                (item.expression.kind === "column" && item.expression.reference === reference));
+            const selected = selectedIndex < 0 ? undefined : select[selectedIndex];
+            const projected = selectedIndex < 0 ? undefined : projections[selectedIndex];
+            const internalReference = projected?.expression.kind === "column" ? projected.expression.reference : selected?.alias;
+            return selected === undefined || internalReference === undefined
+                ? order
+                : {
+                    ...order,
+                    expression: { kind: "column", reference: internalReference },
+                };
+        }),
+    };
     const inner = {
         sql: "(window input)",
         base,
@@ -9136,7 +10034,7 @@ function desugarWindows(sql, base, joins, select, predicates, groupBy, having, t
         predicates: [],
         groupBy: [],
         having: [],
-        ...tail,
+        ...windowTail,
     };
 }
 /**
@@ -9349,6 +10247,29 @@ function tokenize(sql) {
             index += 2;
             continue;
         }
+        if (pair === "::") {
+            // PostgreSQL's postfix cast, `expression::type`.
+            push({ kind: "operator", text: "::", start: index, end: index + 2 });
+            index += 2;
+            continue;
+        }
+        if (pair === "!~") {
+            const text = sql[index + 2] === "*" ? "!~*" : "!~";
+            push({ kind: "operator", text, start: index, end: index + text.length });
+            index += text.length;
+            continue;
+        }
+        if (character === "~") {
+            const text = sql[index + 1] === "*" ? "~*" : "~";
+            push({ kind: "operator", text, start: index, end: index + text.length });
+            index += text.length;
+            continue;
+        }
+        if (character === "^") {
+            push({ kind: "operator", text: "^", start: index, end: index + 1 });
+            index += 1;
+            continue;
+        }
         if (["+", "-", "*", "/", "%", "=", ">", "<"].includes(character))
             push({ kind: "operator", text: character, start: index, end: index + 1 });
         else if (["(", ")", "[", "]", ",", "."].includes(character))