@minnowdb/core 0.6.7 → 0.6.9

package/README.md

@@ -17,7 +17,7 @@ npm install @minnowdb/core
 - A ready-made worker client with the same everyday database API.
 - TypeScript schema declarations and metadata-only migrations, including SQL domains,
   composite primary/foreign keys, and informational relationships.
-- Guarded columnar upserts, result-column SQL domains, typed catalog errors, and batch writes.
+- Batch and upsert write APIs, typed catalog errors, and per-column result type metadata.
 - Pull-driven query cursors, live queries, snapshots, compaction, and configurable query memory.
 
 Use [the PostgreSQL compatibility page](https://minnowdb.com/docs/sql/feature-matrix/) for the
@@ -27,7 +27,8 @@ workers, transactions, and API details.
 The optional [Kysely dialect](https://minnowdb.com/docs/adapters/kysely/) connects Kysely's
 PostgreSQL compiler to the engine and derives its `DB` types from the same schema declaration.
 
-Every `@minnowdb` package in one application must use the same major version. See
+Minnow is 0.x: breaking changes land in minor releases, so pin exact versions and upgrade
+`@minnowdb` packages together. See
 [Versioning](https://minnowdb.com/docs/reference/versioning/).
 
 ## License

package/dist/engine/database.js

@@ -15,7 +15,7 @@ import { cachedQueryTerms, FTS_TOKENIZER_VERSION, renderDocumentValue, tokenize
 import { boundedMaintenanceBatchItems, simpleDataTypes, floorWholeNumberProduct, BlockReadBatchTooLargeError, validateColumnDefault, validateEnumValues, secondaryIndexColumnIds, secondaryIndexDirections, secondaryUniqueKeyNamespace, CompactionJobConflictError, CompactionBacklogError, GarbageCollectionJobConflictError, MAX_LEVEL_ZERO_SEGMENTS, MAX_FTS_CANDIDATE_ROW_IDS, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_INDEXED_STRING_CHARACTERS, MAX_CATALOG_NAME_CHARACTERS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MAINTENANCE_BATCH_ITEMS, MAX_STORAGE_BULK_READ_ITEMS, MAX_TRANSACTION_STAGE_BLOCKS, MAX_TRANSACTION_STAGE_BYTES, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_POSTING_BUILD_TTL_MS, MAX_TEMP_OWNER_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, SNAPSHOT_FRAME_KINDS, validateStorageId, SnapshotManifestMissingError, SchemaConflictError, TableInUseError, TableRecordConflictError, TransactionRecordConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, WriteConflictError, } from "../storage/types.js";
 import { decodeSnapshotFrameStream, encodeSnapshotFrameStreamFooter, encodeSnapshotFrameStreamHeader, extendSnapshotFrameStreamChecksum, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity, } from "../storage/snapshot.js";
 import { Snapshot, TransactionManager, } from "../transactions/index.js";
-import { applyWindowFunctions, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, annotateAvgArgumentScales, compileStatement, comparisonHolds, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, expressionColumnNames, inferBlockSchema, inferResultColumnDomains, isDefaultInsertValue, referencedColumns, childExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, } from "./query.js";
+import { applyWindowFunctions, bindPendingSelectShapes, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, annotateAvgArgumentScales, compileStatement, comparisonHolds, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, expressionColumnNames, inferBlockSchema, inferResultColumnDomains, isDeferredInsertExpression, isDefaultInsertValue, referencedColumns, childExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, } from "./query.js";
 import { copyQueryResult, planMemoKey, queryResultMemoKey, queryResultRetainedBytes, RESULT_MEMO_MAX_BYTES, } from "./query-cache.js";
 import { QueryMemoryBudgetError, QueryMemoryContext, DEFAULT_QUERY_MEMORY_BUDGET_BYTES, } from "./memory.js";
 import { LiveQueryLimitError, LiveQuerySet, MAX_LIVE_QUERY_SETS_PER_DATABASE, } from "./live.js";
@@ -353,6 +353,99 @@ function insertStatementBatch(statement) {
         rowCount: statement.rows.length,
     };
 }
+/** Resolves CURRENT_* in every retained DML expression with one statement-start clock. */
+function resolveMutationStatementDatetimes(statement, now) {
+    const plan = (block) => resolveStatementDatetimes({ ...block, usesStatementDatetime: true }, now);
+    const expression = (value) => {
+        const resolved = plan({
+            sql: "(statement expression)",
+            base: { table: DUAL_TABLE, alias: DUAL_TABLE },
+            joins: [],
+            select: [{ expression: value, alias: "value" }],
+            predicates: [],
+            groupBy: [],
+            having: [],
+            orderBy: [],
+        });
+        return resolved.select[0]?.expression ?? value;
+    };
+    const predicates = (values) => values.map((predicate) => ({
+        ...predicate,
+        left: expression(predicate.left),
+        right: expression(predicate.right),
+    }));
+    if (statement.kind === "insert") {
+        return {
+            ...statement,
+            rows: statement.rows.map((row) => row.map((value) => isDeferredInsertExpression(value) ? { expression: expression(value.expression) } : value)),
+            ...(statement.query === undefined ? {} : { query: plan(statement.query) }),
+            ...(statement.onConflict === undefined
+                ? {}
+                : {
+                    onConflict: {
+                        ...statement.onConflict,
+                        ...(statement.onConflict.assignments === undefined
+                            ? {}
+                            : {
+                                assignments: statement.onConflict.assignments.map((assignment) => ({
+                                    ...assignment,
+                                    expression: expression(assignment.expression),
+                                })),
+                            }),
+                        ...(statement.onConflict.where === undefined
+                            ? {}
+                            : { where: expression(statement.onConflict.where) }),
+                    },
+                }),
+        };
+    }
+    if (statement.kind === "update") {
+        return {
+            ...statement,
+            assignments: statement.assignments.map((assignment) => ({
+                ...assignment,
+                expression: expression(assignment.expression),
+            })),
+            predicates: predicates(statement.predicates),
+        };
+    }
+    if (statement.kind === "delete") {
+        return { ...statement, predicates: predicates(statement.predicates) };
+    }
+    if (statement.kind === "merge") {
+        return {
+            ...statement,
+            on: expression(statement.on),
+            branches: statement.branches.map((branch) => {
+                const condition = branch.condition === undefined ? {} : { condition: expression(branch.condition) };
+                if (branch.when === "not-matched") {
+                    return {
+                        ...branch,
+                        ...condition,
+                        action: { ...branch.action, values: branch.action.values.map(expression) },
+                    };
+                }
+                return {
+                    ...branch,
+                    ...condition,
+                    action: branch.action.kind === "update"
+                        ? {
+                            ...branch.action,
+                            assignments: branch.action.assignments.map((assignment) => ({
+                                ...assignment,
+                                expression: expression(assignment.expression),
+                            })),
+                        }
+                        : branch.action,
+                };
+            }),
+        };
+    }
+    if (statement.kind === "create-table-as") {
+        return { ...statement, query: plan(statement.query) };
+    }
+    return statement;
+}
 /** Quotes a catalog identifier for internally generated SQL. */
 function quoteSqlIdentifier(identifier) {
     return `"${identifier.replaceAll('"', '""')}"`;
@@ -1697,6 +1790,41 @@ export class MinnowDatabase {
         }
         throw new TypeError(`DEFAULT produced an unsupported value: ${sql}`);
     }
+    /** Materializes volatile/catalog-backed INSERT values once per execution, never in the cache. */
+    async #materializeInsertExpressions(statement, statementNow) {
+        if (!statement.rows.some((row) => row.some(isDeferredInsertExpression)))
+            return statement;
+        const rows = [];
+        for (const row of statement.rows) {
+            const materialized = [];
+            for (const value of row) {
+                if (!isDeferredInsertExpression(value)) {
+                    materialized.push(value);
+                    continue;
+                }
+                let plan = {
+                    sql: "(insert value)",
+                    base: { table: DUAL_TABLE, alias: DUAL_TABLE },
+                    joins: [],
+                    select: [{ expression: value.expression, alias: "value" }],
+                    predicates: [],
+                    groupBy: [],
+                    having: [],
+                    orderBy: [],
+                    usesStatementDatetime: true,
+                    usesSequenceCalls: true,
+                    usesVolatileFunctions: true,
+                };
+                // Every CURRENT_* occurrence in all rows sees the same statement clock. RANDOM,
+                // GEN_RANDOM_UUID, and NEXTVAL remain per expression, as SQL requires.
+                plan = resolveStatementDatetimes(plan, statementNow);
+                const result = await this.#queryCompiled(plan, { memoize: false });
+                materialized.push(result.rows[0]?.value ?? null);
+            }
+            rows.push(materialized);
+        }
+        return { ...statement, rows };
+    }
     async insert(tableName, row) {
         return this.insertBatch(tableName, [row]);
     }
@@ -3352,28 +3480,31 @@ export class MinnowDatabase {
         if (domains.size > 0 && planReadsTable(rewritten, (name) => domains.has(name))) {
             rewritten = normalizePlanDomainLiterals(rewritten, domains);
         }
-        const qualified = qualifyCorrelatedReferences(rewritten, catalogColumns);
-        if (qualified !== rewritten)
-            rewritten = optimizePlan(qualified);
-        if (!aliased && !natural)
-            return rewritten;
-        // These two need column *order*, which only the records carry; both are rare enough that
-        // reading the catalog for them is fine.
-        const columns = new Map((await this.store.listTables()).map((table) => [
-            table.name,
-            table.columns.map(({ name }) => name),
-        ]));
-        const columnsOf = (name) => columns.get(name);
+        const columnsOf = (name) => {
+            const columns = catalogColumns.get(name);
+            if (columns === undefined)
+                throw new UnknownTableError(name);
+            return columns;
+        };
+        rewritten = bindPendingSelectShapes(rewritten, columnsOf);
         if (aliased)
             rewritten = expandSourceColumnAliases(rewritten, columnsOf);
-        return natural ? expandNaturalJoins(rewritten, columnsOf) : rewritten;
+        if (natural)
+            rewritten = expandNaturalJoins(rewritten, columnsOf);
+        const qualified = qualifyCorrelatedReferences(rewritten, catalogColumns);
+        return qualified === rewritten ? rewritten : optimizePlan(qualified);
     }
     /** Resolves connection-local sequence calls before either synchronous executor sees the plan. */
     async #resolveSequenceCalls(plan) {
         const usesSequence = (expression) => (expression.kind === "call" &&
             (expression.name === "NEXTVAL" || expression.name === "CURRVAL")) ||
             childExpressions(expression).some(usesSequence);
-        const selected = new Set(plan.select.map((item) => item.expression));
+        const selected = new Set();
+        const markSelected = (expression) => {
+            selected.add(expression);
+            childExpressions(expression).forEach(markSelected);
+        };
+        plan.select.forEach((item) => markSelected(item.expression));
         const sequenceExpressions = [];
         forEachBlockExpression(plan, (expression) => {
             if (!usesSequence(expression))
@@ -4785,7 +4916,7 @@ export class MinnowDatabase {
         }
         for (const trigger of triggers) {
             for (const statement of trigger.statements) {
-                const compiled = compileStatement(statement.sql);
+                const compiled = resolveMutationStatementDatetimes(compileStatement(statement.sql), this.#now());
                 if (compiled.kind === "insert") {
                     await this.#applyTriggerInsertBody(transaction, compiled, statement.bindings, rowCount, valueAt, cascadeBudget);
                     continue;
@@ -4810,8 +4941,9 @@ export class MinnowDatabase {
         if (target.uniqueKeyColumnId !== undefined) {
             throw new TypeError(`Trigger bodies insert into keyless tables only: ${target.name}`);
         }
-        const input = insertStatementBatch({ ...compiled, rows: derivedRows });
         const statementNow = this.#now();
+        const materialized = await this.#materializeInsertExpressions({ ...compiled, rows: derivedRows }, statementNow);
+        const input = insertStatementBatch(materialized);
         const filled = await fillColumnDefaults(target, input, (sql) => this.#evaluateDefaultExpression(sql, statementNow), derivedRows.length);
         normalizeDomainBatch(target, filled.batch);
         fillStoredGeneratedColumns(target, filled.batch, derivedRows.length, filled.generated);
@@ -6961,9 +7093,10 @@ export class MinnowDatabase {
         if (statement.query === undefined)
             return statement;
         const target = await this.#findTable(statement.table);
+        const plan = await this.#applyCatalogRewrites(statement.query);
         let result;
         if (writer === undefined) {
-            const prepared = await this.#prepareCompiledPlan(statement.query);
+            const prepared = await this.#prepareCompiledPlan(plan);
             try {
                 result = prepared.execute();
             }
@@ -6972,14 +7105,22 @@ export class MinnowDatabase {
             }
         }
         else {
-            const plan = await this.#applyCatalogRewrites(statement.query);
             result = await writer.queryPlan(plan);
         }
+        const insertColumns = statement.columns.length > 0
+            ? statement.columns
+            : visibleTableColumns(target).map(({ name }) => name);
+        if (result.columns.length !== insertColumns.length) {
+            throw new TypeError(statement.columns.length > 0
+                ? "INSERT ... SELECT must produce exactly the insert column count"
+                : "INSERT ... SELECT must produce exactly the table column count");
+        }
         const { query, ...rest } = statement;
         void query;
-        const targetColumns = statement.columns.map((name) => target.columns.find((column) => column.name === name));
+        const targetColumns = insertColumns.map((name) => target.columns.find((column) => column.name === name));
         return {
             ...rest,
+            columns: insertColumns,
             rows: result.rows.map((row) => result.columns.map((column, position) => storedSqlValueFromExecution(targetColumns[position], row[column] ?? null))),
         };
     }
@@ -6991,6 +7132,8 @@ export class MinnowDatabase {
      * (the snapshot row with assignments applied — the exact values the mutation wrote).
      */
     async runStatement(statement, options = {}) {
+        const statementNow = this.#now();
+        statement = resolveMutationStatementDatetimes(statement, statementNow);
         if (statement.kind === "select") {
             return { kind: "rows", result: await this.query(statement.sql) };
         }
@@ -7110,7 +7253,8 @@ export class MinnowDatabase {
                         ...(sqlDomain === undefined ? {} : { sqlDomain }),
                     })),
                 ]));
-                const tableColumns = inferBlockSchema(statement.query, schemas).map(({ name, type, integer, sqlDomain }) => ({
+                const plan = await this.#applyCatalogRewrites(statement.query, before);
+                const tableColumns = inferBlockSchema(plan, schemas).map(({ name, type, integer, sqlDomain }) => ({
                     id: this.#createId(),
                     name: validateName(name, "Column"),
                     type,
@@ -7128,7 +7272,6 @@ export class MinnowDatabase {
                 };
                 const transaction = await this.#transactions.beginWithPendingTable(pendingTable, before.catalogEpoch);
                 try {
-                    const plan = await this.#applyCatalogRewrites(statement.query);
                     const executionMemoryBudgetBytes = Math.min(this.#queryExecutionMemoryBudgetBytes, DEFAULT_QUERY_MEMORY_BUDGET_BYTES);
                     const stageBatchRows = 16_384;
                     let nextRowId = 1n;
@@ -7393,6 +7536,9 @@ export class MinnowDatabase {
         if (statement.kind === "transaction") {
             return this.#runTransactionStatement(statement.action, statement.name);
         }
+        if (statement.kind === "insert") {
+            statement = await this.#materializeInsertExpressions(statement, statementNow);
+        }
         if (options.writer === undefined) {
             // Selection, assignment evaluation, constraint proofs, trigger derivation, and the write
             // itself are one statement transaction. A genuine concurrent data commit does not rebase
@@ -7421,13 +7567,12 @@ export class MinnowDatabase {
                 }
             }
         }
+        if (statement.kind === "insert" && statement.query !== undefined) {
+            statement = await this.#materializeInsertSelect(statement, options.writer);
+        }
         if (statement.kind === "insert" && statement.columns.length === 0) {
             const table = await this.#findTable(statement.table);
             const columns = visibleTableColumns(table).map((column) => column.name);
-            const producedColumns = statement.query?.select.length;
-            if (producedColumns !== undefined && producedColumns !== columns.length) {
-                throw new TypeError("INSERT ... SELECT must produce exactly the table column count");
-            }
             if (statement.defaultValues === true) {
                 // Keep the empty column list: omission, not NULL, is what invokes catalog defaults.
             }
@@ -7438,13 +7583,13 @@ export class MinnowDatabase {
                 statement = { ...statement, columns };
             }
         }
+        if (statement.kind === "insert") {
+            statement = await this.#materializeInsertExpressions(statement, statementNow);
+        }
         // A RETURNING clause parsed from SQL text applies unless the caller overrides it.
         if (statement.returning !== undefined && options.returning === undefined) {
             options = { ...options, returning: statement.returning };
         }
-        if (statement.kind === "insert" && statement.query !== undefined) {
-            statement = await this.#materializeInsertSelect(statement, options.writer);
-        }
         if (statement.kind === "insert" && statement.onConflict?.action === "nothing") {
             statement = await this.#filterConflictingInsertRows(statement, options.writer);
         }

package/dist/engine/query.d.ts

@@ -105,10 +105,14 @@ export interface UniqueConstraintDefinition {
 interface DefaultInsertValue {
     readonly default: true;
 }
-export type InsertValue = QueryValue | DefaultInsertValue | {
+interface DeferredInsertExpression {
+    readonly expression: Expression;
+}
+export type InsertValue = QueryValue | DefaultInsertValue | DeferredInsertExpression | {
     parameter: number;
 };
 export declare function isDefaultInsertValue(value: InsertValue): value is DefaultInsertValue;
+export declare function isDeferredInsertExpression(value: InsertValue): value is DeferredInsertExpression;
 export type CompiledStatement = {
     kind: "select";
     sql: string;
@@ -626,6 +630,15 @@ export declare function planReadsViews(plan: CompiledQuery, isView: (name: strin
  */
 export declare function expandViewSources(plan: CompiledQuery, viewFor: (tableName: string) => CompiledQuery | undefined, maxDepth?: number): CompiledQuery;
 export declare function planHasSourceColumnAliases(plan: CompiledQuery): boolean;
+/** Whether any block still needs source schemas before its SELECT shape can be lowered. */
+export declare function planHasPendingSelectShapes(plan: CompiledQuery): boolean;
+/**
+ * Expands schema-dependent SELECT wildcards, then sends the now-concrete block through the same
+ * lowering used by ordinary named select lists. This is the single boundary at which wildcard
+ * width becomes plan shape: DISTINCT, windows, ORDER BY expressions/ordinals, set operations,
+ * CTE/derived column lists, grouping sets, and FULL JOIN therefore cannot disagree about it.
+ */
+export declare function bindPendingSelectShapes(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 /** Whether any block of the plan still carries an unresolved NATURAL join marker. */
 export declare function planHasNaturalJoins(plan: CompiledQuery): boolean;
 /**

package/dist/engine/query.js

@@ -890,7 +890,11 @@ export function compileQuery(sql, options = {}) {
     let compiled;
     try {
         resolvePlanExactNumericConstants(plan);
-        compiled = options.optimize === false ? plan : optimizePlan(plan);
+        if (options.optimize === false && planHasPendingSelectShapes(plan)) {
+            plan.preserveUnoptimizedShape = true;
+        }
+        compiled =
+            options.optimize === false || planHasPendingSelectShapes(plan) ? plan : optimizePlan(plan);
     }
     catch (error) {
         // Compile-time rewrites (for example decorrelation) reject unsupported shapes; those
@@ -925,6 +929,9 @@ function columnDefaultFor(expression, sql) {
 export function isDefaultInsertValue(value) {
     return (typeof value === "object" && value !== null && !(value instanceof Date) && "default" in value);
 }
+export function isDeferredInsertExpression(value) {
+    return (typeof value === "object" && value !== null && !(value instanceof Date) && "expression" in value);
+}
 /**
  * Parses CREATE TRIGGER name AFTER INSERT|UPDATE|DELETE ON table [FOR EACH ROW]
  * BEGIN insert; ... END. Body statements are INSERT ... VALUES with NEW.col / OLD.col
@@ -2365,8 +2372,9 @@ function trimPreparedResults(prepared, trim) {
 }
 export function createPreparedQuery(plan, tables, options = {}) {
     assertTailParametersBound(plan);
-    validateGrouping(plan);
     plan = resolveStatementDatetimes(plan);
+    plan = bindPendingSelectShapes(plan, wildcardRowColumns(tables));
+    validateGrouping(plan);
     // The schema-dependent rewrites run before derived sources materialize, because both can
     // turn a scanned table into one more derived block.
     plan = expandSourceColumnAliases(plan, wildcardRowColumns(tables));
@@ -2411,16 +2419,17 @@ export function createPreparedQuery(plan, tables, options = {}) {
 /** Internal columnar entry point used after MinnowDatabase materializes a stable snapshot. */
 export function createPreparedColumnarQuery(plan, tables, memory = new QueryMemoryContext(), preparedOptions = {}) {
     plan = resolveStatementDatetimes(plan);
-    const ties = withTiesPlan(plan);
-    if (ties.plan !== plan) {
-        return trimPreparedResults(createPreparedColumnarQuery(ties.plan, tables, memory, preparedOptions), ties.trim);
-    }
     const columnarColumns = (tableName) => {
         const table = tables.get(tableName);
         return table === undefined
             ? undefined
             : [...table.columns.keys()].filter((name) => !name.startsWith("\0"));
     };
+    plan = bindPendingSelectShapes(plan, columnarColumns);
+    const ties = withTiesPlan(plan);
+    if (ties.plan !== plan) {
+        return trimPreparedResults(createPreparedColumnarQuery(ties.plan, tables, memory, preparedOptions), ties.trim);
+    }
     plan = expandSourceColumnAliases(plan, columnarColumns);
     plan = expandNaturalJoins(plan, columnarColumns);
     plan = expandQualifiedWildcards(plan, columnarColumns);
@@ -3691,8 +3700,9 @@ export function executeRowQuery(plan, tables) {
 }
 function executeRowQueryInternal(plan, tables, memory) {
     assertTailParametersBound(plan);
-    validateGrouping(plan);
     plan = resolveStatementDatetimes(plan);
+    plan = bindPendingSelectShapes(plan, wildcardRowColumns(tables));
+    validateGrouping(plan);
     plan = expandSourceColumnAliases(plan, wildcardRowColumns(tables));
     plan = expandNaturalJoins(plan, wildcardRowColumns(tables));
     plan = expandQualifiedWildcards(plan, wildcardRowColumns(tables));
@@ -5634,11 +5644,12 @@ class Parser {
         if (this.#isKeyword("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");
-            }
-            if (columns.length > 0 && query.select.length !== columns.length) {
+            const query = planHasPendingSelectShapes(insertSource)
+                ? insertSource
+                : optimizePlan(insertSource);
+            if (!planHasPendingSelectShapes(query) &&
+                columns.length > 0 &&
+                query.select.length !== columns.length) {
                 throw new TypeError("INSERT ... SELECT must produce exactly the insert column count");
             }
             return {
@@ -5959,6 +5970,15 @@ 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))) ||
+            childExpressions(value).some(needsExecution);
+        if (needsExecution(expression)) {
+            return { expression: resolveExactNumericConstants(expression) };
+        }
         return asQueryValue(evaluate(resolveExactNumericConstants(expression), {}));
     }
     #unionMember(sql) {
@@ -6515,18 +6535,7 @@ class Parser {
                 break;
         }
         this.#expectPunctuation(")");
-        // Set-operation output takes the first member's aliases, so renaming targets it.
-        const target = derived.base.union !== undefined && derived.select[0]?.expression.kind === "wildcard"
-            ? derived.base.union.blocks[0]
-            : derived;
-        if (target?.select.length !== names.length) {
-            throw new TypeError("Column alias list must match the derived table's column count");
-        }
-        names.forEach((name, index) => {
-            const item = target.select[index];
-            if (item !== undefined)
-                item.alias = name;
-        });
+        renameBlockOutputs(derived, names, "derived table");
     }
     /**
      * `JOIN t USING (a, b)`: the named columns must exist on both sides, and the join condition
@@ -8281,6 +8290,34 @@ function desugarFullJoin(parts, nextSequence) {
     if (join.on !== undefined) {
         throw new TypeError("FULL JOIN requires a single equality ON condition");
     }
+    // The UNION ALL this desugars into resolves ORDER BY against the compound's output columns,
+    // where the branches' table aliases no longer exist. Qualified references that name a select
+    // item are rewritten to its output alias, and everything else — expressions, and columns the
+    // select list does not carry — takes the shared hidden-column desugar, which re-enters this
+    // function with alias-only ordering.
+    const outputAlias = (reference) => {
+        const exact = parts.select.find((item) => item.alias === reference ||
+            (item.expression.kind === "column" && item.expression.reference === reference));
+        if (exact !== undefined)
+            return exact.alias;
+        const bare = reference.split(".").at(-1) ?? reference;
+        return parts.select.find((item) => item.alias === bare)?.alias;
+    };
+    parts = {
+        ...parts,
+        orderBy: parts.orderBy.map((order) => {
+            if (order.expression.kind !== "column" || !order.expression.reference.includes(".")) {
+                return order;
+            }
+            const alias = outputAlias(order.expression.reference);
+            if (alias === undefined)
+                return order;
+            return { ...order, expression: { kind: "column", reference: alias } };
+        }),
+    };
+    if (parts.orderBy.some((order) => orderNeedsHiddenColumn(order.expression, parts))) {
+        return assembleOrderByExpressionBlock(parts, nextSequence);
+    }
     // `on` is absent here: the guard above rejected non-equi conditions.
     const { full, kind, left, right, ...joinSource } = join;
     void full;
@@ -8313,6 +8350,37 @@ function desugarFullJoin(parts, nextSequence) {
     }, nextSequence);
 }
 export function assembleSelectBlock(parts, nextSequence) {
+    if (parts.select.some((item) => item.expression.kind === "wildcard")) {
+        if (parts.joins.some((join) => join.full === true)) {
+            throw new TypeError("FULL JOIN cannot be combined with SELECT *");
+        }
+        // A wildcard's width and names come from source schemas, but ordinals, hidden ORDER BY
+        // columns, DISTINCT grouping, windows, grouping sets, and FULL JOIN lowering all depend on
+        // that width. Preserve the raw block until schema binding instead of teaching each lowering
+        // a different late wildcard exception.
+        return {
+            sql: parts.sql,
+            base: parts.base,
+            joins: parts.joins,
+            select: parts.select,
+            predicates: parts.predicates,
+            groupBy: parts.groupBy,
+            having: parts.having,
+            orderBy: parts.orderBy,
+            ...(parts.limit === undefined ? {} : { limit: parts.limit }),
+            ...(parts.offset === undefined ? {} : { offset: parts.offset }),
+            ...(parts.limitParameter === undefined ? {} : { limitParameter: parts.limitParameter }),
+            ...(parts.offsetParameter === undefined ? {} : { offsetParameter: parts.offsetParameter }),
+            ...(parts.limitWithTies === true ? { limitWithTies: true } : {}),
+            pendingSelectShape: {
+                distinct: parts.distinct,
+                ...(parts.groupingSets === undefined
+                    ? {}
+                    : { groupingSets: structuredClone(parts.groupingSets) }),
+            },
+            ...(parts.distinct ? { distinctWildcard: true } : {}),
+        };
+    }
     parts = { ...parts, orderBy: resolveOrderByOrdinals(parts.orderBy, parts.select) };
     if (parts.joins.some((join) => join.full === true)) {
         return desugarFullJoin(parts, nextSequence);
@@ -8555,6 +8623,12 @@ function withTiesPlan(plan) {
  * table's own aliases, a set operation's first member's, and otherwise the input table's.
  */
 function sourceWildcardColumns(source, columnsOf) {
+    if (source.derived?.base.union !== undefined &&
+        source.derived.select[0]?.expression.kind === "wildcard") {
+        return source.derived.base.union.blocks[0]?.select
+            .map((item) => item.alias)
+            .filter((name) => !name.startsWith("\0"));
+    }
     if (source.derived !== undefined)
         return source.derived.select.map((item) => item.alias).filter((name) => !name.startsWith("\0"));
     if (source.union !== undefined) {
@@ -8562,8 +8636,188 @@ function sourceWildcardColumns(source, columnsOf) {
             .map((item) => item.alias)
             .filter((name) => !name.startsWith("\0"));
     }
+    if (source.windowed !== undefined) {
+        return [
+            ...source.windowed.block.select.map((item) => item.alias),
+            ...source.windowed.windows.map((window) => window.alias),
+        ].filter((name) => !name.startsWith("\0"));
+    }
+    if (source.recursive !== undefined) {
+        return source.recursive.base.select
+            .map((item) => item.alias)
+            .filter((name) => !name.startsWith("\0"));
+    }
     return columnsOf(source.table)?.filter((name) => !name.startsWith("\0"));
 }
+/** Whether any block still needs source schemas before its SELECT shape can be lowered. */
+export function planHasPendingSelectShapes(plan) {
+    if (plan.pendingSelectShape !== undefined ||
+        plan.pendingOutputAliases !== undefined ||
+        plan.pendingSetOrder === true) {
+        return true;
+    }
+    let pending = false;
+    forEachNestedBlock(plan, (nested) => {
+        pending ||= planHasPendingSelectShapes(nested);
+    });
+    const inspect = (expression) => {
+        if (expression.kind === "subquery" || expression.kind === "exists") {
+            pending ||= planHasPendingSelectShapes(expression.block);
+            return;
+        }
+        childExpressions(expression).forEach(inspect);
+    };
+    forEachBlockExpression(plan, inspect);
+    return pending;
+}
+/**
+ * Expands schema-dependent SELECT wildcards, then sends the now-concrete block through the same
+ * lowering used by ordinary named select lists. This is the single boundary at which wildcard
+ * width becomes plan shape: DISTINCT, windows, ORDER BY expressions/ordinals, set operations,
+ * CTE/derived column lists, grouping sets, and FULL JOIN therefore cannot disagree about it.
+ */
+export function bindPendingSelectShapes(plan, columnsOf) {
+    if (!planHasPendingSelectShapes(plan))
+        return plan;
+    const bound = structuredClone(plan);
+    const preserveUnoptimizedShape = bound.preserveUnoptimizedShape === true;
+    delete bound.preserveUnoptimizedShape;
+    let sequence = 0;
+    const scanSequence = (block) => {
+        for (const source of [block.base, ...block.joins]) {
+            const match = /\((?:derived|window|union) (\d+)\)/.exec(source.table);
+            if (match?.[1] !== undefined)
+                sequence = Math.max(sequence, Number(match[1]));
+        }
+        forEachNestedBlock(block, scanSequence);
+    };
+    scanSequence(bound);
+    const nextSequence = () => {
+        sequence += 1;
+        return sequence;
+    };
+    const bindExpressionBlocks = (expression) => {
+        if (expression.kind === "subquery" || expression.kind === "exists") {
+            return { ...expression, block: bindBlock(expression.block) };
+        }
+        if (expression.kind === "window") {
+            return {
+                ...expression,
+                partitionBy: expression.partitionBy.map(bindExpressionBlocks),
+                orderBy: expression.orderBy.map((order) => ({
+                    ...order,
+                    expression: bindExpressionBlocks(order.expression),
+                })),
+                ...(expression.argument === undefined
+                    ? {}
+                    : { argument: bindExpressionBlocks(expression.argument) }),
+            };
+        }
+        return mapChildExpressions(expression, bindExpressionBlocks);
+    };
+    const bindSource = (source) => {
+        if (source.derived !== undefined)
+            source.derived = bindBlock(source.derived);
+        if (source.union !== undefined) {
+            source.union.blocks = source.union.blocks.map(bindBlock);
+        }
+        if (source.windowed !== undefined) {
+            source.windowed.block = bindBlock(source.windowed.block);
+        }
+        if (source.recursive !== undefined) {
+            source.recursive.base = bindBlock(source.recursive.base);
+            source.recursive.step = bindBlock(source.recursive.step);
+        }
+    };
+    const expandedSelect = (block) => {
+        const sources = [block.base, ...block.joins];
+        const shaped = sources.map((source) => ({
+            source,
+            columns: source.columnAliases ?? sourceWildcardColumns(source, columnsOf),
+        }));
+        const unknown = shaped.find(({ columns }) => columns === undefined);
+        if (unknown !== undefined) {
+            throw new TypeError(`SELECT * requires known columns for: ${unknown.source.table}`);
+        }
+        const multiple = shaped.filter(({ columns }) => (columns?.length ?? 0) > 0).length > 1;
+        const items = block.select.flatMap((item) => {
+            if (item.expression.kind !== "wildcard")
+                return [item];
+            const table = item.expression.table;
+            const selected = table === undefined ? shaped : shaped.filter(({ source }) => source.alias === table);
+            if (table !== undefined && selected.length === 0) {
+                throw new TypeError(`Unknown table for ${table}.*: ${table}`);
+            }
+            return selected.flatMap(({ source, columns }) => (columns ?? []).map((name) => ({
+                expression: { kind: "column", reference: `${source.alias}.${name}` },
+                alias: multiple ? `${source.alias}.${name}` : name,
+            })));
+        });
+        const aliases = new Set();
+        for (const item of items) {
+            if (aliases.has(item.alias))
+                throw new TypeError(`Duplicate output column: ${item.alias}`);
+            aliases.add(item.alias);
+        }
+        return items;
+    };
+    const carryPlanFlags = (from, to) => {
+        for (const key of [
+            "parameterCount",
+            "usesStatementDatetime",
+            "usesSequenceCalls",
+            "usesVolatileFunctions",
+        ]) {
+            const value = from[key];
+            if (value !== undefined)
+                Object.assign(to, { [key]: value });
+        }
+    };
+    function bindBlock(block) {
+        for (const source of [block.base, ...block.joins])
+            bindSource(source);
+        mapBlockExpressions(block, bindExpressionBlocks);
+        let lowered = block;
+        const pending = block.pendingSelectShape;
+        if (pending !== undefined) {
+            const { pendingSelectShape, pendingOutputAliases, distinctWildcard, ...rest } = block;
+            void pendingSelectShape;
+            void pendingOutputAliases;
+            void distinctWildcard;
+            lowered = assembleSelectBlock({
+                sql: rest.sql,
+                base: rest.base,
+                joins: rest.joins,
+                select: expandedSelect(block),
+                distinct: pending.distinct,
+                predicates: rest.predicates,
+                groupBy: rest.groupBy,
+                having: rest.having,
+                orderBy: rest.orderBy,
+                ...(rest.limit === undefined ? {} : { limit: rest.limit }),
+                ...(rest.offset === undefined ? {} : { offset: rest.offset }),
+                ...(rest.limitParameter === undefined ? {} : { limitParameter: rest.limitParameter }),
+                ...(rest.offsetParameter === undefined ? {} : { offsetParameter: rest.offsetParameter }),
+                ...(rest.limitWithTies === true ? { limitWithTies: true } : {}),
+                ...(pending.groupingSets === undefined ? {} : { groupingSets: pending.groupingSets }),
+            }, nextSequence);
+            carryPlanFlags(block, lowered);
+        }
+        if (lowered.pendingSetOrder === true) {
+            const first = lowered.base.union?.blocks[0];
+            lowered.orderBy = resolveOrderByOrdinals(lowered.orderBy, first?.select ?? []);
+            delete lowered.pendingSetOrder;
+        }
+        const aliases = block.pendingOutputAliases;
+        if (aliases !== undefined) {
+            renameBlockOutputs(lowered, aliases.columns, aliases.sourceName);
+            delete lowered.pendingOutputAliases;
+        }
+        return lowered;
+    }
+    const lowered = bindBlock(bound);
+    return preserveUnoptimizedShape ? lowered : optimizePlan(lowered);
+}
 /** Whether any block of the plan still carries an unresolved NATURAL join marker. */
 export function planHasNaturalJoins(plan) {
     if (plan.joins.some((join) => join.natural === true))
@@ -8723,7 +8977,13 @@ function expandQualifiedWildcards(plan, columnsOf) {
             }
             return columns.map((name) => {
                 const output = multiple ? `${source.alias}.${name}` : name;
-                return { expression: { kind: "column", reference: output }, alias: output };
+                // Keep the source-qualified input reference even though one source exposes a bare output
+                // name. ORDER BY can legally spell either form (`id` or `orders.id`), and the latter must
+                // still match this select item after the wildcard has expanded.
+                return {
+                    expression: { kind: "column", reference: `${source.alias}.${name}` },
+                    alias: output,
+                };
             });
         });
         const aliases = new Set();
@@ -8740,7 +9000,10 @@ function expandQualifiedWildcards(plan, columnsOf) {
 /** Wraps compound members into the set-operation source the executor folds left to right. */
 export function compoundSelectBlock(sql, blocks, ops, tail, nextSequence) {
     // Set-operation output columns are the first member's, so ordinals resolve against them.
-    tail = { ...tail, orderBy: resolveOrderByOrdinals(tail.orderBy, blocks[0]?.select ?? []) };
+    const pendingSetOrder = blocks.some(planHasPendingSelectShapes);
+    if (!pendingSetOrder) {
+        tail = { ...tail, orderBy: resolveOrderByOrdinals(tail.orderBy, blocks[0]?.select ?? []) };
+    }
     return {
         sql,
         base: {
@@ -8754,9 +9017,12 @@ export function compoundSelectBlock(sql, blocks, ops, tail, nextSequence) {
         groupBy: [],
         having: [],
         orderBy: tail.orderBy,
+        ...(pendingSetOrder ? { pendingSetOrder: true } : {}),
         ...(tail.limit === undefined ? {} : { limit: tail.limit }),
         ...(tail.offset === undefined ? {} : { offset: tail.offset }),
         ...(tail.limitWithTies === true ? { limitWithTies: true } : {}),
+        ...(tail.limitParameter === undefined ? {} : { limitParameter: tail.limitParameter }),
+        ...(tail.offsetParameter === undefined ? {} : { offsetParameter: tail.offsetParameter }),
     };
 }
 /**
@@ -8764,9 +9030,10 @@ export function compoundSelectBlock(sql, blocks, ops, tail, nextSequence) {
  * either reuses a structurally identical select item's alias or becomes a hidden "(order N)"
  * select item, the ordering (and LIMIT/OFFSET) applies inside that block, and an outer block
  * projects only the visible aliases away from a derived source. Runs in the shared assembly,
- * so the builder and SQL front ends produce identical plans. A wildcard select has no named
- * output list to hide items behind, and DISTINCT's output would change if hidden expressions
- * joined its grouping, so both keep the named-column restriction.
+ * so the builder and SQL front ends produce identical plans. Schema-bound wildcard blocks reach
+ * this function with concrete items; only a manually constructed unresolved wildcard plan keeps
+ * the named-column restriction. DISTINCT's output would change if hidden expressions joined its
+ * grouping, so it keeps the selected-column restriction.
  */
 /**
  * Whether an ORDER BY item has to travel as a hidden select item: any expression, and also a
@@ -8823,17 +9090,39 @@ function assembleOrderByExpressionBlock(parts, nextSequence) {
             expression: { kind: "column", reference: alias },
         };
     });
-    const inner = assembleSelectBlock({ ...parts, select: [...parts.select, ...hiddenItems], orderBy: rewrittenOrder }, nextSequence);
     // Every ordering expression matched a visible select item — no hidden columns, no wrap.
-    if (hiddenItems.length === 0)
-        return inner;
+    if (hiddenItems.length === 0) {
+        return assembleSelectBlock({ ...parts, orderBy: rewrittenOrder }, nextSequence);
+    }
+    // Once hidden columns exist, the visible projection is wrapped in a derived table. Visible
+    // output names such as `people.id` are legal result labels but are not legal internal column
+    // references there — the dot would be read as the vanished `people` source qualifier. Carry
+    // every visible value through a private dot-free name and restore its public label outside.
+    const visibleInner = parts.select.map((item, index) => ({
+        ...item,
+        alias: item.alias.includes(".") ? `(order visible ${String(index + 1)})` : item.alias,
+    }));
+    const visibleAlias = new Map(parts.select.map((item, index) => [item.alias, visibleInner[index]?.alias ?? item.alias]));
+    const innerOrder = rewrittenOrder.map((order) => {
+        if (order.expression.kind !== "column" || order.expression.reference.includes(".")) {
+            return order;
+        }
+        const alias = visibleAlias.get(order.expression.reference);
+        return alias === undefined
+            ? order
+            : { ...order, expression: { kind: "column", reference: alias } };
+    });
+    const inner = assembleSelectBlock({ ...parts, select: [...visibleInner, ...hiddenItems], orderBy: innerOrder }, nextSequence);
     const source = derivedTableSource(inner, "(ordered)", nextSequence);
     return {
         sql: parts.sql,
         base: source,
         joins: [],
-        select: parts.select.map((item) => ({
-            expression: { kind: "column", reference: item.alias },
+        select: parts.select.map((item, index) => ({
+            expression: {
+                kind: "column",
+                reference: visibleInner[index]?.alias ?? item.alias,
+            },
             alias: item.alias,
         })),
         predicates: [],
@@ -8915,10 +9204,28 @@ export function validateLimit(limit) {
  * which is later than this.
  */
 function renameBlockOutputs(block, columns, name) {
+    // Set-operation output names come from the first member. Its width may itself be pending on a
+    // wildcard, so preserve the alias list on the compound until all members have schema-bound.
+    if (block.base.union !== undefined && block.select[0]?.expression.kind === "wildcard") {
+        const first = block.base.union.blocks[0];
+        if (first === undefined || planHasPendingSelectShapes(first)) {
+            block.pendingOutputAliases = { columns: [...columns], sourceName: name };
+            return;
+        }
+        renameBlockOutputs(first, columns, name);
+        return;
+    }
+    if (block.pendingSelectShape !== undefined) {
+        block.pendingOutputAliases = { columns: [...columns], sourceName: name };
+        return;
+    }
     if (block.select.some((item) => item.expression.kind === "wildcard")) {
-        throw new TypeError(`A column list needs named columns in the CTE body: ${name}`);
+        throw new TypeError(`A column list needs named columns in the query body: ${name}`);
     }
     if (block.select.length !== columns.length) {
+        if (name === "derived table") {
+            throw new TypeError("Column alias list must match the derived table's column count");
+        }
         throw new TypeError(`CTE ${name} declares ${String(columns.length)} columns but selects ${String(block.select.length)}`);
     }
     block.select = block.select.map((item, index) => ({
@@ -9009,7 +9316,10 @@ function desugarWindows(sql, base, joins, select, predicates, groupBy, having, t
     const readableWhenGrouped = (expression) => hasAggregate(expression) ||
         expressionColumns(expression).length === 0 ||
         groupExpressions.has(JSON.stringify(expression));
-    const innerSelect = select.filter((item) => !containsWindow(item.expression));
+    const internalAliases = select.map((item, index) => item.alias.includes(".") ? `(window visible ${String(index + 1)})` : item.alias);
+    const innerSelect = select.flatMap((item, index) => containsWindow(item.expression)
+        ? []
+        : [{ ...item, alias: internalAliases[index] ?? item.alias }]);
     const windows = [];
     let hidden = 0;
     /** A name for one more column the inner block computes for the wrapper to read back. */
@@ -9071,21 +9381,52 @@ function desugarWindows(sql, base, joins, select, predicates, groupBy, having, t
         }
         return mapChildExpressions(expression, split);
     };
-    const projections = select.map((item) => {
+    const projections = select.map((item, index) => {
+        const internalAlias = internalAliases[index] ?? item.alias;
         if (!containsWindow(item.expression)) {
-            return { expression: { kind: "column", reference: item.alias }, alias: item.alias };
+            return {
+                expression: { kind: "column", reference: internalAlias },
+                alias: item.alias,
+            };
         }
-        // A window that is the whole select item keeps carrying that item's own name, which is what
-        // the executor's windowed source and every existing plan already expect.
+        // A window that is the whole select item carries a private source-safe name through the
+        // windowed source, then the wrapper restores the public output alias.
         if (item.expression.kind === "window") {
-            registerWindow(item.expression, item.alias);
-            return { expression: { kind: "column", reference: item.alias }, alias: item.alias };
+            registerWindow(item.expression, internalAlias);
+            return {
+                expression: { kind: "column", reference: internalAlias },
+                alias: item.alias,
+            };
         }
         return { expression: split(item.expression), alias: item.alias };
     });
     if (innerSelect.length === 0) {
         innerSelect.push({ expression: { kind: "literal", value: 1 }, alias: "(window 0)" });
     }
+    // Window evaluation replaces the FROM sources with one synthetic source. A qualified ORDER
+    // BY that names a selected column must therefore follow that value through its output alias;
+    // leaving `a.id` in the wrapper would try to resolve the vanished table alias `a`.
+    const windowTail = {
+        ...tail,
+        orderBy: tail.orderBy.map((order) => {
+            if (order.expression.kind !== "column")
+                return order;
+            const reference = order.expression.reference;
+            const bare = reference.split(".").at(-1) ?? reference;
+            const selectedIndex = select.findIndex((item) => item.alias === reference ||
+                item.alias === bare ||
+                (item.expression.kind === "column" && item.expression.reference === reference));
+            const selected = selectedIndex < 0 ? undefined : select[selectedIndex];
+            const projected = selectedIndex < 0 ? undefined : projections[selectedIndex];
+            const internalReference = projected?.expression.kind === "column" ? projected.expression.reference : selected?.alias;
+            return selected === undefined || internalReference === undefined
+                ? order
+                : {
+                    ...order,
+                    expression: { kind: "column", reference: internalReference },
+                };
+        }),
+    };
     const inner = {
         sql: "(window input)",
         base,
@@ -9108,7 +9449,7 @@ function desugarWindows(sql, base, joins, select, predicates, groupBy, having, t
         predicates: [],
         groupBy: [],
         having: [],
-        ...tail,
+        ...windowTail,
     };
 }
 /**

package/dist/plan/model.d.ts

@@ -226,6 +226,24 @@ export interface CompiledQuery {
     }>;
     limit?: number;
     offset?: number;
+    /**
+     * A SELECT whose output width depends on an input wildcard. The parser preserves the raw
+     * shape until source schemas are available; the schema-binding pass then expands the
+     * wildcard and runs the ordinary SELECT lowering exactly once.
+     */
+    pendingSelectShape?: {
+        distinct: boolean;
+        groupingSets?: Expression[][];
+    };
+    /** Positional output names whose count cannot be checked until a wildcard is expanded. */
+    pendingOutputAliases?: {
+        columns: string[];
+        sourceName: string;
+    };
+    /** A compound tail whose ORDER BY ordinals depend on its first member's wildcard width. */
+    pendingSetOrder?: true;
+    /** Preserve `{ optimize: false }` after a deferred wildcard shape becomes concrete. */
+    preserveUnoptimizedShape?: true;
     distinctWildcard?: boolean;
     limitParameter?: number;
     offsetParameter?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",

package/sql-feature-matrix.json

@@ -170,6 +170,12 @@
       "status": "supported",
       "example": "SELECT * FROM rows ORDER BY amount"
     },
+    {
+      "id": "order-by.qualified-wildcard-reference",
+      "status": "supported",
+      "example": "SELECT rows.* FROM rows ORDER BY rows.amount DESC",
+      "notes": "Both the wildcard and the ordering reference may use a table name or alias, quoted or unquoted. The conformance corpus crosses those spellings and compares them with SQLite and PostgreSQL."
+    },
     {
       "id": "limit",
       "status": "supported",
@@ -242,6 +248,15 @@
       "example": "INSERT INTO defaulted_insert DEFAULT VALUES",
       "notes": "DEFAULT VALUES inserts one row using catalog defaults. DEFAULT is also accepted in an individual VALUES slot."
     },
+    {
+      "id": "mutation.insert-runtime-values",
+      "status": "supported",
+      "setup": [
+        "CREATE TABLE runtime_values (id INTEGER PRIMARY KEY, noted_at TIMESTAMP, sample DOUBLE PRECISION, token UUID)"
+      ],
+      "example": "INSERT INTO runtime_values VALUES (1, CURRENT_TIMESTAMP, RANDOM(), GEN_RANDOM_UUID()) RETURNING id",
+      "notes": "Statement-time, random, UUID, and sequence calls in VALUES are evaluated at execution rather than frozen in the compiled-statement cache. Every CURRENT_* call in one statement shares one clock."
+    },
     {
       "id": "mutation.update-keyed",
       "status": "supported",
@@ -605,7 +620,7 @@
       "id": "select.distinct-wildcard",
       "status": "supported",
       "example": "SELECT DISTINCT * FROM rows",
-      "notes": "Expands to DISTINCT over every wildcard output column once input schemas are known."
+      "notes": "Expands bare or qualified wildcards to exactly their selected source columns before DISTINCT grouping is planned."
     },
     {
       "id": "limit.offset",
@@ -806,7 +821,7 @@
       "id": "order-by.ordinal",
       "status": "supported",
       "example": "SELECT region, amount FROM rows ORDER BY 2 DESC",
-      "notes": "Ordinals resolve to the select list at compile time; out-of-range ordinals are an error."
+      "notes": "Ordinals resolve after schema-bound wildcard expansion when needed; out-of-range ordinals are an error."
     },
     {
       "id": "window.lag-lead",
@@ -818,7 +833,7 @@
       "id": "mutation.insert-select",
       "status": "supported",
       "example": "INSERT INTO keyed (name, score) SELECT name || '2' AS name, score + 1 AS score FROM keyed",
-      "notes": "The SELECT runs at one snapshot and materializes before the batch write."
+      "notes": "The SELECT runs at one snapshot and materializes before the batch write. Bare and qualified wildcard select lists are supported and their expanded width is checked against the target columns."
     },
     {
       "id": "mutation.merge",
@@ -899,7 +914,13 @@
       "id": "select.qualified-wildcard",
       "status": "supported",
       "example": "SELECT rows.* FROM rows",
-      "notes": "Output names follow the rule a bare * uses: the column's own name from one source, alias-qualified from several."
+      "notes": "Output names follow the rule a bare * uses: the column's own name from one source, alias-qualified from several. Expansion happens before shape-dependent planning, so qualified wildcards compose with DISTINCT, windows, set operations, CTE/derived column lists, ORDER BY expressions and ordinals, and INSERT SELECT."
+    },
+    {
+      "id": "select.wildcard-window-composition",
+      "status": "supported",
+      "example": "SELECT rows.*, ROW_NUMBER() OVER (ORDER BY amount) AS position FROM rows ORDER BY amount",
+      "notes": "Wildcard columns are schema-bound before window lowering. The generated conformance corpus also crosses wildcards with DISTINCT, set operations, column lists, and ORDER BY expressions and ordinals."
     },
     {
       "id": "from.column-alias-list",