@minnowdb/core 0.6.4 → 0.6.6

package/dist/engine/query.js

@@ -6,10 +6,10 @@ import { cachedQueryTerms, ftsBm25Row, FtsStatsAccumulator, ftsMatchTruth, rende
 import { QueryMemoryContext } from "./memory.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
 import { stringArgument } from "./sql-semantics.js";
-import { jsonAtPath, jsonConstructor, jsonIsValid, parseJsonPath } from "./sql-json.js";
+import { 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";
-import { arrayDomainValue, boundedJsonText, collatedDomainValue, dateDomainValue, exactNumericBinary, exactNumericValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, preservedJsonDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue, } from "./sql-domains.js";
+import { arrayDomainValue, boundedJsonText, collatedDomainValue, concatenatedSqlValue, dateDomainValue, exactNumericAsNumber, exactNumericBinary, exactNumericLiteral, exactNumericValue, externalSqlDomainColumnValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, preservedJsonDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue, } from "./sql-domains.js";
 import { columnarTableFromRows, prepareVectorQuery, } from "./vector.js";
 /** Domain metadata for an execution path that has no catalog-backed type information. */
 export function unknownColumnDomains(columns) {
@@ -62,6 +62,8 @@ export const scalarFunctionNames = new Set([
     "JSON_ARRAY",
     "IS_JSON",
     "ARRAY",
+    "MINNOW_JSON_GET",
+    "MINNOW_JSON_GET_TEXT",
     "MINNOW_TUPLE_KEY",
     "MINNOW_COLLATE",
     "NEXTVAL",
@@ -79,7 +81,7 @@ export const volatileScalarFunctionNames = new Set([
  * reading, so they are resolved once per execution rather than evaluated per row: every row of
  * one statement sees one instant, both executors agree, and constant folding leaves them alone.
  */
-export const statementDatetimeNames = new Set([
+const statementDatetimeNames = new Set([
     "CURRENT_DATE",
     "CURRENT_TIMESTAMP",
     "LOCALTIME",
@@ -167,16 +169,20 @@ function castValue(value, target) {
             return protectedSqlTextValue(dateIsoString(value));
     }
     if (target === "number" || target === "number-integer") {
+        // Externalize first, exactly as the string and datetime targets do: a NUMERIC (or other
+        // domain) value is an internally tagged string, and CAST(numeric_column AS DOUBLE
+        // PRECISION) must read its decimal text, not fail on the tag (T703).
+        const external = externalSqlDomainValue(value);
         let parsed;
-        if (typeof value === "number")
-            parsed = value;
-        else if (typeof value === "boolean")
-            parsed = value ? 1 : 0;
-        else if (typeof value === "string") {
-            const text = value.trim();
+        if (typeof external === "number")
+            parsed = external;
+        else if (typeof external === "boolean")
+            parsed = external ? 1 : 0;
+        else if (typeof external === "string") {
+            const text = external.trim();
             const candidate = text === "" ? Number.NaN : Number(text);
             if (!Number.isFinite(candidate)) {
-                throw new TypeError(`Cannot cast this string to a number: ${value}`);
+                throw new TypeError(`Cannot cast this string to a number: ${text}`);
             }
             parsed = candidate;
         }
@@ -201,12 +207,13 @@ function castValue(value, target) {
             throw new TypeError(`Only 0 and 1 cast to boolean, got ${String(value)}`);
         }
         if (typeof value === "string") {
-            const text = value.trim().toLowerCase();
+            const external = externalSqlDomainValue(value);
+            const text = typeof external === "string" ? external.trim().toLowerCase() : "";
             if (text === "true" || text === "t" || text === "1")
                 return true;
             if (text === "false" || text === "f" || text === "0")
                 return false;
-            throw new TypeError(`Cannot cast this string to a boolean: ${value}`);
+            throw new TypeError(`Cannot cast this string to a boolean: ${typeof external === "string" ? external : value}`);
         }
     }
     if (target === "datetime") {
@@ -396,6 +403,27 @@ export function scalarFunctionValue(name, values) {
             // JSON_QUERY returns JSON text, so a selected string keeps its quotes.
             return preservedJsonDomainValue(JSON.stringify(found.value));
         }
+        case "MINNOW_JSON_GET": {
+            if (values[1] === null || values[1] === undefined)
+                return null;
+            const found = jsonArrowStep(first, values[1], "->");
+            if (!found.found)
+                return null;
+            // -> returns a JSON value: a selected string keeps its quotes, a JSON null is the
+            // one-character document "null" rather than SQL NULL, exactly as PostgreSQL has it.
+            return preservedJsonDomainValue(JSON.stringify(found.value));
+        }
+        case "MINNOW_JSON_GET_TEXT": {
+            if (values[1] === null || values[1] === undefined)
+                return null;
+            const found = jsonArrowStep(first, values[1], "->>");
+            // ->> returns text: strings unquoted, other scalars as their JSON rendering, objects
+            // and arrays serialized, and a JSON null as SQL NULL.
+            if (!found.found || found.value === null || found.value === undefined)
+                return null;
+            const value = found.value;
+            return protectedSqlTextValue(typeof value === "string" ? value : JSON.stringify(value));
+        }
         case "LPAD":
         case "RPAD": {
             if (values[1] === null || values[1] === undefined)
@@ -579,7 +607,7 @@ function assertReplacementResultLength(source, search, replacement) {
         throw new RangeError(`REPLACE result exceeds ${String(MAX_SQL_SCALAR_RESULT_CHARACTERS)} characters`);
     }
 }
-export const dateTruncUnits = new Set([
+const dateTruncUnits = new Set([
     "year",
     "quarter",
     "month",
@@ -609,7 +637,7 @@ const intervalUnits = new Map([
  * rather than converted, because a month is not a fixed number of them: adding one to January 31
  * has to land on the end of February, which only calendar arithmetic can do.
  */
-export function intervalLiteral(text) {
+function intervalLiteral(text) {
     let months = 0;
     let milliseconds = 0;
     let matched = 0;
@@ -635,7 +663,7 @@ export function intervalLiteral(text) {
  * does not exist in the target month clamps to that month's last day, which is what both SQLite
  * and PostgreSQL do with 31 January plus a month.
  */
-export function dateAddValue(value, months, milliseconds) {
+function dateAddValue(value, months, milliseconds) {
     if (value === null || value === undefined)
         return null;
     const calendarDate = isDateDomainValue(value);
@@ -662,7 +690,7 @@ export function dateAddValue(value, months, milliseconds) {
         ? dateDomainValue(dateIsoString(result).slice(0, 10))
         : result;
 }
-export function dateTruncValue(unit, value) {
+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");
     }
@@ -860,6 +888,7 @@ export function compileQuery(sql, options = {}) {
     }
     let compiled;
     try {
+        resolvePlanExactNumericConstants(plan);
         compiled = options.optimize === false ? plan : optimizePlan(plan);
     }
     catch (error) {
@@ -967,7 +996,7 @@ export function compileCheckExpression(sql, name) {
     if (hasAggregate(expression) || containsWindow(expression) || containsParameter(expression)) {
         throw new TypeError(`CHECK ${name} takes a row condition over this table's own columns`);
     }
-    return expression;
+    return resolveExactNumericConstants(expression);
 }
 /**
  * Parses and type-checks one catalog default. PostgreSQL defaults are variable-free scalar
@@ -1314,6 +1343,22 @@ export function evaluateJoinedRowExpression(expression, rows) {
 export function evaluateRowExpression(expression, alias, row) {
     return asQueryValue(evaluate(expression, { [alias]: row }));
 }
+/**
+ * Wraps one value from an executed subquery block as a substituted literal. Block results are
+ * internal: domain values keep their tags and protected text keeps its wrapper. The literal must
+ * say so — an unmarked string literal is re-protected as user text at evaluation, which both
+ * leaks the internal tag into the outer result and makes equality against internal column
+ * values never match (T694: `WHERE amount = (SELECT amount ...)` on a NUMERIC column returned
+ * no rows). Carrying the block's column domain also keeps the outer result's domain metadata.
+ */
+function substitutedResultLiteral(value, sqlDomain) {
+    return {
+        kind: "literal",
+        value: value ?? null,
+        ...(typeof value === "string" ? { internalSqlValue: true } : {}),
+        ...(sqlDomain === null || sqlDomain === undefined ? {} : { sqlDomain }),
+    };
+}
 /**
  * Clones a plan and returns its subquery sites in post-order: executing each step's block and
  * substituting its result leaves the returned plan free of subquery nodes. A scalar subquery must
@@ -1338,10 +1383,7 @@ export function subqueryResolutionSteps(plan) {
                     if (result.rows.length > 1) {
                         throw new TypeError(`A scalar subquery returned ${String(result.rows.length)} rows`);
                     }
-                    replace({
-                        kind: "literal",
-                        value: result.rows[0]?.[result.columns[0] ?? ""] ?? null,
-                    });
+                    replace(substitutedResultLiteral(result.rows[0]?.[result.columns[0] ?? ""], result.columnDomains[0]));
                 },
             });
             return;
@@ -1412,10 +1454,7 @@ export function subqueryResolutionSteps(plan) {
                         }
                         expression.right = {
                             kind: "list",
-                            items: result.rows.map((row) => ({
-                                kind: "literal",
-                                value: row[result.columns[0] ?? ""] ?? null,
-                            })),
+                            items: result.rows.map((row) => substitutedResultLiteral(row[result.columns[0] ?? ""], result.columnDomains[0])),
                         };
                     },
                 });
@@ -1458,10 +1497,7 @@ export function subqueryResolutionSteps(plan) {
                         }
                         predicate.right = {
                             kind: "list",
-                            items: result.rows.map((row) => ({
-                                kind: "literal",
-                                value: row[result.columns[0] ?? ""] ?? null,
-                            })),
+                            items: result.rows.map((row) => substitutedResultLiteral(row[result.columns[0] ?? ""], result.columnDomains[0])),
                         };
                     },
                 });
@@ -1494,7 +1530,7 @@ export function blockHasSubqueries(plan) {
     return blockHas(plan);
 }
 /** True when any `?`/`$n` placeholder remains anywhere in the expression tree. */
-export function containsParameter(expression) {
+function containsParameter(expression) {
     if (expression.kind === "parameter")
         return true;
     if (expression.kind === "subquery" || expression.kind === "exists") {
@@ -1502,7 +1538,7 @@ export function containsParameter(expression) {
     }
     return childExpressions(expression).some(containsParameter);
 }
-export function blockHasParameters(block) {
+function blockHasParameters(block) {
     if (block.limitParameter !== undefined ||
         block.offsetParameter !== undefined ||
         (block.limitValidationParameters?.length ?? 0) > 0 ||
@@ -1886,7 +1922,8 @@ export function inferBlockSchema(plan, schemas) {
         if (expression.name === "JSON_ARRAYAGG" ||
             expression.name === "JSON_QUERY" ||
             expression.name === "JSON_OBJECT" ||
-            expression.name === "JSON_ARRAY") {
+            expression.name === "JSON_ARRAY" ||
+            expression.name === "MINNOW_JSON_GET") {
             return { kind: "json" };
         }
         if (expression.name === "GEN_RANDOM_UUID")
@@ -2025,6 +2062,8 @@ export function inferBlockSchema(plan, schemas) {
             expression.name === "JSON_OBJECT" ||
             expression.name === "JSON_ARRAY" ||
             expression.name === "ARRAY" ||
+            expression.name === "MINNOW_JSON_GET" ||
+            expression.name === "MINNOW_JSON_GET_TEXT" ||
             expression.name === "MINNOW_TUPLE_KEY" ||
             expression.name === "MINNOW_COLLATE" ||
             expression.name === "GEN_RANDOM_UUID") {
@@ -2953,12 +2992,188 @@ export function expandFtsColumns(plan, searchableColumnsFor) {
     expandBlock(plan);
     return plan;
 }
+/**
+ * Annotates every `AVG(column)` in this block's expression positions with the argument column's
+ * declared NUMERIC scale, resolved against the given schemas. PostgreSQL floors an AVG's
+ * internal division scale at the summed values' display scale; the canonical NUMERIC encoding
+ * strips trailing fractional zeros, so without the annotation the divide cannot know the digits
+ * a declared scale above its own selection would render, and the display padding would fabricate
+ * zeros where PostgreSQL computes real digits. Runs where the catalog is known, per block —
+ * nested blocks execute through their own schema-aware entry. Copy-on-write: plans without an
+ * AVG pass through untouched, and the input is often the compile cache's own object.
+ */
+export function annotateAvgArgumentScales(plan, schemas) {
+    const containsAvg = (expression) => (expression.kind === "call" && expression.name === "AVG") ||
+        childExpressions(expression).some(containsAvg);
+    const roots = [];
+    forEachBlockExpression(plan, (expression) => roots.push(expression));
+    if (!roots.some(containsAvg))
+        return plan;
+    plan = clonePlanTree(plan);
+    const sources = [plan.base, ...plan.joins];
+    const declaredScale = (reference) => {
+        const parts = reference.split(".");
+        const matches = parts.length === 2
+            ? sources
+                .filter(({ alias }) => alias === parts[0])
+                .flatMap((source) => (schemas.get(source.table) ?? []).filter(({ name }) => name === parts[1]))
+            : sources.flatMap((source) => (schemas.get(source.table) ?? []).filter(({ name }) => name === parts[0]));
+        const domain = matches.length === 1 ? matches[0]?.sqlDomain : undefined;
+        return domain?.kind === "numeric" ? domain.scale : undefined;
+    };
+    const annotate = (expression) => {
+        if (expression.kind === "call" && expression.name === "AVG") {
+            const argument = expression.arguments[0];
+            if (argument?.kind === "column") {
+                const scale = declaredScale(argument.reference);
+                if (scale !== undefined && scale > 0)
+                    expression.avgArgumentScale = scale;
+            }
+        }
+        for (const child of childExpressions(expression))
+            annotate(child);
+    };
+    forEachBlockExpression(plan, annotate);
+    return plan;
+}
+/**
+ * The exact fold of a constant arithmetic subtree, or undefined where none applies. PostgreSQL
+ * types every decimal constant — and every integer constant too large for its integer types —
+ * as NUMERIC, so arithmetic among constants happens in exact decimal space before any float8
+ * context sees the result: `0.1 + 0.2` is exactly 0.3. A subtree folds only when it is
+ * "seeded" by such a constant (one carrying exact digits); pure safe-integer arithmetic keeps
+ * its historical Float64 evaluation, including non-truncating division.
+ */
+function exactConstantFold(expression) {
+    if (expression.kind === "literal") {
+        if (expression.exactText !== undefined) {
+            return { value: exactNumericLiteral(expression.exactText), seeded: true };
+        }
+        const value = expression.value;
+        if (typeof value === "string" && expression.sqlDomain?.kind === "numeric") {
+            return isExactNumeric(value) ? { value, seeded: true } : undefined;
+        }
+        if (typeof value === "number" && Number.isFinite(value))
+            return { value, seeded: false };
+        if (value === null)
+            return { value: null, seeded: false };
+        return undefined;
+    }
+    if (expression.kind !== "binary" || expression.operator === "||")
+        return undefined;
+    const left = exactConstantFold(expression.left);
+    if (left === undefined)
+        return undefined;
+    const right = exactConstantFold(expression.right);
+    if (right === undefined)
+        return undefined;
+    const seeded = left.seeded || right.seeded;
+    if (left.value === null || right.value === null)
+        return { value: null, seeded };
+    const folded = exactNumericBinary(expression.operator, left.value, right.value, 0, false);
+    return folded === undefined ? undefined : { value: folded, seeded };
+}
+/**
+ * Rewrites every seeded constant arithmetic subtree of this expression to its exact fold. A
+ * folded value demotes back to an ordinary number literal when it reads back identically from
+ * a Float64 — PostgreSQL's own cast when a numeric constant meets a float8 operand, and it
+ * keeps every number-typed fast path — and stays a tagged exact-NUMERIC literal when the
+ * number boundary would visibly round it. A fold that overflows its bounds is left unfolded
+ * for execution to report.
+ */
+function resolveExactNumericConstants(expression) {
+    let folded;
+    try {
+        folded = exactConstantFold(expression);
+    }
+    catch {
+        folded = undefined;
+    }
+    if (folded?.seeded === true) {
+        const value = folded.value;
+        if (value === null || typeof value === "number")
+            return { kind: "literal", value };
+        const fits = exactNumericAsNumber(value);
+        if (fits !== undefined)
+            return { kind: "literal", value: fits };
+        return { kind: "literal", value, internalSqlValue: true, sqlDomain: { kind: "numeric" } };
+    }
+    if (expression.kind === "subquery" || expression.kind === "exists") {
+        resolvePlanExactNumericConstants(expression.block);
+        return expression;
+    }
+    if (expression.kind === "window") {
+        return {
+            ...expression,
+            partitionBy: expression.partitionBy.map(resolveExactNumericConstants),
+            orderBy: expression.orderBy.map((order) => ({
+                ...order,
+                expression: resolveExactNumericConstants(order.expression),
+            })),
+            ...(expression.argument === undefined
+                ? {}
+                : { argument: resolveExactNumericConstants(expression.argument) }),
+        };
+    }
+    return mapChildExpressions(expression, resolveExactNumericConstants);
+}
+/** Applies `resolveExactNumericConstants` to every expression of a plan, nested blocks included. */
+function resolvePlanExactNumericConstants(plan) {
+    mapBlockExpressions(plan, resolveExactNumericConstants);
+    forEachNestedBlock(plan, resolvePlanExactNumericConstants);
+}
+/**
+ * The statement counterpart of `resolvePlanExactNumericConstants`: every expression slot a
+ * mutation evaluates later. INSERT VALUES cells are absent because the parser evaluates them
+ * to values on the spot, resolving each expression first.
+ */
+function resolveStatementExactNumericConstants(statement) {
+    const resolve = resolveExactNumericConstants;
+    if (statement.kind === "insert") {
+        const conflict = statement.onConflict;
+        if (conflict?.assignments !== undefined) {
+            for (const assignment of conflict.assignments) {
+                assignment.expression = resolve(assignment.expression);
+            }
+        }
+        if (conflict?.where !== undefined)
+            conflict.where = resolve(conflict.where);
+        return;
+    }
+    if (statement.kind === "update" || statement.kind === "delete") {
+        if (statement.kind === "update") {
+            for (const assignment of statement.assignments) {
+                assignment.expression = resolve(assignment.expression);
+            }
+        }
+        for (const predicate of statement.predicates) {
+            predicate.left = resolve(predicate.left);
+            predicate.right = resolve(predicate.right);
+        }
+        return;
+    }
+    if (statement.kind === "merge") {
+        statement.on = resolve(statement.on);
+        for (const branch of statement.branches) {
+            if (branch.condition !== undefined)
+                branch.condition = resolve(branch.condition);
+            if (branch.action.kind === "update") {
+                for (const assignment of branch.action.assignments) {
+                    assignment.expression = resolve(assignment.expression);
+                }
+            }
+            if (branch.action.kind === "insert") {
+                branch.action.values = branch.action.values.map(resolve);
+            }
+        }
+    }
+}
 /**
  * Aggregates the frame members named by position, for the frames whose rows are not contiguous.
  * EXCLUDE puts a hole in the middle of a frame, which the prefix sums the common path uses
  * cannot represent, so those positions walk their members instead.
  */
-function aggregateWindowMembers(window, values, members) {
+function aggregateWindowMembers(window, values, members, avgScale) {
     const present = members.filter((member) => {
         const value = values[member];
         return value !== null && value !== undefined;
@@ -2988,7 +3203,9 @@ function aggregateWindowMembers(window, values, members) {
                     throw new Error("Exact NUMERIC sum disappeared");
                 total = next;
             }
-            return window.name === "SUM" ? total : exactNumericBinary("/", total, present.length);
+            return window.name === "SUM"
+                ? total
+                : exactNumericBinary("/", total, present.length, avgScale);
         }
         const total = present.reduce((sum, member) => sum + numeric(values[member]), 0);
         return window.name === "SUM" ? total : total / present.length;
@@ -3013,7 +3230,7 @@ function aggregateWindowMembers(window, values, members) {
  * RANGE frames take only UNBOUNDED and CURRENT ROW bounds, where CURRENT ROW spans the peer
  * group. COUNT of an empty frame is 0 and every other aggregate NULL.
  */
-function applyAggregateWindow(rows, indexes, window, samePartition, sameOrderKeys) {
+function applyAggregateWindow(rows, indexes, window, samePartition, sameOrderKeys, avgScale) {
     const frame = window.frame ?? {
         unit: "range",
         start: { kind: "unbounded-preceding" },
@@ -3025,11 +3242,11 @@ function applyAggregateWindow(rows, indexes, window, samePartition, sameOrderKey
         while (end < indexes.length && samePartition(indexes[start] ?? 0, indexes[end] ?? 0)) {
             end += 1;
         }
-        applyAggregateWindowPartition(rows, indexes, window, frame, sameOrderKeys, start, end);
+        applyAggregateWindowPartition(rows, indexes, window, frame, sameOrderKeys, start, end, avgScale);
         start = end;
     }
 }
-function applyAggregateWindowPartition(rows, indexes, window, frame, sameOrderKeys, start, end) {
+function applyAggregateWindowPartition(rows, indexes, window, frame, sameOrderKeys, start, end, avgScale) {
     const size = end - start;
     // Peer-group bounds per position; with no OVER ordering the whole partition is one peer group.
     const peerStart = new Array(size).fill(0);
@@ -3160,7 +3377,7 @@ function applyAggregateWindowPartition(rows, indexes, window, frame, sameOrderKe
                 if (!dropped)
                     members.push(member);
             }
-            value = aggregateWindowMembers(window, values, members);
+            value = aggregateWindowMembers(window, values, members, avgScale);
             const row = rows[indexes[start + position] ?? -1];
             if (row !== undefined)
                 row[window.alias] = asQueryValue(value);
@@ -3192,7 +3409,7 @@ function applyAggregateWindowPartition(rows, indexes, window, frame, sameOrderKe
             }
             else if (prefixExact !== undefined) {
                 const total = exactNumericBinary("-", prefixExact[high] ?? exactZero, prefixExact[low] ?? exactZero);
-                value = window.name === "SUM" ? total : exactNumericBinary("/", total, nonNull);
+                value = window.name === "SUM" ? total : exactNumericBinary("/", total, nonNull, avgScale);
             }
             else {
                 const total = (prefixSum?.[high] ?? 0) - (prefixSum?.[low] ?? 0);
@@ -3369,7 +3586,13 @@ export function applyWindowFunctions(result, windows, options = {}) {
             continue;
         }
         if (window.name !== "ROW_NUMBER" && window.name !== "RANK" && window.name !== "DENSE_RANK") {
-            applyAggregateWindow(rows, indexes, window, samePartition, sameOrderKeys);
+            // PostgreSQL computes a window AVG's quotient to at least the summed values' display
+            // scale; canonical NUMERIC values no longer carry it, so read the argument column's
+            // declared scale from the inner result the way the summed dscale would have carried it.
+            const argumentDomain = window.name === "AVG" && window.argumentAlias !== undefined
+                ? result.columnDomains[result.columns.indexOf(window.argumentAlias)]
+                : undefined;
+            applyAggregateWindow(rows, indexes, window, samePartition, sameOrderKeys, argumentDomain?.kind === "numeric" ? argumentDomain.scale : undefined);
             continue;
         }
         let rowNumber = 0;
@@ -3781,7 +4004,7 @@ function evaluate(expression, context, group) {
                 if (typeof left !== "string" || typeof right !== "string") {
                     throw new TypeError("|| requires string operands");
                 }
-                return protectedSqlTextValue(String(externalSqlDomainValue(left)) + String(externalSqlDomainValue(right)));
+                return concatenatedSqlValue(left, right);
             }
             const exact = exactNumericBinary(expression.operator, left, right);
             if (exact !== undefined)
@@ -3925,7 +4148,8 @@ function evaluate(expression, context, group) {
                         ? null
                         : (() => {
                             const sum = sumNumericValues(values);
-                            return exactNumericBinary("/", sum, values.length) ?? numeric(sum) / values.length;
+                            return (exactNumericBinary("/", sum, values.length, expression.avgArgumentScale) ??
+                                numeric(sum) / values.length);
                         })();
                 if (expression.name === "MIN")
                     return values.reduce((best, value) => (best === undefined || compareValues(value, best) < 0 ? value : best), undefined);
@@ -4378,6 +4602,11 @@ export function hasAggregate(expression) {
     }
     return childExpressions(expression).some(hasAggregate);
 }
+function hasWindow(expression) {
+    if (expression.kind === "window")
+        return true;
+    return childExpressions(expression).some(hasWindow);
+}
 /** One root aggregate call, using the same canonical set as parsing and execution. */
 export function isAggregateCall(expression) {
     return expression.kind === "call" && aggregateNames.has(expression.name);
@@ -4478,9 +4707,6 @@ function asQueryValue(value) {
         return null;
     throw new TypeError("Query produced an unsupported value");
 }
-function asExternalQueryValue(value) {
-    return asQueryValue(externalSqlDomainValue(value));
-}
 const alreadyExternalResults = new WeakSet();
 function markExternalizationState(result, outputNeedsExternalization) {
     if (outputNeedsExternalization === false)
@@ -4505,11 +4731,12 @@ export function externalizeQueryResult(result) {
         // Ordinary primitive results are already public values. Most queries never touch one of the
         // tagged PostgreSQL domains, so keep their row objects and avoid rebuilding a large result
         // set merely to discover that every value is unchanged.
-        for (const name of result.columns) {
+        for (let position = 0; position < result.columns.length; position += 1) {
+            const name = result.columns[position] ?? "";
             const value = row[name];
             if (value !== undefined && !isSqlDomainValue(value))
                 continue;
-            const external = asExternalQueryValue(value);
+            const external = asQueryValue(externalSqlDomainColumnValue(value, result.columnDomains[position]));
             if (external === value)
                 continue;
             if (output === row)
@@ -5272,6 +5499,14 @@ class Parser {
             },
         };
     }
+    /** A type name's precision, scale, or width: plain digits, as PostgreSQL requires there. */
+    #typeWidth() {
+        const token = this.#take("number");
+        if (!/^\d+$/.test(token.text)) {
+            throw new SqlCompileError(`A type width must be an integer: ${token.text}`, token.start, token.end - token.start);
+        }
+        return Number(token.text);
+    }
     /** A CAST target: the SqlColumnType, or "number-integer" for the truncating integer names. */
     #castTarget() {
         const word = this.#identifier().toUpperCase();
@@ -5279,9 +5514,9 @@ class Parser {
             let precision;
             let scale;
             if (this.#punctuation("(")) {
-                precision = Number(this.#take("number").text);
+                precision = this.#typeWidth();
                 if (this.#punctuation(","))
-                    scale = Number(this.#take("number").text);
+                    scale = this.#typeWidth();
                 else
                     scale = 0;
                 this.#expectPunctuation(")");
@@ -5299,9 +5534,9 @@ class Parser {
         if (mapped === undefined)
             throw new TypeError(`Unsupported CAST target: ${word}`);
         if (this.#punctuation("(")) {
-            this.#take("number");
+            this.#typeWidth();
             if (this.#punctuation(","))
-                this.#take("number");
+                this.#typeWidth();
             this.#expectPunctuation(")");
         }
         const integer = word === "INTEGER" || word === "INT" || word === "BIGINT" || word === "SMALLINT";
@@ -5314,8 +5549,8 @@ class Parser {
             let precision;
             let scale;
             if (this.#punctuation("(")) {
-                precision = Number(this.#take("number").text);
-                scale = this.#punctuation(",") ? Number(this.#take("number").text) : 0;
+                precision = this.#typeWidth();
+                scale = this.#punctuation(",") ? this.#typeWidth() : 0;
                 this.#expectPunctuation(")");
             }
             return {
@@ -5340,7 +5575,7 @@ class Parser {
         }
         // Character widths document intent and do not truncate values.
         if (this.#punctuation("(")) {
-            this.#take("number");
+            this.#typeWidth();
             if (this.#punctuation(",")) {
                 throw new TypeError(`${word} takes one width`);
             }
@@ -5360,6 +5595,7 @@ class Parser {
                 ? this.#updateStatement()
                 : this.#deleteStatement();
         this.#take("eof");
+        resolveStatementExactNumericConstants(statement);
         return statement;
     }
     #insertStatement() {
@@ -5392,7 +5628,9 @@ class Parser {
             };
         }
         if (this.#isKeyword("SELECT")) {
-            const query = optimizePlan(this.#selectBlock("(insert select)"));
+            const insertSource = this.#selectBlock("(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");
             }
@@ -5655,7 +5893,9 @@ class Parser {
             throw new TypeError("MERGE does not support RETURNING; read the rows back with a SELECT");
         }
         this.#take("eof");
-        return { kind: "merge", table, alias, source, on, branches };
+        const statement = { kind: "merge", table, alias, source, on, branches };
+        resolveStatementExactNumericConstants(statement);
+        return statement;
     }
     #updateStatement() {
         this.#keyword("UPDATE");
@@ -5715,7 +5955,7 @@ class Parser {
         if (hasAggregate(expression) || expressionColumns(expression).length > 0) {
             throw new TypeError(`${label} must be constant expressions`);
         }
-        return asQueryValue(evaluate(expression, {}));
+        return asQueryValue(evaluate(resolveExactNumericConstants(expression), {}));
     }
     #unionMember(sql) {
         if (this.#punctuation("(")) {
@@ -6896,17 +7136,41 @@ class Parser {
                 continue;
             }
             const operator = this.#peek().text;
-            // || binds loosest, matching PostgreSQL: concatenation applies to whole arithmetic terms.
+            // A bracket after a complete expression is PostgreSQL's array subscript, which has no
+            // other reading in this grammar — name the missing feature instead of "Expected eof".
+            if (operator === "[") {
+                throw new TypeError("Array subscripts are not supported");
+            }
+            // || 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 === "->" || operator === "->>"
                         ? 5
                         : -1;
             if (precedence < minimumPrecedence)
                 break;
             this.#index += 1;
+            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.
+                if (key.kind === "literal" && typeof key.value === "number") {
+                    if (!Number.isInteger(key.value)) {
+                        throw new TypeError(`${operator} array positions are integers`);
+                    }
+                }
+                else if (key.kind === "literal" && typeof key.value === "boolean") {
+                    throw new TypeError(`${operator} keys are member names or array positions`);
+                }
+                left = {
+                    kind: "call",
+                    name: operator === "->" ? "MINNOW_JSON_GET" : "MINNOW_JSON_GET_TEXT",
+                    arguments: [left, key],
+                };
+                continue;
+            }
             // `placed_at + INTERVAL '1 month'`. An interval is not a value any column can hold, so it
             // never becomes an expression of its own: it is read here, where the thing it applies to is
             // already in hand, and folds into the date arithmetic DATE_ADD performs.
@@ -6966,10 +7230,29 @@ class Parser {
         if (token.kind === "number") {
             this.#index += 1;
             const value = Number(token.text);
-            if (!token.text.includes(".") && !Number.isSafeInteger(value)) {
-                throw new SqlCompileError(`Integer literal is outside the exact safe range: ${token.text}`, token.start, token.end - token.start);
+            // A safe integer spelled as one is exactly itself; every other spelling — a decimal
+            // point, an exponent, or digits beyond 2^53 — is a numeric constant PostgreSQL would
+            // type NUMERIC. Keep its exact digits: as an annotation when the value reads back
+            // identically from a number, or as a tagged exact-NUMERIC literal when it would not.
+            if (!/[.eE]/.test(token.text) && Number.isSafeInteger(value)) {
+                return { kind: "literal", value };
+            }
+            let tagged;
+            try {
+                tagged = exactNumericLiteral(token.text);
             }
-            return { kind: "literal", value };
+            catch (error) {
+                throw new SqlCompileError(error instanceof Error ? error.message : `Invalid number: ${token.text}`, token.start, token.end - token.start);
+            }
+            const fits = exactNumericAsNumber(tagged);
+            if (fits !== undefined)
+                return { kind: "literal", value: fits, exactText: token.text };
+            return {
+                kind: "literal",
+                value: tagged,
+                internalSqlValue: true,
+                sqlDomain: { kind: "numeric" },
+            };
         }
         if (token.kind === "string") {
             this.#index += 1;
@@ -7380,7 +7663,9 @@ class Parser {
             const name = (upper === "ANY_VALUE" ? "MIN" : (functionSpellings.get(upper) ?? upper));
             if (name === "MINNOW_TUPLE_KEY" ||
                 name === "MINNOW_COLLATE" ||
-                name === "MINNOW_SINGLE_VALUE") {
+                name === "MINNOW_SINGLE_VALUE" ||
+                name === "MINNOW_JSON_GET" ||
+                name === "MINNOW_JSON_GET_TEXT") {
                 throw new TypeError(`Unsupported function: ${identifier}`);
             }
             if (!aggregateNames.has(name) && !scalarFunctionNames.has(name))
@@ -8058,6 +8343,8 @@ export function assembleSelectBlock(parts, 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)
@@ -8136,7 +8423,7 @@ export function assembleSelectBlock(parts, nextSequence) {
  * over those same columns provides the deduplication through the grouped executor. Runs
  * exactly once per execution entry, like MATCH(*) expansion.
  */
-export function expandDistinctWildcard(plan, columnsOf) {
+function expandDistinctWildcard(plan, columnsOf) {
     if (plan.distinctWildcard !== true)
         return plan;
     const shaped = [plan.base, ...plan.joins].map((source) => ({
@@ -8228,7 +8515,7 @@ export function planHasSourceColumnAliases(plan) {
  * scan cannot know whether the next row ties — and the ordered result is trimmed here: rows up
  * to the limit, plus every following row equal to the last one on all ORDER BY columns.
  */
-export function withTiesPlan(plan) {
+function withTiesPlan(plan) {
     // Ordering by an expression or an unselected column wraps the real block in a projection that
     // hides the sort column. The tie test needs that column, so the inner block runs and the
     // projection is applied after trimming instead of before.
@@ -8415,7 +8702,7 @@ export function expandSourceColumnAliases(plan, columnsOf) {
  * one source, and `alias.column` when it reads several, so two sources cannot collide.
  * Runs once per execution entry, like MATCH(*) and DISTINCT * expansion.
  */
-export function expandQualifiedWildcards(plan, columnsOf) {
+function expandQualifiedWildcards(plan, columnsOf) {
     const qualified = (block) => {
         if (block.select.some((item) => item.expression.kind === "wildcard" && item.expression.table))
             return true;
@@ -8691,7 +8978,7 @@ function jsonTableColumnValue(column, value) {
     }
     return date;
 }
-export function timestampLiteral(text) {
+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)
@@ -8865,13 +9152,14 @@ function defaultAlias(expression) {
     return "expression";
 }
 /**
- * Whether a numeric literal's digits are well formed: at most one decimal point (radix 10 only)
- * and underscores only between digits, never leading, trailing, or doubled (T662).
+ * Whether a numeric literal's digits are well formed: at most one decimal point and an optional
+ * exponent (radix 10 only), and underscores only between digits, never leading, trailing, or
+ * doubled (T662). Exponent digits are plain, as in PostgreSQL.
  */
 function validNumericLiteral(text, radix) {
     const digits = radix === 16 ? "0-9a-fA-F" : radix === 8 ? "0-7" : radix === 2 ? "01" : "0-9";
     const group = `[${digits}]+(?:_[${digits}]+)*`;
-    const pattern = radix === 10 ? `^${group}(?:\\.${group})?$` : `^${group}$`;
+    const pattern = radix === 10 ? `^${group}(?:\\.${group})?(?:[eE][+-]?\\d+)?$` : `^${group}$`;
     return new RegExp(pattern).test(text);
 }
 function tokenize(sql) {
@@ -8929,6 +9217,16 @@ function tokenize(sql) {
             // T662: underscores may separate digits.
             while (index < sql.length && /[\d._]/.test(sql[index] ?? ""))
                 index += 1;
+            // Scientific notation: an exponent marker joins the token only when digits follow, so
+            // `1e2` is the numeric constant 100 while `SELECT 1 e` still reads `e` as an alias.
+            if (/[eE]/.test(sql[index] ?? "")) {
+                const signed = /[+-]/.test(sql[index + 1] ?? "") ? 1 : 0;
+                if (/\d/.test(sql[index + 1 + signed] ?? "")) {
+                    index += 2 + signed;
+                    while (index < sql.length && /\d/.test(sql[index] ?? ""))
+                        index += 1;
+                }
+            }
             const text = sql.slice(start, index);
             if (!validNumericLiteral(text, 10))
                 throw new SqlCompileError(`Invalid number: ${text}`, start, index - start);
@@ -9022,7 +9320,12 @@ function tokenize(sql) {
             index += 1;
             continue;
         }
-        if ([">=", "<=", "!=", "<>", "||"].includes(pair)) {
+        if (pair === "->" && sql[index + 2] === ">") {
+            push({ kind: "operator", text: "->>", start: index, end: index + 3 });
+            index += 3;
+            continue;
+        }
+        if ([">=", "<=", "!=", "<>", "||", "->"].includes(pair)) {
             push({ kind: "operator", text: pair, start: index, end: index + 2 });
             index += 2;
             continue;