@quereus/quereus 4.17.1 → 4.19.0

package/dist/src/planner/util/column-refs.js

@@ -0,0 +1,30 @@
+/**
+ * Column-reference walks over scalar plan subtrees.
+ *
+ * Lives here rather than in `analysis/constraint-extractor.ts` so that
+ * `planner/nodes/` can import it as a *value*: the runtime cycle
+ * `constraint-extractor → nodes/reference → …` is real, and this module
+ * deliberately depends on nothing but the node-type enum.
+ */
+import { PlanNodeType } from '../nodes/plan-node-type.js';
+/**
+ * Collect the attributeIds of every ColumnReference in a scalar subtree.
+ * Walking into children (rather than only unwrapping a top-level Cast) reaches
+ * references nested inside arithmetic, function calls, casts, etc. — e.g.
+ * `outer.id + 1`, `coalesce(outer.id, 0)`, `cast(outer.id + 1 as integer)`.
+ */
+export function collectColumnRefAttributeIds(node) {
+    const ids = [];
+    const stack = [node];
+    while (stack.length) {
+        const n = stack.pop();
+        if (n.nodeType === PlanNodeType.ColumnReference) {
+            ids.push(n.attributeId);
+        }
+        for (const c of n.getChildren()) {
+            stack.push(c);
+        }
+    }
+    return ids;
+}
+//# sourceMappingURL=column-refs.js.map

package/dist/src/planner/util/column-refs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-refs.js","sourceRoot":"","sources":["../../../../src/planner/util/column-refs.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAI1D;;;;;GAKG;AACH,MAAM,UAAU,4BAA4B,CAAC,IAAoB;IAChE,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,MAAM,KAAK,GAAqB,CAAC,IAAI,CAAC,CAAC;IACvC,OAAO,KAAK,CAAC,MAAM,EAAE,CAAC;QACrB,MAAM,CAAC,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;QACvB,IAAI,CAAC,CAAC,QAAQ,KAAK,YAAY,CAAC,eAAe,EAAE,CAAC;YACjD,GAAG,CAAC,IAAI,CAAE,CAAoC,CAAC,WAAW,CAAC,CAAC;QAC7D,CAAC;QACD,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;YACjC,KAAK,CAAC,IAAI,CAAC,CAA8B,CAAC,CAAC;QAC5C,CAAC;IACF,CAAC;IACD,OAAO,GAAG,CAAC;AACZ,CAAC"}

package/dist/src/planner/util/row-estimates.d.ts

@@ -36,4 +36,95 @@ export declare function physicalSourceRows(childPhysical: PhysicalProperties | u
  * @param groupDivisor rows-per-group assumption for the grouped estimate
  */
 export declare function aggregateRowsFrom(sourceRows: number | undefined, grouped: boolean, groupDivisor: number): number | undefined;
+/**
+ * ## Data-modifying nodes: rows EMITTED, not rows written
+ *
+ * Every estimate in this file counts the rows a node puts on its own output
+ * stream. For the write family (`InsertNode`, `UpdateNode`, `DeleteNode`,
+ * `ConstraintCheckNode`, `DmlExecutorNode`, `ReturningNode`) that stream tracks
+ * the source at most one-for-one — the prep nodes yield one flat OLD/NEW row per
+ * source row and `ReturningNode` projects one row per written row — so every
+ * member relays its source count unchanged.
+ *
+ * That relay is an UPPER BOUND, not an exact count, because two members can drop
+ * a row silently. `ConstraintCheckNode` skips a row whose NOT NULL / CHECK
+ * violation resolves to `IGNORE` (`runtime/row-constraints.ts` returns
+ * `{ skip: true }` and the emitter `continue`s), and `DmlExecutorNode` yields
+ * nothing for a row it did not write (`insert or ignore` onto an existing key,
+ * `on conflict do nothing`, an update whose row is no longer there). Neither skip
+ * rate is modelled: both are properties of the data, not of the plan, and
+ * inventing a discount would be less honest than the bound. Consumers of a
+ * write's estimate size buffers and pick strategies, which an upper bound serves
+ * correctly.
+ *
+ * The two readings only diverge at the statement boundary, and that boundary is
+ * a different node: a statement with no `returning` is topped by a `SinkNode`,
+ * which drains the write stream and reports the single changes-count row
+ * (`SinkNode.estimatedRows === 1`). So a consumer reading `estimatedRows` on a
+ * DML node is asking "how much work flows through this write pipeline", which is
+ * what sort strategy / cache thresholds above it want; a consumer asking "how
+ * many rows does this statement hand back" reads the Sink.
+ */
+/** Largest row estimate the relay will emit; see {@link clampRowEstimate}. */
+export declare const MAX_ROW_ESTIMATE: number;
+/**
+ * Normalize a composed row estimate to a finite, non-negative integer.
+ *
+ * Combinators that multiply (`crossProduct`) can push three large branches past
+ * `Number.MAX_SAFE_INTEGER` and on to `Infinity`; consumers do arithmetic on
+ * this value (selectivity multiplication, cache thresholds), so an `Infinity` or
+ * a fractional count leaks into cost comparisons and EXPLAIN output. Saturate at
+ * `MAX_ROW_ESTIMATE` instead — a saturated estimate is still "astronomically
+ * large", which is all any consumer does with it. `NaN` cannot survive either:
+ * it saturates too, since the only way to produce one here is an overflowed
+ * intermediate.
+ */
+export declare function clampRowEstimate(rows: number): number;
+/** The set operations `SetOperationNode` can carry. */
+export type SetOperationKind = 'union' | 'unionAll' | 'intersect' | 'except';
+/**
+ * A set operation's output cardinality as a pure function of its branches' —
+ * shared by `SetOperationNode`'s logical `estimatedRows` getter and its
+ * `computePhysical` (which feeds it the PHYSICAL branch counts) so the two
+ * cannot drift.
+ *
+ * - `unionAll` — the sum; no rows are removed.
+ * - `union` — the true count lies in `max(branches) … sum(branches)` and the
+ *   deduplication factor is unknown, so report the **sum**: the honest upper
+ *   bound. The deduplication happens inside the node's own emitter
+ *   (`runtime/emit/set-operation.ts`), not in a `Distinct` above it, so nothing
+ *   downstream narrows this claim — it stays an upper bound for the whole plan.
+ * - `intersect` — the min; the result is a subset of both branches.
+ * - `except` — the left branch's count. The right branch can only remove rows,
+ *   so the left count is an upper bound and the result can never go negative.
+ *
+ * `undefined` propagates from any branch the formula actually reads. `except`
+ * reads only the left branch, so an unknown right side does not blank it —
+ * the left bound is exactly as sound then as it is with a known right side.
+ */
+export declare function setOperationRowsFrom(op: SetOperationKind, leftRows: number | undefined, rightRows: number | undefined): number | undefined;
+/** The combinators `AsyncGatherNode` can carry. */
+export type GatherCombinatorKind = 'unionAll' | 'zipByKey' | 'crossProduct';
+/**
+ * An `AsyncGatherNode`'s output cardinality as a pure function of its branches' —
+ * shared by its logical `estimatedRows` getter and its `computePhysical` (which
+ * feeds it the PHYSICAL branch counts), the same discipline
+ * {@link aggregateRowsFrom} applies to the aggregate family.
+ *
+ * - `unionAll` — the sum, matching {@link setOperationRowsFrom}: a
+ *   PostOptimization rule substitutes a gather for a `union all`, and the two
+ *   shapes must not report different counts for the same rows.
+ * - `zipByKey` — the max. Distinct keys across branches bound the result at
+ *   `max(branches) … sum(branches)`; heavily overlapping keys is the normal case.
+ *   NOTE: this is the only arm that picks the LOW end of its range — every other
+ *   arm reports the upper bound. Now that the number is also stamped physically,
+ *   a low-key-overlap workload can under-size a buffer above the gather; if that
+ *   ever shows up, move this arm to the sum like the others.
+ * - `crossProduct` — the product, saturated by {@link clampRowEstimate} so three
+ *   large branches cannot emit `Infinity`.
+ *
+ * Any unknown branch makes the whole result unknown — every branch is an input
+ * to all three formulas.
+ */
+export declare function gatherRowsFrom(kind: GatherCombinatorKind, branchRows: readonly (number | undefined)[]): number | undefined;
 //# sourceMappingURL=row-estimates.d.ts.map

package/dist/src/planner/util/row-estimates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"row-estimates.d.ts","sourceRoot":"","sources":["../../../../src/planner/util/row-estimates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEpF;;;;;;;;GAQG;AAYH,wBAAgB,kBAAkB,CACjC,aAAa,EAAE,kBAAkB,GAAG,SAAS,EAC7C,MAAM,EAAE,kBAAkB,GACxB,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAChC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAiBpB"}
+{"version":3,"file":"row-estimates.d.ts","sourceRoot":"","sources":["../../../../src/planner/util/row-estimates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEpF;;;;;;;;GAQG;AAMH,wBAAgB,kBAAkB,CACjC,aAAa,EAAE,kBAAkB,GAAG,SAAS,EAC7C,MAAM,EAAE,kBAAkB,GACxB,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAChC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAapB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,QAA0B,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIrD;AAED,uDAAuD;AACvD,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,UAAU,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CACnC,EAAE,EAAE,gBAAgB,EACpB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC3B,MAAM,GAAG,SAAS,CAQpB;AAED,mDAAmD;AACnD,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG,UAAU,GAAG,cAAc,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAC7B,IAAI,EAAE,oBAAoB,EAC1B,UAAU,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GACzC,MAAM,GAAG,SAAS,CAoBpB"}

package/dist/src/planner/util/row-estimates.js

@@ -23,17 +23,11 @@
  * there the logical getter is the only number available, and it is still the
  * pre-optimization truth.
  */
-// NOTE: `SchemaManager` hardcodes `TableSchema.estimatedRows` to 0 at CREATE TABLE,
-// so a never-analyzed table's scan reports 0 — a value that means "unknown", not
-// "empty" (see the NOTE in `planner/stats/table-cardinality.ts`). That 0 now travels
-// much further than it used to: before this relay it died at the first operator that
-// read a logical getter, and consumers fell back to their own defaults instead. Any
-// consumer that reads a row estimate as a *magnitude* must therefore spell 0 as
-// unknown — `rule-cte-optimization` gates on `sourceSize > 0` and had to be taught
-// this (its `|| defaultRowEstimate` matches `vtab/memory/module.ts`); threshold
-// consumers that floor (the cache threshold's min of 1000) or use a `>` test are
-// unaffected. The real fix is distinguishing unknown from empty at the source —
-// not clamping here, which would erase a genuinely empty analyzed table.
+// Invariant: a row estimate has exactly two spellings — `undefined` means "nobody
+// knows" and a number (including a real 0, from an analyzed empty table) means
+// "measured or derived" (see `planner/stats/table-cardinality.ts`). A never-analyzed
+// table's scan reports `undefined`, not 0, so this relay may propagate any number it
+// sees as a genuine magnitude; consumers apply their own default only on `undefined`.
 export function physicalSourceRows(childPhysical, source) {
     return childPhysical?.estimatedRows ?? source.estimatedRows;
 }
@@ -54,15 +48,137 @@ export function aggregateRowsFrom(sourceRows, grouped, groupDivisor) {
     // (including the unknown sentinel — the count is not a function of the source).
     if (!grouped)
         return 1;
-    // 0 must pass through unchanged. It is both the genuinely-empty count (0 rows
-    // in ⇒ 0 groups out) and the never-analyzed "unknown" sentinel (see the NOTE
-    // on `physicalSourceRows`), and flooring it to 1 conflates them: unknown would
-    // leave here as a confident single row, which reads as a real magnitude and
-    // silently defeats every downstream `|| default` unknown-guard —
-    // `rule-join-physical-selection` costed a 1x1 join and kept the nested loop
-    // where both sides were un-analyzed grouped aggregates.
+    // 0 passes through unchanged: it now only ever means a genuinely empty source
+    // (never-analyzed is `undefined`, handled above), and 0 rows in ⇒ 0 groups
+    // out. Flooring it to 1 would claim a row an empty table cannot produce.
     if (sourceRows === 0)
         return 0;
     return Math.max(1, Math.floor(sourceRows / groupDivisor));
 }
+/**
+ * ## Data-modifying nodes: rows EMITTED, not rows written
+ *
+ * Every estimate in this file counts the rows a node puts on its own output
+ * stream. For the write family (`InsertNode`, `UpdateNode`, `DeleteNode`,
+ * `ConstraintCheckNode`, `DmlExecutorNode`, `ReturningNode`) that stream tracks
+ * the source at most one-for-one — the prep nodes yield one flat OLD/NEW row per
+ * source row and `ReturningNode` projects one row per written row — so every
+ * member relays its source count unchanged.
+ *
+ * That relay is an UPPER BOUND, not an exact count, because two members can drop
+ * a row silently. `ConstraintCheckNode` skips a row whose NOT NULL / CHECK
+ * violation resolves to `IGNORE` (`runtime/row-constraints.ts` returns
+ * `{ skip: true }` and the emitter `continue`s), and `DmlExecutorNode` yields
+ * nothing for a row it did not write (`insert or ignore` onto an existing key,
+ * `on conflict do nothing`, an update whose row is no longer there). Neither skip
+ * rate is modelled: both are properties of the data, not of the plan, and
+ * inventing a discount would be less honest than the bound. Consumers of a
+ * write's estimate size buffers and pick strategies, which an upper bound serves
+ * correctly.
+ *
+ * The two readings only diverge at the statement boundary, and that boundary is
+ * a different node: a statement with no `returning` is topped by a `SinkNode`,
+ * which drains the write stream and reports the single changes-count row
+ * (`SinkNode.estimatedRows === 1`). So a consumer reading `estimatedRows` on a
+ * DML node is asking "how much work flows through this write pipeline", which is
+ * what sort strategy / cache thresholds above it want; a consumer asking "how
+ * many rows does this statement hand back" reads the Sink.
+ */
+/** Largest row estimate the relay will emit; see {@link clampRowEstimate}. */
+export const MAX_ROW_ESTIMATE = Number.MAX_SAFE_INTEGER;
+/**
+ * Normalize a composed row estimate to a finite, non-negative integer.
+ *
+ * Combinators that multiply (`crossProduct`) can push three large branches past
+ * `Number.MAX_SAFE_INTEGER` and on to `Infinity`; consumers do arithmetic on
+ * this value (selectivity multiplication, cache thresholds), so an `Infinity` or
+ * a fractional count leaks into cost comparisons and EXPLAIN output. Saturate at
+ * `MAX_ROW_ESTIMATE` instead — a saturated estimate is still "astronomically
+ * large", which is all any consumer does with it. `NaN` cannot survive either:
+ * it saturates too, since the only way to produce one here is an overflowed
+ * intermediate.
+ */
+export function clampRowEstimate(rows) {
+    if (Number.isNaN(rows))
+        return MAX_ROW_ESTIMATE;
+    if (rows >= MAX_ROW_ESTIMATE)
+        return MAX_ROW_ESTIMATE;
+    return Math.max(0, Math.floor(rows));
+}
+/**
+ * A set operation's output cardinality as a pure function of its branches' —
+ * shared by `SetOperationNode`'s logical `estimatedRows` getter and its
+ * `computePhysical` (which feeds it the PHYSICAL branch counts) so the two
+ * cannot drift.
+ *
+ * - `unionAll` — the sum; no rows are removed.
+ * - `union` — the true count lies in `max(branches) … sum(branches)` and the
+ *   deduplication factor is unknown, so report the **sum**: the honest upper
+ *   bound. The deduplication happens inside the node's own emitter
+ *   (`runtime/emit/set-operation.ts`), not in a `Distinct` above it, so nothing
+ *   downstream narrows this claim — it stays an upper bound for the whole plan.
+ * - `intersect` — the min; the result is a subset of both branches.
+ * - `except` — the left branch's count. The right branch can only remove rows,
+ *   so the left count is an upper bound and the result can never go negative.
+ *
+ * `undefined` propagates from any branch the formula actually reads. `except`
+ * reads only the left branch, so an unknown right side does not blank it —
+ * the left bound is exactly as sound then as it is with a known right side.
+ */
+export function setOperationRowsFrom(op, leftRows, rightRows) {
+    if (leftRows === undefined)
+        return undefined;
+    // The right branch subtracts; it is not an input to the upper bound.
+    if (op === 'except')
+        return clampRowEstimate(leftRows);
+    if (rightRows === undefined)
+        return undefined;
+    if (op === 'intersect')
+        return clampRowEstimate(Math.min(leftRows, rightRows));
+    // union / unionAll: sum (see the `union` note above).
+    return clampRowEstimate(leftRows + rightRows);
+}
+/**
+ * An `AsyncGatherNode`'s output cardinality as a pure function of its branches' —
+ * shared by its logical `estimatedRows` getter and its `computePhysical` (which
+ * feeds it the PHYSICAL branch counts), the same discipline
+ * {@link aggregateRowsFrom} applies to the aggregate family.
+ *
+ * - `unionAll` — the sum, matching {@link setOperationRowsFrom}: a
+ *   PostOptimization rule substitutes a gather for a `union all`, and the two
+ *   shapes must not report different counts for the same rows.
+ * - `zipByKey` — the max. Distinct keys across branches bound the result at
+ *   `max(branches) … sum(branches)`; heavily overlapping keys is the normal case.
+ *   NOTE: this is the only arm that picks the LOW end of its range — every other
+ *   arm reports the upper bound. Now that the number is also stamped physically,
+ *   a low-key-overlap workload can under-size a buffer above the gather; if that
+ *   ever shows up, move this arm to the sum like the others.
+ * - `crossProduct` — the product, saturated by {@link clampRowEstimate} so three
+ *   large branches cannot emit `Infinity`.
+ *
+ * Any unknown branch makes the whole result unknown — every branch is an input
+ * to all three formulas.
+ */
+export function gatherRowsFrom(kind, branchRows) {
+    let acc = kind === 'crossProduct' ? 1 : 0;
+    for (const rows of branchRows) {
+        if (rows === undefined)
+            return undefined;
+        switch (kind) {
+            case 'unionAll':
+                acc += rows;
+                break;
+            case 'zipByKey':
+                acc = Math.max(acc, rows);
+                break;
+            case 'crossProduct':
+                // Saturate every step, not just the result: an overflowed `Infinity`
+                // intermediate followed by a provably-empty branch would otherwise
+                // multiply out to `NaN`.
+                acc = clampRowEstimate(acc * rows);
+                break;
+        }
+    }
+    return clampRowEstimate(acc);
+}
 //# sourceMappingURL=row-estimates.js.map

package/dist/src/planner/util/row-estimates.js.map

@@ -1 +1 @@
-{"version":3,"file":"row-estimates.js","sourceRoot":"","sources":["../../../../src/planner/util/row-estimates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH;;;;;;;;GAQG;AACH,oFAAoF;AACpF,iFAAiF;AACjF,qFAAqF;AACrF,qFAAqF;AACrF,oFAAoF;AACpF,gFAAgF;AAChF,mFAAmF;AACnF,gFAAgF;AAChF,iFAAiF;AACjF,gFAAgF;AAChF,yEAAyE;AACzE,MAAM,UAAU,kBAAkB,CACjC,aAA6C,EAC7C,MAA0B;IAE1B,OAAO,aAAa,EAAE,aAAa,IAAI,MAAM,CAAC,aAAa,CAAC;AAC7D,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAChC,UAA8B,EAC9B,OAAgB,EAChB,YAAoB;IAEpB,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAE/C,6EAA6E;IAC7E,gFAAgF;IAChF,IAAI,CAAC,OAAO;QAAE,OAAO,CAAC,CAAC;IAEvB,8EAA8E;IAC9E,6EAA6E;IAC7E,+EAA+E;IAC/E,4EAA4E;IAC5E,iEAAiE;IACjE,4EAA4E;IAC5E,wDAAwD;IACxD,IAAI,UAAU,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAE/B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,YAAY,CAAC,CAAC,CAAC;AAC3D,CAAC"}
+{"version":3,"file":"row-estimates.js","sourceRoot":"","sources":["../../../../src/planner/util/row-estimates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH;;;;;;;;GAQG;AACH,kFAAkF;AAClF,+EAA+E;AAC/E,qFAAqF;AACrF,qFAAqF;AACrF,sFAAsF;AACtF,MAAM,UAAU,kBAAkB,CACjC,aAA6C,EAC7C,MAA0B;IAE1B,OAAO,aAAa,EAAE,aAAa,IAAI,MAAM,CAAC,aAAa,CAAC;AAC7D,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAChC,UAA8B,EAC9B,OAAgB,EAChB,YAAoB;IAEpB,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAE/C,6EAA6E;IAC7E,gFAAgF;IAChF,IAAI,CAAC,OAAO;QAAE,OAAO,CAAC,CAAC;IAEvB,8EAA8E;IAC9E,2EAA2E;IAC3E,yEAAyE;IACzE,IAAI,UAAU,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAE/B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,YAAY,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,8EAA8E;AAC9E,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC5C,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,gBAAgB,CAAC;IAChD,IAAI,IAAI,IAAI,gBAAgB;QAAE,OAAO,gBAAgB,CAAC;IACtD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;AACtC,CAAC;AAKD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,oBAAoB,CACnC,EAAoB,EACpB,QAA4B,EAC5B,SAA6B;IAE7B,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC7C,qEAAqE;IACrE,IAAI,EAAE,KAAK,QAAQ;QAAE,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IACvD,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC9C,IAAI,EAAE,KAAK,WAAW;QAAE,OAAO,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;IAC/E,sDAAsD;IACtD,OAAO,gBAAgB,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC;AAC/C,CAAC;AAKD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,cAAc,CAC7B,IAA0B,EAC1B,UAA2C;IAE3C,IAAI,GAAG,GAAG,IAAI,KAAK,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1C,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC/B,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QACzC,QAAQ,IAAI,EAAE,CAAC;YACd,KAAK,UAAU;gBACd,GAAG,IAAI,IAAI,CAAC;gBACZ,MAAM;YACP,KAAK,UAAU;gBACd,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;gBAC1B,MAAM;YACP,KAAK,cAAc;gBAClB,qEAAqE;gBACrE,mEAAmE;gBACnE,yBAAyB;gBACzB,GAAG,GAAG,gBAAgB,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;gBACnC,MAAM;QACR,CAAC;IACF,CAAC;IACD,OAAO,gBAAgB,CAAC,GAAG,CAAC,CAAC;AAC9B,CAAC"}

package/dist/src/runtime/emit/alter-table.d.ts

@@ -6,10 +6,30 @@ export declare function emitAlterTable(plan: AlterTableNode, ctx: EmissionContex
 /**
  * Build the shadow-table CREATE TABLE DDL used by the non-memory rebuild path.
  *
- * Nullability is emitted explicitly for every column, matching the "no-db"
- * stance of `generateTableDDL` in ddl-generator.ts: safe under any session's
- * `default_column_nullability` setting. DEFAULT and COLLATE are preserved so
- * the shadow table faithfully mirrors the original schema.
+ * Rendered through the canonical emitter (`generateTableDDL`) over a copy of the
+ * REAL `TableSchema` with only the name and key substituted, so the shadow
+ * carries everything the table declares — constraints, foreign keys, tags,
+ * defaults, collations, generated columns, the key's ON CONFLICT action — not a
+ * hand-picked subset. An omission in emitted DDL is never neutral: a missing
+ * PRIMARY KEY clause re-parses as a different key (all-columns), and a missing
+ * constraint re-parses as no constraint.
+ *
+ * Called WITHOUT a `db` argument: that form fully qualifies the name, always
+ * emits USING, and annotates nullability on every column, so the text re-parses
+ * to the same shape under any session's `default_column_nullability` /
+ * `default_vtab_module` settings. An empty `newPkDef` emits `PRIMARY KEY ()` —
+ * the singleton key — rather than omitting the clause (which would re-parse as
+ * the opposite thing: keyed by every column).
+ *
+ * The copied schema's per-column `primaryKey` flags are stale (they still mirror
+ * the OLD key) — harmless: the emitter reads only `primaryKeyDefinition`, and the
+ * shadow's real schema is built by re-parsing the emitted text.
+ *
+ * Deliberately WHOLE-TABLE only (no column subset parameter): stored constraints
+ * address columns by index, so a subset copy would need every constraint and
+ * index remapped or dropped. `ALTER TABLE … DROP COLUMN` goes through
+ * `module.alterTable`, never through this rebuild; if a column-dropping rebuild
+ * is ever wanted it must come back with deliberate constraint handling.
  */
-export declare function buildShadowTableDdl(tableSchema: TableSchema, shadowName: string, survivingColumns: string[], newPkDef: PrimaryKeyColumnDefinition[]): string;
+export declare function buildShadowTableDdl(tableSchema: TableSchema, shadowName: string, newPkDef: PrimaryKeyColumnDefinition[]): string;
 //# sourceMappingURL=alter-table.d.ts.map

package/dist/src/runtime/emit/alter-table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alter-table.d.ts","sourceRoot":"","sources":["../../../../src/runtime/emit/alter-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAqC,MAAM,yCAAyC,CAAC;AACjH,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,aAAa,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAM9D,OAAO,KAAK,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAkDrF,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,WAAW,CAkJtF;AA2xDD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAClC,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,MAAM,EAAE,EAC1B,QAAQ,EAAE,0BAA0B,EAAE,GACpC,MAAM,CAuCR"}
+{"version":3,"file":"alter-table.d.ts","sourceRoot":"","sources":["../../../../src/runtime/emit/alter-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAqC,MAAM,yCAAyC,CAAC;AACjH,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,aAAa,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAM9D,OAAO,KAAK,EAAE,WAAW,EAAE,0BAA0B,EAAe,MAAM,uBAAuB,CAAC;AAmDlG,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,WAAW,CAkJtF;AAyyDD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CAClC,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,0BAA0B,EAAE,GACpC,MAAM,CAMR"}