@minnowdb/core 0.6.9 → 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) {
@@ -903,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;
 }
 /**
@@ -1921,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"
@@ -2023,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";
             }
@@ -2079,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") {
@@ -4014,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;
@@ -4212,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)));
@@ -4240,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;
@@ -4259,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;
@@ -4285,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
@@ -4297,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);
+        }
     }
 }
 /**
@@ -4540,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 === "=")
@@ -4625,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)
@@ -4640,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}`);
         }
     }
@@ -4807,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. */
@@ -4925,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];
@@ -4949,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];
@@ -4969,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], ...). */
@@ -5153,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")) {
@@ -5165,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;
@@ -5379,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"))
@@ -5502,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,
@@ -5510,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. */
@@ -5559,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;
@@ -5641,13 +5930,18 @@ 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 = 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");
@@ -5658,6 +5952,7 @@ class Parser {
                 columns,
                 rows: [],
                 query,
+                ...this.#onConflictClause(table),
                 ...this.#returningClause(table),
             };
         }
@@ -5693,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 (;;) {
@@ -5753,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");
@@ -5761,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).
@@ -5915,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;
@@ -5932,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 = [];
@@ -5970,26 +6360,30 @@ class Parser {
         if (hasAggregate(expression) || expressionColumns(expression).length > 0) {
             throw new TypeError(`${label} must be constant expressions`);
         }
-        const needsExecution = (value) => (value.kind === "call" &&
-            (statementDatetimeNames.has(value.name) ||
-                value.name === "NEXTVAL" ||
-                value.name === "CURRVAL" ||
-                volatileScalarFunctionNames.has(value.name))) ||
+        // 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() {
@@ -6166,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")) {
@@ -6322,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")) {
@@ -6338,7 +6734,7 @@ class Parser {
                     break;
             }
         }
-        const orderBy = this.#orderByClause();
+        const orderBy = compoundMember ? [] : this.#orderByClause();
         return assembleSelectBlock({
             sql,
             base,
@@ -6349,7 +6745,7 @@ class Parser {
             groupBy,
             having,
             orderBy,
-            ...this.#tailClauses(),
+            ...(compoundMember ? {} : this.#tailClauses()),
             ...(groupingSets === undefined ? {} : { groupingSets }),
         }, this.nextDerivedSequence);
     }
@@ -6414,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") {
@@ -7143,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.
@@ -7665,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))
@@ -7718,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)
@@ -8211,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({
@@ -8267,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
@@ -8381,7 +8909,16 @@ export function assembleSelectBlock(parts, nextSequence) {
             ...(parts.distinct ? { distinctWildcard: true } : {}),
         };
     }
-    parts = { ...parts, orderBy: resolveOrderByOrdinals(parts.orderBy, parts.select) };
+    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);
     }
@@ -8399,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).
@@ -8490,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;
@@ -8739,7 +9306,21 @@ export function bindPendingSelectShapes(plan, columnsOf) {
         if (unknown !== undefined) {
             throw new TypeError(`SELECT * requires known columns for: ${unknown.source.table}`);
         }
-        const multiple = shaped.filter(({ columns }) => (columns?.length ?? 0) > 0).length > 1;
+        // 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];
@@ -8750,7 +9331,7 @@ export function bindPendingSelectShapes(plan, columnsOf) {
             }
             return selected.flatMap(({ source, columns }) => (columns ?? []).map((name) => ({
                 expression: { kind: "column", reference: `${source.alias}.${name}` },
-                alias: multiple ? `${source.alias}.${name}` : name,
+                alias: (contributed.get(name) ?? 0) > 1 ? `${source.alias}.${name}` : name,
             })));
         });
         const aliases = new Set();
@@ -9194,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;
 }
 /**
@@ -9266,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
@@ -9277,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)
@@ -9662,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))