@quereus/store 4.5.0 → 4.7.0

package/dist/src/common/store-module-access-plan.js

@@ -0,0 +1,428 @@
+/**
+ * Access planning for a store-backed table: which physical access path
+ * (`_primary_` point / range seek, a secondary-index seek or multi-seek, or a full
+ * scan) this module advertises for a pushed predicate, which of the pushed filters it
+ * claims as handled, and what ordering the chosen path provides.
+ *
+ * The mirror of `store-table-scan.ts`: the planner here decides which access path to
+ * advertise, and the scan layer there executes it. A plan that claims a filter the scan
+ * cannot honor drops the residual Filter and returns wrong rows, so every soundness
+ * predicate the two share lives in `pk-key-resolution.ts` (`keyOrderMatchesCollation`,
+ * `indexLeadingRangeIsOrderSafe`, `pkOrderPreservingPrefixLength`) rather than being
+ * restated here. The declines that are NOT shared — partial indexes, the multi-seek cap,
+ * and the semantic-ordering column ban on multi-seeks specifically — are stated in both
+ * files, and changing one means changing the other.
+ *
+ * Free functions rather than a layer of the store-module chain — access planning reads
+ * no module state beyond the table's configured key collation, which the caller passes in.
+ */
+import { AccessPlanBuilder, equalitySeekKeyCount, hasSemanticOrdering, isMultiValueEquality } from '@quereus/quereus';
+import { indexLeadingRangeIsOrderSafe, indexPrefixSeekIsCollationExact, pkOrderPreservingPrefixLength, resolveIndexKeyCollations, resolvePkKeyCollations, } from './pk-key-resolution.js';
+/**
+ * Planner-side constraint operator groups, as `BestAccessPlanRequest.filters` spells
+ * them. Kept as one source of truth for the access-plan code below: {@link computeBestAccessPlan}
+ * classifies each pushed filter with these, and {@link tryIndexAccessPlan} claims a filter as
+ * handled only when it falls in the group the engine's access-path rule will consume.
+ */
+const EQ_OPS = ['='];
+/**
+ * Secondary-index arm ONLY: an IN is N equalities served as one multi-seek (`plan=5`),
+ * whether its members are a literal list or a runtime-valued set. The primary-key arms
+ * deliberately keep {@link EQ_OPS} — a `_primary_` multi-seek's emission order would
+ * break the isolation layer's primary-key merge — so an IN on the PK declines here,
+ * runtime-valued or not. PK IN support is deferred; see
+ * tickets/backlog/feat-store-pk-in-list-multiseek.
+ */
+const EQ_OR_IN_OPS = ['=', 'IN'];
+const LOWER_BOUND_OPS = ['>', '>='];
+const UPPER_BOUND_OPS = ['<', '<='];
+const RANGE_OPS = [...LOWER_BOUND_OPS, ...UPPER_BOUND_OPS];
+/**
+ * Ceiling on the seek keys a single IN-list multi-seek may claim (the cross-product
+ * for a composite seek). Above it the plan declines to cost-only — residual retained,
+ * answer right, only the speed-up lost. The FK RESTRICT batch chunks at 500 keys, so
+ * 1000 leaves headroom while stopping an `a in (1..100) and b in (1..100)` 10k-seek
+ * explosion.
+ */
+const MAX_MULTI_SEEK_KEYS = 1000;
+/** Cost of positioning one index seek, in the same unit as the per-row fetch cost. */
+const INDEX_SEEK_COST = 0.5;
+/**
+ * Build `handledFilters` by claiming ONLY the constraints `rule-select-access-path`
+ * actually consumes: per seek column the FIRST '=' (equality seek), or the FIRST lower
+ * ('>'/'>=') plus the FIRST upper ('<'/'<=') bound, selected by `colConstraints.find(...)`
+ * in `request.filters` order.
+ *
+ * That rule collapses `handledFilters` into a per-COLUMN set, so a redundant same-column,
+ * same-role constraint marked handled is neither turned into a seek bound nor kept by
+ * `ruleGrowRetrieve` as a residual — its predicate would be LOST (`where v > 10 and v > 30`
+ * would wrongly return the `v > 10` rows; `where v = 20 and v = 30` would wrongly return
+ * the `v = 20` row). The engine now reattaches such orphans defensively, but a module that
+ * over-claims still pays a redundant predicate evaluation per fetched row.
+ *
+ * Claiming must therefore be POSITIONAL and match the rule's first-match pick: claiming the
+ * tighter-but-later duplicate instead would be actively wrong (the rule would still seek on
+ * the earlier one). Any later duplicate stays unhandled so it survives in the residual Filter.
+ */
+function claimFirstPerRole(filters, roles) {
+    const claimed = new Set();
+    for (const { colIdx, ops } of roles) {
+        // An 'IN' fills an equality role only when well-formed — a non-empty literal list
+        // or a runtime-valued set. Same shape gate the rule's pick applies, so a malformed
+        // IN is neither claimed here nor seeked there and survives as a residual.
+        const i = filters.findIndex(f => f.columnIndex === colIdx && ops.includes(f.op)
+            && (f.op !== 'IN' || equalitySeekKeyCount(f) !== null));
+        if (i >= 0)
+            claimed.add(i);
+    }
+    return filters.map((_f, i) => claimed.has(i));
+}
+/** The lower-bound + upper-bound roles a single-column range seek on `colIdx` fills. */
+function rangeRoles(colIdx) {
+    return [{ colIdx, ops: LOWER_BOUND_OPS }, { colIdx, ops: UPPER_BOUND_OPS }];
+}
+/**
+ * The one equality role each seek column of an equality/prefix seek fills. `ops` is
+ * explicit so the PK arm ({@link EQ_OPS}) and the secondary-index arm
+ * ({@link EQ_OR_IN_OPS}) cannot drift into each other — see the note on EQ_OR_IN_OPS.
+ */
+function equalityRoles(colIdxs, ops) {
+    return colIdxs.map(colIdx => ({ colIdx, ops }));
+}
+/**
+ * The access plan this module advertises for `request`, before the caller stamps the
+ * module-wide `honorsCollatedRangeBounds` flag onto it.
+ *
+ * `tableKeyCollation` is the table's resolved key collation K, passed in rather than
+ * looked up: the caller (`StoreModule.getBestAccessPlan`) owns the module's table map.
+ * It is the PRIMARY-KEY arms' concern only — `resolvePkKeyCollations` still falls back to
+ * K for an undecorated text PK member. The secondary-index arm never sees it: index key
+ * bytes encode under each index column's own collation, so {@link tryIndexAccessPlan}
+ * judges its filters against that instead.
+ */
+export function computeBestAccessPlan(db, tableInfo, request, tableKeyCollation) {
+    const estimatedRows = request.estimatedRows ?? 1000;
+    // Check for primary key equality constraints. Count DISTINCT pinned PK columns:
+    // counting raw '=' filters would read `a = 1 and a = 2` on a composite PK (a, b)
+    // as "both PK columns pinned", claim both filters handled, then — with no
+    // complete PK equality set to seek — degrade to a sequential scan whose residual
+    // has already been discarded, returning the whole table.
+    const pkColumns = tableInfo.primaryKeyDefinition.map(pk => pk.index);
+    const pinnedPkColumns = new Set(request.filters
+        .filter(f => f.columnIndex !== undefined && pkColumns.includes(f.columnIndex) && f.op === '=')
+        .map(f => f.columnIndex));
+    if (pinnedPkColumns.size === pkColumns.length && pkColumns.length > 0) {
+        // Full PK match - point lookup (single row; no monotonic advertisement)
+        return AccessPlanBuilder
+            .eqMatch(1, 0.1)
+            .setHandledFilters(claimFirstPerRole(request.filters, equalityRoles(pkColumns, EQ_OPS)))
+            .setIsSet(true)
+            .setIndexName('_primary_')
+            .setExplanation('Store primary key lookup')
+            .build();
+    }
+    // Check for range constraints on the leading PK column.
+    // The legacy access-path rule (rule-select-access-path.ts) only forwards
+    // range bounds for primaryKeyDefinition[0]; ranges on later PK columns
+    // are silently dropped if marked handled. So only claim handled=true
+    // when the range is on the first PK column.
+    //
+    // The seek is also declined when the leading PK column's key bytes do not order the
+    // way its comparator does (`pkOrderPreservingPrefix === 0`): `StoreTable.analyzePKAccess`
+    // declines the byte window under exactly that condition, so claiming the range filters
+    // handled here would drop the residual Filter and return the whole table.
+    const pkOrderPreservingPrefix = pkOrderPreservingPrefixLength(db, tableInfo, resolvePkKeyCollations(tableInfo.primaryKeyDefinition, tableInfo.columns, tableKeyCollation), tableKeyCollation);
+    const firstPkColumn = tableInfo.primaryKeyDefinition[0]?.index;
+    const hasLeadingPkRange = firstPkColumn !== undefined
+        && pkOrderPreservingPrefix >= 1
+        && request.filters.some(f => f.columnIndex === firstPkColumn && RANGE_OPS.includes(f.op));
+    if (hasLeadingPkRange) {
+        // Range scan on first PK column. Iteration is by PK key order (see
+        // StoreTable.scanPKRange), so we can advertise monotonic emission on
+        // the leading PK column. The scan seeks to the window start and
+        // early-terminates (StoreTable.buildPKRangeBounds derives the encoded
+        // bounds), and the leading-PK order guarantee holds throughout.
+        const rangeRows = Math.max(1, Math.floor(estimatedRows * 0.3));
+        const plan = AccessPlanBuilder
+            .rangeScan(rangeRows, 0.2)
+            .setHandledFilters(claimFirstPerRole(request.filters, rangeRoles(firstPkColumn)))
+            .setIndexName('_primary_')
+            .setSeekColumns([firstPkColumn])
+            .setExplanation('Store primary key range scan')
+            .build();
+        return { ...plan, ...buildPkOrderingAdvertisement(tableInfo, request, pkOrderPreservingPrefix) };
+    }
+    // Check for secondary index usage. `StoreTable.query` now implements the
+    // secondary-index scan arm (leading-prefix EQ point / leading-column range),
+    // so we advertise the index with `indexName` + `seekColumns` and mark the
+    // covered filters handled — subject to the range arm's order-safety gate in
+    // {@link tryIndexAccessPlan}. A cost-only plan (no seek) is kept as a fallback
+    // when no index yields a sound seek, preserving the prior "cheaper cost, filters
+    // unhandled, residual retained" behavior.
+    const indexes = tableInfo.indexes || [];
+    let bestSeekPlan = null;
+    let costOnlyFallback = null;
+    for (const index of indexes) {
+        if (index.columns.length === 0)
+            continue;
+        const plan = tryIndexAccessPlan(db, tableInfo, request, index, estimatedRows);
+        if (!plan)
+            continue;
+        // A fully-handled seek (indexName + seekColumns set) is a candidate: keep the
+        // cheapest one seen so far rather than the first, so declaration order of the
+        // indexes doesn't decide the plan. Strict '<' so ties keep the first candidate,
+        // matching MemoryTableModule.findBestAccessPlan's `indexPlan.cost < bestPlan.cost`.
+        if (plan.seekColumnIndexes && plan.seekColumnIndexes.length > 0) {
+            if (!bestSeekPlan || plan.cost < bestSeekPlan.cost)
+                bestSeekPlan = plan;
+            continue;
+        }
+        // Otherwise remember the first cost-only advertisement as a fallback.
+        if (!costOnlyFallback)
+            costOnlyFallback = plan;
+    }
+    if (bestSeekPlan)
+        return bestSeekPlan;
+    // NOTE: a cost-only plan carries no PK-order advertisement even though the store still
+    // iterates in PK key order for it (`StoreTable.query` full-scans), so `... where v > 'x'
+    // order by <pk>` picks up a Sort it did not need. Still true, just rarer than it was: an
+    // index range on a plain BINARY text column of a default-K (NOCASE) table now gets its
+    // seek and no longer lands here — what remains is a range under a collation without the
+    // `orderPreserving` assertion, an `any` column with a declared COLLATE, a semantic-ordering
+    // column, and the multi-seek declines. If it shows up as slow, merge
+    // `buildPkOrderingAdvertisement(...)` into this return.
+    //
+    // NOTE: cost-only fallback deliberately stays first-wins, not min-cost. These plans
+    // handle no filters — the scan full-scans regardless of which index "wins" — so
+    // "cheapest" among them isn't a meaningful ranking; picking a lower-cost one here would
+    // just under-state the plan's advertised cost to the optimizer without changing the work.
+    if (costOnlyFallback)
+        return costOnlyFallback;
+    // Fallback to full scan. The store iterates rows in PK key order
+    // (see StoreTable.query / store.iterate over buildFullScanBounds), so
+    // the scan is monotonic on the leading PK column. Advertise that so
+    // downstream rules (merge-join, asof-scan) can fire on store-backed
+    // tables, matching memory-mode behavior.
+    const plan = AccessPlanBuilder
+        .fullScan(estimatedRows)
+        .setHandledFilters(new Array(request.filters.length).fill(false))
+        .setExplanation('Store full table scan')
+        .build();
+    return { ...plan, ...buildPkOrderingAdvertisement(tableInfo, request, pkOrderPreservingPrefix) };
+}
+/**
+ * Build the access plan for one secondary index against `request`, or null when
+ * the index is not usable for this predicate.
+ *
+ * Usable = a contiguous leading-prefix EQ on the index columns (an index seek /
+ * point), or a LT/LE/GT/GE range on the LEADING index column. These mirror the
+ * two windows `StoreTable.analyzeIndexAccess` can build.
+ *
+ * **Collation safety.** Index-column key bytes are encoded under each column's own key
+ * collation (`resolveIndexKeyCollations`); `StoreTable.matchesFilters` re-checks a fetched
+ * row under the index column's `COLLATE` else the table column's declared collation. Both
+ * arms below ask whether those two agree — the question is no longer about the table key
+ * collation K at all, which is why this function never sees it:
+ *
+ *  - EQUALITY — {@link indexPrefixSeekIsCollationExact}: agreement makes the window
+ *    EXACTLY the qualifying set. A `text` or `any` column always agrees (both key under
+ *    the same resolution the residual uses); a collation-blind column (`json`, the
+ *    temporal types) under an index column with an explicit non-BINARY COLLATE does not
+ *    (its key bytes are hard-BINARY) and declines.
+ *  - RANGE — {@link indexLeadingRangeIsOrderSafe}: the same agreement PLUS the collation's
+ *    `orderPreserving` assertion, because a byte window also equates memcmp of the key
+ *    bytes with the residual comparator's order.
+ *
+ * `StoreTable.analyzeIndexAccess` gates its windows on the same two helpers, so the "mark
+ * handled" and "build a window" decisions cannot disagree. A decline returns a cost-only
+ * plan: cheaper cost, filters unhandled, residual retained; correct, just not sped up.
+ */
+function tryIndexAccessPlan(db, tableInfo, request, index, estimatedRows) {
+    // Exclude PARTIAL indexes from access planning: neither the engine nor this
+    // module checks that the query's WHERE implies the index predicate, so seeking
+    // a partial index for a query it doesn't cover would silently drop the rows the
+    // index omits (an out-of-scope predicate returns nothing). Treat partial indexes
+    // purely as uniqueness enforcers — the query full-scans + residual instead.
+    // Mirrors MemoryTableModule.getAvailableIndexes (`if (idx.predicate) continue`).
+    if (index.predicate)
+        return null;
+    const indexColIndexes = index.columns.map(c => c.index);
+    // Contiguous leading-prefix equality → point/prefix seek. An IN filter counts as
+    // an equality here (it is N equalities, served as one multi-seek by
+    // StoreTable.scanMultiSeek); `inCount` is the cross-product of the per-column
+    // seek-key counts (1 for a plain '='), matching the rule's seek-key count. The
+    // FIRST role-filling filter per column is what the rule seeks on, so its
+    // cardinality is the one that counts.
+    //
+    // A runtime-valued IN set contributes its `maxCount` ceiling — the worst case the
+    // engine may deliver — so every gate below (the MAX_MULTI_SEEK_KEYS cap, the
+    // semantic-ordering decline) judges it against the largest multi-seek it could
+    // ever be asked to perform.
+    const eqCols = [];
+    let inCount = 1;
+    // `isMultiSeek` is NOT `inCount > 1`: a runtime set is delivered as a `plan=5`
+    // multi-seek even at `maxCount === 1`, so the gates below must judge it as one
+    // rather than as the plain EQ its ceiling arithmetic would otherwise suggest.
+    // (`inCount > 1` implies this flag — every factor above 1 is a multi-value
+    // equality — so the flag only ever *adds* the maxCount-1 runtime-set case.)
+    let isMultiSeek = false;
+    for (const colIdx of indexColIndexes) {
+        const eqFilter = request.filters.find(f => f.columnIndex === colIdx && equalitySeekKeyCount(f) !== null);
+        if (!eqFilter)
+            break;
+        eqCols.push(colIdx);
+        inCount *= equalitySeekKeyCount(eqFilter);
+        if (isMultiValueEquality(eqFilter))
+            isMultiSeek = true;
+    }
+    const leadingCol = indexColIndexes[0];
+    const hasLeadingRange = request.filters.some(f => f.columnIndex === leadingCol && RANGE_OPS.includes(f.op));
+    let seekCols;
+    let isRange;
+    if (eqCols.length > 0) {
+        seekCols = eqCols;
+        isRange = false;
+    }
+    else if (hasLeadingRange) {
+        seekCols = [leadingCol];
+        isRange = true;
+    }
+    else {
+        return null; // this index cannot serve this predicate
+    }
+    const rows = isRange
+        ? Math.max(1, Math.floor(estimatedRows * 0.3))
+        : Math.max(1, Math.floor(estimatedRows * 0.1));
+    const costOnly = (why) => (isRange ? AccessPlanBuilder.rangeScan(rows, 0.2) : AccessPlanBuilder.eqMatch(rows, 0.3))
+        .setHandledFilters(new Array(request.filters.length).fill(false))
+        .setExplanation(`Store index scan on ${index.name} (${why})`)
+        .build();
+    // Collation gates — see the doc comment above. `StoreTable.analyzeIndexAccess` declines
+    // exactly the same windows through the same two helpers.
+    const indexKeyCollations = resolveIndexKeyCollations(index, tableInfo.columns);
+    if (isRange) {
+        if (!indexLeadingRangeIsOrderSafe(db, tableInfo.columns, index, indexKeyCollations)) {
+            return costOnly('cost-only; index range needs an order-preserving key collation');
+        }
+    }
+    else if (!indexPrefixSeekIsCollationExact(tableInfo.columns, index, indexKeyCollations, seekCols.length)) {
+        return costOnly('cost-only; index key collation differs from the comparison collation');
+    }
+    // Multi-seek declines. Cost-only keeps the residual, so the answer stays right
+    // and only the speed-up is lost.
+    if (inCount > MAX_MULTI_SEEK_KEYS) {
+        return costOnly(`cost-only; IN cross-product of ${inCount} exceeds the ${MAX_MULTI_SEEK_KEYS}-seek cap`);
+    }
+    if (isMultiSeek && seekCols.some(colIdx => hasSemanticOrdering(tableInfo.columns[colIdx]?.logicalType))) {
+        // A plain EQ on a TIMESPAN/JSON column now seeks: `StoreTable.analyzeIndexAccess`
+        // encodes the probe through the column's key transform ('PT1H' and 'PT60M' collide
+        // on one key) and, for a probe with no faithful byte position, simply stops its
+        // prefix short and lets the residual re-filter under the type's compare. A
+        // multi-seek has neither escape — its merged windows ARE the whole access, with the
+        // residual already dropped — so an unfaithful member of the IN list would silently
+        // lose its tuple's rows or raise out of the key encoder. See `scanMultiSeek` and
+        // backlog `feat-store-semantic-key-multiseek`.
+        return costOnly('cost-only; semantic-ordering seek column cannot multi-seek');
+    }
+    // Claim positionally — see {@link claimFirstPerRole}.
+    const handledFilters = claimFirstPerRole(request.filters, isRange ? rangeRoles(leadingCol) : equalityRoles(eqCols, EQ_OR_IN_OPS));
+    if (isMultiSeek) {
+        // Multi-seek (plan=5): inCount point seeks, `rows` matched per seek key. The
+        // per-seek positioning term keeps a 500-key IN over a 10-row table from pricing
+        // below a full scan and issuing 500 seeks to read 10 rows. `isSet` false mirrors
+        // MemoryTableModule.evaluateIndexAccess's setIsSet(!isMultiSeek). No ordering is
+        // advertised — window emission order is encoded-key order, not any column order.
+        const multiRows = Math.min(estimatedRows, inCount * rows);
+        return AccessPlanBuilder.eqMatch(multiRows, inCount * INDEX_SEEK_COST)
+            .setIsSet(false)
+            .setHandledFilters(handledFilters)
+            .setIndexName(index.name)
+            .setSeekColumns(seekCols)
+            .setExplanation(`Store index multi-seek(${inCount}) on ${index.name}`)
+            .build();
+    }
+    return (isRange ? AccessPlanBuilder.rangeScan(rows, 0.2) : AccessPlanBuilder.eqMatch(rows, 0.3))
+        .setHandledFilters(handledFilters)
+        .setIndexName(index.name)
+        .setSeekColumns(seekCols)
+        .setExplanation(`Store index ${isRange ? 'range scan' : 'seek'} on ${index.name}`)
+        .build();
+}
+/**
+ * Compute the PK-ordering advertisement for a scan-style plan. Returns the
+ * `providesOrdering` / `monotonicOn` / `supportsAsofRight` fields for a plan
+ * whose iteration is driven by the primary-key key order (full scan or PK
+ * range scan).
+ *
+ * `providesOrdering` is set only when it actually matches what the caller
+ * needs:
+ *   - When the request carries `requiredOrdering`, claim it only if the
+ *     requested keys form a prefix of the PK with matching directions.
+ *     Claiming PK order against an `ORDER BY <other column>` would cause
+ *     the absorb-Sort rule to drop the Sort and yield wrong-order rows.
+ *   - When no `requiredOrdering` is present, advertise the full PK
+ *     ordering so downstream rules (merge-join, sort elision after a
+ *     filter) can opportunistically use it.
+ *
+ * `monotonicOn` reflects the access path itself and is independent of any
+ * `requiredOrdering`; it always advertises the leading PK column. Strict
+ * monotonicity is claimed iff the PK is single-column — composite PKs can
+ * repeat values on the leading column.
+ *
+ * Returns an empty object when there is no PK (heap-only table) — without a
+ * leading key column there is no natural emit order.
+ *
+ * Every claim here is about the PHYSICAL key-byte order the store iterates in, but the
+ * consumers of `providesOrdering` / `monotonicOn` reason in the columns' COLLATION order.
+ * `orderPreservingPrefix` (from {@link pkOrderPreservingPrefixLength}) is how many leading
+ * PK members those two orders provably agree on: the advertisement is truncated to that
+ * prefix, and voided entirely when even the leading member disagrees — otherwise the
+ * absorb-Sort rule would elide a Sort and hand the caller byte-ordered rows.
+ */
+function buildPkOrderingAdvertisement(tableInfo, request, orderPreservingPrefix) {
+    const pk = tableInfo.primaryKeyDefinition;
+    if (pk.length === 0 || orderPreservingPrefix === 0)
+        return {};
+    const leading = pk[0];
+    const monotonicOn = {
+        columnIndex: leading.index,
+        direction: leading.desc ? 'desc' : 'asc',
+        strict: pk.length === 1,
+    };
+    const pkOrdering = pk.slice(0, orderPreservingPrefix).map(col => ({
+        columnIndex: col.index,
+        desc: !!col.desc,
+    }));
+    // Pick the providesOrdering to advertise based on requiredOrdering.
+    const required = request.requiredOrdering;
+    let providesOrdering;
+    if (required && required.length > 0) {
+        // Only claim ordering when the requested keys form a prefix of the
+        // PK with matching directions. nullsFirst is intentionally not
+        // matched here — if the request specifies an explicit NULLS
+        // FIRST/LAST, leave the Sort in place rather than assume the PK
+        // scan's natural NULL placement matches.
+        if (required.length > pkOrdering.length)
+            return { monotonicOn, supportsAsofRight: true };
+        for (let i = 0; i < required.length; i++) {
+            if (required[i].columnIndex !== pkOrdering[i].columnIndex)
+                return { monotonicOn, supportsAsofRight: true };
+            if (required[i].desc !== pkOrdering[i].desc)
+                return { monotonicOn, supportsAsofRight: true };
+            if (required[i].nullsFirst !== undefined)
+                return { monotonicOn, supportsAsofRight: true };
+        }
+        providesOrdering = required;
+    }
+    else {
+        providesOrdering = pkOrdering;
+    }
+    return {
+        providesOrdering,
+        orderingIndexName: '_primary_',
+        monotonicOn,
+        supportsAsofRight: true,
+    };
+}
+// --- StoreTableModule interface implementation ---
+//# sourceMappingURL=store-module-access-plan.js.map

package/dist/src/common/store-module-access-plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-module-access-plan.js","sourceRoot":"","sources":["../../../src/common/store-module-access-plan.ts"],"names":[],"mappings":"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"}

package/dist/src/common/store-module-alter-column.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ALTER TABLE ... ALTER COLUMN: the one ALTER arm that can rewrite stored values and
+ * re-encode physical keys. The orchestrating method decides the order of the throw-only
+ * checks and the mutations; the per-attribute sub-branches below it are pure — each
+ * returns the rewritten column schema plus a DEFERRED value-rewrite closure, mutating
+ * nothing itself.
+ *
+ * Fifth layer of the store-module chain:
+ *   StoreModuleBase -> StoreModuleCatalog -> StoreModuleSchemaSync -> StoreModuleIndex
+ *   -> StoreModuleAlterColumn -> StoreModuleAlter -> StoreModuleRename -> StoreModule
+ */
+import type { Database, EffectiveRowSource, SchemaChangeInfo, TableSchema } from '@quereus/quereus';
+import { StoreTable } from './store-table.js';
+import { StoreModuleIndex } from './store-module-index.js';
+export declare abstract class StoreModuleAlterColumn extends StoreModuleIndex {
+    /** ALTER COLUMN arm of `StoreModuleAlter.alterTable`: change one attribute (NOT NULL / data type /
+     *  default / collation), running the physical re-key + existing-row re-validation the
+     *  collation / PK paths require, then persist. Behavior-preserving extraction. */
+    protected alterColumnChange(db: Database, schemaName: string, tableName: string, table: StoreTable, oldSchema: TableSchema, change: Extract<SchemaChangeInfo, {
+        type: 'alterColumn';
+    }>, rows?: EffectiveRowSource): Promise<TableSchema>;
+}
+//# sourceMappingURL=store-module-alter-column.d.ts.map

package/dist/src/common/store-module-alter-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-module-alter-column.d.ts","sourceRoot":"","sources":["../../../src/common/store-module-alter-column.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAEX,QAAQ,EACR,kBAAkB,EAElB,gBAAgB,EAEhB,WAAW,EACX,MAAM,kBAAkB,CAAC;AAS1B,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAyB3D,8BAAsB,sBAAuB,SAAQ,gBAAgB;IACpE;;sFAEkF;cAClE,iBAAiB,CAChC,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,OAAO,CAAC,gBAAgB,EAAE;QAAE,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC,EAC1D,IAAI,CAAC,EAAE,kBAAkB,GACvB,OAAO,CAAC,WAAW,CAAC;CAwNvB"}