@quereus/store 4.11.0 → 4.12.0

package/dist/src/common/store-table-scan.d.ts

@@ -11,6 +11,30 @@ import { IndexConstraintOp, type IdxStrSpec, type CollationFunction, type Compar
 import type { IterateOptions, KVStore } from './kv-store.js';
 import type { KeyValueTransform } from './encoding.js';
 import { StoreTableBase } from './store-table-base.js';
+/**
+ * Index entries per row-resolution batch: the scan arms below collect up to this many
+ * surviving index entries (or multi-seek point keys) and resolve them with ONE
+ * {@link StoreTableBase.readEffectiveRowsByKeys} call, so an indexed read of N rows
+ * costs on the order of N / 256 store round trips instead of N serialized point reads
+ * (on IndexedDB, one readonly transaction instead of N). This is the bound
+ * {@link KVStore.getMany}'s "bounded by the caller" note refers to.
+ *
+ * 256 matches the iterate pager's default page (`paged-iterate.ts` DEFAULT_BATCH_SIZE)
+ * and makes the same trade that pager already makes and the {@link KVStore.iterate}
+ * contract documents: a little early-termination cost for throughput — `limit 1`
+ * collects one batch rather than one row — while keeping peak memory independent of
+ * the range size.
+ *
+ * NOTE: that early-termination cost is bounded but not free — `limit 1` deserializes up
+ * to 256 rows to yield one, and holds them all at once. It is charged against ROUND
+ * TRIPS, which is what dominates on the backends this exists for (the index side already
+ * pages 256 entries per read, so a stopped scan costs one data round trip either way),
+ * so it is accepted as-is. Revisit if a `limit`-shaped query (a correlated `EXISTS`, a
+ * semi-join probe) shows up in a profile as row-decode or allocation cost: the fix is a
+ * SMALLER FIRST batch that ramps toward this bound, which keeps a drain's round-trip
+ * count within a log factor while making a stopped scan cost ~one row again.
+ */
+export declare const ROW_RESOLUTION_BATCH = 256;
 /**
  * Read-path layer of the generic KVStore-backed virtual table.
  *
@@ -131,26 +155,61 @@ export declare abstract class StoreTableScan extends StoreTableBase {
      * Analyze filter info to determine a secondary-index access pattern, mirroring
      * {@link analyzePKAccess} but over the index chosen in `idxStr`.
      *
-     * A contiguous leading-prefix EQ on the index columns yields a `point` window
-     * (the prefix covers every entry sharing those leading values — an index seek
-     * is a PREFIX scan, not a single row, since the index need not be unique and
-     * the PK suffix varies); otherwise a range (LT/LE/GT/GE) on the LEADING index
-     * column yields a `range` window. Returns null when neither applies or when the
-     * index is unresolved. {@link matchesFilters} stays the authoritative row filter,
-     * so the window need only be a SUPERSET.
+     * Three window shapes, in the order they are tried:
+     *
+     *  - a contiguous leading-prefix EQ plus a LT/LE/GT/GE bound on the NEXT index column
+     *    (the `prefixRangeSeek` / `plan=7` plan) — one `range` window covering just the
+     *    bounded slice INSIDE the prefix;
+     *  - a contiguous leading-prefix EQ alone → a `point` window (the prefix covers every
+     *    entry sharing those leading values — an index seek is a PREFIX scan, not a single
+     *    row, since the index need not be unique and the PK suffix varies);
+     *  - otherwise a range (LT/LE/GT/GE) on the LEADING index column → a `range` window.
+     *
+     * Returns null when none applies or when the index is unresolved.
+     * {@link matchesFilters} stays the authoritative row filter, so the window need only be
+     * a SUPERSET — which is why every degraded path below WIDENS (a prefix-range that
+     * cannot narrow falls back to the prefix window, a prefix that cannot encode a member
+     * stops short) rather than declining outright.
      *
      * Index-column bytes are encoded under each column's own key collation
      * ({@link indexKeyCollations}); {@link matchesFilters} re-checks a fetched row under the
      * index column's `COLLATE` else the table column's declared collation. The EQ/prefix
      * window is EXACTLY the qualifying set when those two agree, which
-     * {@link indexPrefixSeekIsCollationExact} decides; the RANGE window additionally equates
-     * memcmp of the key bytes with the residual's comparison ORDER, which
-     * {@link indexRangeIsOrderSafe} decides. `tryIndexAccessPlan`
-     * (store-module-access-plan.ts) consults the SAME two predicates before claiming the
-     * filters handled, so the two decisions cannot disagree. Either failing returns null and
-     * the caller full-scans, where the residual is authoritative.
+     * {@link indexPrefixSeekIsCollationExact} decides; a RANGE window additionally equates
+     * memcmp of the key bytes with the residual's comparison ORDER at the bounded column's
+     * position, which {@link indexRangeIsOrderSafe} decides. `tryIndexAccessPlan`
+     * (store-module-access-plan.ts) consults the SAME two predicates, at the same positions,
+     * before claiming the filters handled, so the two decisions cannot disagree. An EQ-prefix
+     * failure returns null and the caller full-scans, where the residual is authoritative.
      */
     protected analyzeIndexAccess(filterInfo: FilterInfo): IndexAccessPattern | null;
+    /**
+     * The prefix length a `prefixRangeSeek` (`plan=7`) FilterInfo declares, or null when
+     * this FilterInfo is not one.
+     *
+     * Honoring the plan's own `prefixLen` — rather than re-deriving it from the constraint
+     * list — is what makes a plan/scan disagreement LOUD: a value outside `1 …
+     * index.columns.length - 1` cannot describe a window over this index, and the plan
+     * already dropped the residual for the filters it claimed, so guessing a length would
+     * silently address the wrong columns.
+     */
+    private prefixRangeSeekLength;
+    /** The pushed LT/LE/GT/GE constraints on `columnIndex`, paired with their bound values. */
+    private rangeConstraintsOn;
+    /**
+     * The narrowed window for a prefix-equality + trailing-range seek: the equality prefix
+     * bytes, further bounded by the LT/LE/GT/GE constraints on the index column right after
+     * it. Null when the trailing bound cannot be used, in which case the caller falls back
+     * to the plain prefix window — a strict SUPERSET, so the answer is unchanged and only
+     * the narrowing is lost. Two reasons for that:
+     *
+     *  - the trailing column's key bytes do not reproduce its residual comparator's ORDER
+     *    ({@link indexRangeIsOrderSafe}) — `tryIndexAccessPlan` degrades to the plain prefix
+     *    seek through the same predicate, so this is the matching scan-side move rather than
+     *    a disagreement;
+     *  - no bound constraint survived on that column at all (nothing to narrow with).
+     */
+    private buildPrefixRangeWindow;
     /**
      * Lazy cache behind {@link indexKeyCollations}: one resolved array per index-schema
      * object, invalidated when the column array it was resolved against is replaced (an
@@ -209,23 +268,35 @@ export declare abstract class StoreTableScan extends StoreTableBase {
      */
     getIndexComparator(indexName: string): CompareFn[] | undefined;
     /**
-     * True when a byte window over the LEADING column of `index` reproduces the order the
-     * residual comparison uses. Delegates to {@link indexLeadingRangeIsOrderSafe} — the SAME
-     * call the range arm of `tryIndexAccessPlan` (store-module-access-plan.ts) makes before
-     * it marks the range filters handled, so the "build a window" and "mark handled"
-     * decisions cannot disagree. The memoized {@link indexKeyCollations} is passed as the
-     * key side, so the predicate judges the bytes this scan actually addresses.
+     * True when a byte window bounded on index column `position` reproduces the order the
+     * residual comparison uses there. Delegates to {@link indexRangeAtPositionIsOrderSafe} —
+     * the SAME call `tryIndexAccessPlan` (store-module-access-plan.ts) makes, at the same
+     * position, before it marks the range filters handled, so the "build a window" and "mark
+     * handled" decisions cannot disagree. The memoized {@link indexKeyCollations} is passed
+     * as the key side, so the predicate judges the bytes this scan actually addresses.
+     *
+     * `position` is 0 for a standalone leading-column range and the prefix length for a
+     * prefix-equality + trailing-range window.
      */
-    protected indexRangeIsOrderSafe(index: TableIndexSchema): boolean;
+    protected indexRangeIsOrderSafe(index: TableIndexSchema, position: number): boolean;
     /**
-     * Convert leading-index-column LT/LE/GT/GE constraints into one encoded-byte
-     * `gte`/`lt` window — the secondary-index analogue of {@link buildPKRangeBounds}.
+     * Convert LT/LE/GT/GE constraints on ONE index column into a single encoded-byte
+     * `gte`/`lt` window, optionally nested inside a fixed equality prefix — the
+     * secondary-index analogue of {@link buildPKRangeBounds}.
+     *
+     * The bounded column sits at position `prefixValues.length`; `directions`,
+     * `collations` and `transforms` are the index's own per-column arrays sliced to cover
+     * the prefix AND that column. An empty `prefixValues` is the standalone leading-column
+     * range; a non-empty one is the trailing bound of a `prefixRangeSeek`.
      *
-     * Each bound value is encoded under the leading index column's own key `collation`
-     * ({@link indexKeyCollations}) and DESC `dir` — exactly as {@link buildIndexKey}
-     * encodes that column — via {@link buildIndexPrefixBounds}, giving the byte region
-     * `[lo, hi)` whose leading column equals that value. The op maps that region's
-     * endpoints onto `gte`/`lt`, with the same DESC lower/upper SWAP as the PK path:
+     * Each bound value is encoded BEHIND the prefix, under the bounded column's own key
+     * collation ({@link indexKeyCollations}) and DESC direction — exactly as
+     * {@link buildIndexKey} encodes that column — via {@link buildIndexPrefixBounds},
+     * giving the byte region `[lo, hi)` whose prefix columns equal `prefixValues` and whose
+     * bounded column equals that value. The op maps that region's endpoints onto
+     * `gte`/`lt`, with the same DESC lower/upper SWAP as the PK path — driven by the BOUNDED
+     * column's direction alone, since a DESC prefix column merely inverts bytes *inside* a
+     * prefix that stays fixed:
      *
      *   | op | ASC      | DESC     |
      *   |----|----------|----------|
@@ -234,40 +305,94 @@ export declare abstract class StoreTableScan extends StoreTableBase {
      *   | LE | lt  = hi | gte = lo |
      *   | LT | lt  = lo | gte = hi |
      *
-     * Across constraints keep the MAX lower and MIN upper. An `undefined` upper (an
-     * `hi` whose increment overflowed all-0xff) leaves that side unbounded — a safe
-     * SUPERSET. A NULL/missing bound value is skipped (the planner never pushes
-     * `= NULL`, and a range op against NULL rejects every row in matchesFilters).
-     * A bound over a semantic-ordering leading column (`logicalType`) whose VALUE has
-     * no faithful byte position ({@link semanticProbeIsKeyFaithful}) is skipped the
-     * same way — a dropped RANGE bound only widens the window, and matchesFilters
-     * reproduces the predicate under the type's compare; see the widen-vs-decline
-     * note on {@link buildPKRangeBounds}. `transform` is the leading column's key
-     * value transform ({@link indexKeyTransforms}), so a surviving bound addresses
-     * the same transformed bytes the index store holds.
+     * Both sides START at the prefix's own window (`[P, incr(P))`, or unbounded for an
+     * empty prefix) and are then tightened: keep the MAX lower and MIN upper across
+     * constraints. So every degraded path lands back on the prefix window, never wider:
+     * an `undefined` upper (an `hi` whose increment overflowed all-0xff), a NULL/missing
+     * bound value (the planner never pushes `= NULL`, and a range op against NULL rejects
+     * every row in matchesFilters), and a bound over a semantic-ordering column
+     * (`logicalType`) whose VALUE has no faithful byte position
+     * ({@link semanticProbeIsKeyFaithful}) are all simply skipped — a dropped RANGE bound
+     * only widens the window, and matchesFilters reproduces the predicate under the type's
+     * compare; see the widen-vs-decline note on {@link buildPKRangeBounds}. `transforms`
+     * carry each column's key value transform ({@link indexKeyTransforms}), so a surviving
+     * bound addresses the same transformed bytes the index store holds.
      */
-    protected buildIndexRangeBounds(constraints: Array<{
+    protected buildIndexRangeBounds(prefixValues: readonly SqlValue[], constraints: Array<{
         op: IndexConstraintOp;
         value?: SqlValue;
-    }>, dir: boolean, collation: string | undefined, logicalType: LogicalType | undefined, transform: KeyValueTransform | undefined): IterateOptions;
+    }>, directions: ReadonlyArray<boolean>, collations: ReadonlyArray<string | undefined>, logicalType: LogicalType | undefined, transforms: ReadonlyArray<KeyValueTransform | undefined>): IterateOptions;
     /**
      * Scan a secondary index over `access.bounds`, resolving each index entry to its
      * base row and re-filtering.
      *
-     * {@link iterateEffective} yields the committed index entries merged with this
-     * transaction's pending index puts/deletes (read-your-own-writes over the
-     * index), in index-key byte order — the order the isolation overlay merge relies
-     * on (`isolated-table.ts` § buildSortKey). We resolve each entry to its row via
-     * its stored data-key value WITHOUT reordering, so index-key order is preserved.
-     *
-     * Defense in depth mirroring the memory layer's live-recheck: a resolved-null
-     * row (the entry's row was deleted — a pending index delete would normally
-     * suppress the entry, but a committed entry can lag) is skipped, and every
-     * resolved row is re-checked by {@link matchesFilters} (the byte window is only
-     * a superset, and a stale entry whose indexed column no longer matches is
-     * dropped).
+     * One window of the producer/consumer pair below: {@link produceIndexEntries}
+     * walks the window's index entries and {@link resolveIndexEntries} resolves them
+     * to rows in {@link ROW_RESOLUTION_BATCH}-bounded batches — one
+     * {@link StoreTableBase.readEffectiveRowsByKeys} round trip per batch instead of
+     * one awaited point read per entry. A multi-seek runs the SAME consumer over the
+     * concatenation of every window's producer instead of calling this method — see
+     * {@link scanMultiSeek}.
+     */
+    protected scanIndex(indexStore: KVStore, access: IndexAccessPattern, filterInfo: FilterInfo): AsyncIterable<Row>;
+    /**
+     * Producer half of the index-scan pair: walk one byte window's index entries —
+     * {@link iterateEffective} yields the committed entries merged with this
+     * transaction's pending index puts/deletes (read-your-own-writes over the index),
+     * in index-key byte order, the order the isolation overlay merge relies on
+     * (`isolated-table.ts` § buildSortKey) — and yield, per surviving entry, its data
+     * key plus the FilterInfos a resolved row may match. Entries stay in visit order
+     * end to end, so index-key order is preserved through the batching consumer.
+     *
+     * Only the defenses that need nothing but the entry itself run here, BEFORE the
+     * row read; everything row-dependent lives in {@link resolveRowBatch}.
      */
-    protected scanIndex(indexStore: KVStore, access: IndexAccessPattern, filterInfo: FilterInfo, multi?: MultiSeekWindowContext): AsyncIterable<Row>;
+    private produceIndexEntries;
+    /**
+     * Consumer half of the index-scan pair: collect up to {@link ROW_RESOLUTION_BATCH}
+     * produced entries and resolve each batch through {@link resolveRowBatch} — one
+     * store round trip per batch. Batching changes the round-trip count, never the row
+     * set or its order: batches are resolved and yielded in entry order.
+     *
+     * Early termination: a downstream `break` mid-batch finishes this generator, whose
+     * `for await` closes `entries` — and the iterate cursor under it — on the way out;
+     * no further batch is collected or read.
+     */
+    private resolveIndexEntries;
+    /**
+     * Resolve one bounded batch of index entries to rows — a single
+     * {@link StoreTableBase.readEffectiveRowsByKeys} call (which applies this
+     * transaction's pending deletes/puts BEFORE touching the committed store; the
+     * precedence is not re-implemented here) — then run the row-dependent defenses in
+     * entry order, mirroring the memory layer's live-recheck:
+     *
+     *  - a resolved-null row (the entry's row was deleted — a pending index delete
+     *    would normally suppress the entry, but a committed entry can lag) is skipped,
+     *    and cannot shift later positions (the read answers positionally);
+     *  - the multi-seek `seen` set is RE-checked after the read: the producer's
+     *    pre-check ran before this batch was collected, so two entries at one data key
+     *    inside a single batch (a stale index entry) are only caught here — without
+     *    the re-check the row would yield twice;
+     *  - a row is accepted when it matches ANY of the entry's FilterInfos (the byte
+     *    window is only a superset, and a stale entry whose indexed column no longer
+     *    matches is dropped), and `seen` is added to on yield ALONE — a stale entry
+     *    that fails its residual must not suppress the row's live entry later.
+     *
+     * NOTE: still one data-store point read per matched index entry — the row lives in
+     * the data store, not the index (the index value carries only the data key, no
+     * covering payload); batching collapses the reads' round trips, not their count.
+     * If index-covered scans ever dominate a profile, consider storing the serialized
+     * row as a covering index value, at the cost of an index rewrite on EVERY column
+     * change (not just indexed columns) — deliberately not done here.
+     */
+    private resolveRowBatch;
+    /**
+     * Fail loudly on a structurally impossible FilterInfo — one whose own idxStr describes
+     * an access this table's schema cannot express. Not a soundness fallback: everything
+     * that is merely UNSERVEABLE degrades to a wider window plus the {@link matchesFilters}
+     * residual instead of raising. `kind` names the plan shape for the message.
+     */
+    private malformedFilterInfo;
     /**
      * Fail loudly on a multi-seek FilterInfo this table cannot serve. The plan already
      * dropped the residual Filter, and {@link matchesFilters} ANDs every pushed
@@ -303,27 +428,43 @@ export declare abstract class StoreTableScan extends StoreTableBase {
      * away before scanning:
      *   - Tuples whose encoded prefix byte-matches (duplicate bound parameters, or
      *     case variants under a NOCASE key collation C) share ONE window, each kept
-     *     as a residual alternative — see {@link MultiSeekWindowContext}.
+     *     as a residual alternative — see {@link PendingIndexEntry}.
      *   - A window with no finite upper bound (all-0xff prefix — see
      *     buildIndexPrefixBounds) contains every later-sorting window outright (any
      *     key ≥ an all-0xff prefix necessarily starts with it), so those windows fold
      *     into it instead of re-scanning an overlapping range out of order.
      *
-     * Emission is lazy per window — `… in (…) limit 1` stops after the first yielded
-     * row without materializing the remaining windows. Each window goes through
-     * {@link scanIndex} → {@link iterateEffective}, so read-your-own-writes and the
-     * stale-entry / deleted-row defenses hold per seek key.
+     * Emission is lazy and batched ACROSS windows: every window's
+     * {@link produceIndexEntries} feeds ONE {@link resolveIndexEntries} consumer, whose
+     * batches are bounded by ENTRY count, not window count — so a hundred single-row
+     * windows collapse into a single row-resolution round trip, and
+     * `… in (…) limit 1` materializes at most one {@link ROW_RESOLUTION_BATCH} batch
+     * rather than every window. Each window's entries still come from
+     * {@link iterateEffective}, so read-your-own-writes and the stale-entry /
+     * deleted-row defenses hold per seek key.
      */
     protected scanMultiSeek(spec: IdxStrSpec, filterInfo: FilterInfo): AsyncIterable<Row>;
+    /**
+     * Concatenate the disjoint multi-seek windows' producers, in window (byte) order.
+     * Each entry carries its window's full FilterInfo list — the primary tuple plus
+     * the byte-equal merged alternatives — so acceptance stays per row, in order (see
+     * {@link PendingIndexEntry}).
+     */
+    private produceMultiSeekEntries;
     /**
      * Multi-seek over the PRIMARY key: each tuple is a full PK, resolved by a point
      * read in ascending encoded-data-key order (the table's native emission order).
      *
-     * NOT reachable from this module's own plans today: `computeBestAccessPlan` (store-module-access-plan.ts)
-     * claims IN-list filters only for secondary indexes (see its EQ_OPS vs EQ_OR_IN_OPS
-     * split and tickets/backlog/feat-store-pk-in-list-multiseek). The branch exists so
-     * a `_primary_` multi-seek arriving from a future plan gets a correct answer rather
-     * than the scan arm's silent zero rows, and it is what PK-IN enablement will build on.
+     * Reached from `computeBestAccessPlan`'s primary-key multi-seek arm
+     * (store-module-access-plan.ts), which claims a whole-primary-key `IN` — literal list
+     * or runtime-valued set — through `EQ_OR_IN_OPS` and advertises `_primary_` with every
+     * PK column as its seek columns. That arm declines exactly the two shapes the
+     * {@link multiSeekMalformed} throws below assert against (over the seek cap, and a
+     * semantic-ordering PK member), so a throw here means the plan and the scan disagreed.
+     *
+     * The ascending-encoded-key emission order is a contract, not an implementation
+     * detail: the isolation layer merges this stream with its overlay by primary key
+     * (`bug-isolation-multiseek-merge-order`), and the arm advertises PK ordering off it.
      */
     protected scanMultiSeekPrimary(tuples: MultiSeekTuple[], seekWidth: number, filterInfo: FilterInfo): AsyncIterable<Row>;
     /**
@@ -397,9 +538,10 @@ interface PKAccessPattern {
 /**
  * Secondary-index access pattern analysis result: the chosen index plus the
  * encoded byte window {@link StoreTableScan.scanIndex} iterates. `point` is a
- * leading-prefix EQ window, `range` a leading-column LT/LE/GT/GE window; both
- * resolve to a `bounds` scan (an index seek is always a prefix scan, never a
- * single entry).
+ * leading-prefix EQ window; `range` is an LT/LE/GT/GE window, either on the leading
+ * column or nested inside an equality prefix (`prefixRangeSeek`). Both resolve to a
+ * `bounds` scan (an index seek is always a prefix scan, never a single entry) — nothing
+ * downstream branches on the tag, which is descriptive only.
  */
 interface IndexAccessPattern {
     index: TableIndexSchema;
@@ -416,37 +558,5 @@ interface MultiSeekTuple {
     entries: ConstraintEntry[];
     values: SqlValue[];
 }
-/**
- * Per-window context a multi-seek passes to {@link StoreTableScan.scanIndex} (absent for
- * ordinary single-window scans).
- *
- * `seen` — data-key hexes already YIELDED by an earlier window. Checked before the
- * data-store read (a cross-window duplicate costs no extra `get`), added only on a
- * yield: adding at visit time would let a stale index entry (row re-keyed since
- * indexing) that FAILS its residual poison the set and suppress the row's live entry
- * in a later window.
- * NOTE: holds one hex string per row the multi-seek yields, for the whole seek — the
- * only unbounded allocation on this path. Windows are byte-disjoint, so the only real
- * duplicate source is a stale index entry; if a large-result `IN` ever shows up as a
- * memory problem, the set can be scoped per window (or dropped for a consistent store).
- *
- * `collations` — the constraint collation map, resolved once per multi-seek (it is
- * identical for every window).
- *
- * `extraTuples` — additional seek tuples whose encoded window byte-equals this
- * window's (duplicate bound parameters, or case-variant values under a NOCASE key
- * collation). A row is yielded when it matches the primary FilterInfo OR any of
- * these. Index bytes now encode under the same collation C the residual compares
- * under (`indexKeyCollations`), so byte-equal tuples are C-equal and each merged
- * tuple's residual admits the same rows — the OR is redundancy, kept because it is
- * what makes the fold safe by construction rather than by that argument, and it is
- * what a custom equality-only normalizer (byte-equal ⇏ comparator-equal order but
- * equal partition) still relies on.
- */
-interface MultiSeekWindowContext {
-    seen: Set<string>;
-    collations: ReadonlyMap<number, CollationFunction>;
-    extraTuples: readonly FilterInfo[];
-}
 export {};
 //# sourceMappingURL=store-table-scan.d.ts.map

package/dist/src/common/store-table-scan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-table-scan.d.ts","sourceRoot":"","sources":["../../../src/common/store-table-scan.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"store-table-scan.d.ts","sourceRoot":"","sources":["../../../src/common/store-table-scan.ts"],"names":[],"mappings":"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"}