@quereus/quereus 2.8.0 → 3.0.0

package/dist/src/planner/rules/access/rule-asof-strategy-select.js

@@ -0,0 +1,112 @@
+/**
+ * Rule: AsofScan strategy selection (hash → merge).
+ *
+ * Promotes an `AsofScanNode` from the default `'hash'` strategy to the
+ * co-streaming `'merge'` strategy when:
+ *
+ *   - Both children advertise `physical.ordering` whose leading
+ *     `partitionAttrs.length + 1` entries form `[partition cols..., matchAttr]`.
+ *   - At each partition position, left and right's attribute IDs pair up via
+ *     a `partitionAttrs` equi-pair, in the same direction on both sides.
+ *   - The trailing match-attr ordering on each side is ASC. The merge emitter
+ *     walks both inputs forward — `direction='desc'` (latest right ≤ left)
+ *     accumulates the largest qualifier seen; `direction='asc'` (earliest
+ *     right ≥ left) returns the first qualifier. Both forms assume ASC sort
+ *     on the matchAttr; that aligns with how access-path `monotonicOn` is
+ *     advertised today (always ascending).
+ *   - The right's estimated row count meets the configured
+ *     `tuning.asof.mergeRowThreshold` — below it, hash's constant factors win.
+ *
+ * Bails to `null` (leaving the hash strategy) on any failure.
+ *
+ * The merge strategy streams memory O(1) and emits as left rows arrive,
+ * unlike the hash variant's O(R) buffering and full-right-arrival latency.
+ * Cost is O(L + R) for both — only constant factors differ — so this is a
+ * predicate-driven rewrite rather than enumerate-and-cost.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { AsofScanNode } from '../../nodes/asof-scan-node.js';
+const log = createLogger('optimizer:rule:asof-strategy-select');
+/**
+ * Translate the leading `prefixLen` ordering entries on a child to
+ * (attrId, desc) pairs. Returns null when the ordering is shorter than
+ * required or contains entries that do not map to a known attribute.
+ */
+function mapLeadingOrdering(ordering, attrs, prefixLen) {
+    if (!ordering || ordering.length < prefixLen)
+        return null;
+    const out = [];
+    for (let i = 0; i < prefixLen; i++) {
+        const entry = ordering[i];
+        const attr = attrs[entry.column];
+        if (!attr)
+            return null;
+        out.push({ attrId: attr.id, desc: entry.desc });
+    }
+    return out;
+}
+export function ruleAsofStrategySelect(node, ctx) {
+    if (!(node instanceof AsofScanNode))
+        return null;
+    if (node.strategy !== 'hash')
+        return null;
+    const partitionLen = node.partitionAttrs.length;
+    const prefixLen = partitionLen + 1;
+    const leftAttrs = node.left.getAttributes();
+    const rightAttrs = node.right.getAttributes();
+    const leftOrdering = mapLeadingOrdering(node.left.physical.ordering, leftAttrs, prefixLen);
+    if (!leftOrdering) {
+        log('Left does not provide a long enough ordering prefix (need %d)', prefixLen);
+        return null;
+    }
+    const rightOrdering = mapLeadingOrdering(node.right.physical.ordering, rightAttrs, prefixLen);
+    if (!rightOrdering) {
+        log('Right does not provide a long enough ordering prefix (need %d)', prefixLen);
+        return null;
+    }
+    // Partition prefix: at each ordering position, left's attr-id must be the
+    // `leftAttrId` of one of the partition pairs; the same position on the
+    // right must carry the corresponding `rightAttrId`. Directions must match.
+    const remainingPairs = node.partitionAttrs.slice();
+    for (let i = 0; i < partitionLen; i++) {
+        const leftEntry = leftOrdering[i];
+        const rightEntry = rightOrdering[i];
+        if (leftEntry.desc !== rightEntry.desc) {
+            log('Direction mismatch at partition position %d (left=%s, right=%s)', i, leftEntry.desc ? 'desc' : 'asc', rightEntry.desc ? 'desc' : 'asc');
+            return null;
+        }
+        const pairIdx = remainingPairs.findIndex(p => p.leftAttrId === leftEntry.attrId && p.rightAttrId === rightEntry.attrId);
+        if (pairIdx < 0) {
+            log('Position %d (left=%d, right=%d) does not pair via partitionAttrs', i, leftEntry.attrId, rightEntry.attrId);
+            return null;
+        }
+        remainingPairs.splice(pairIdx, 1);
+    }
+    // Trailing entry on each side must be the asof match attribute, ASC.
+    // The merge emitter walks both inputs forward; that requires ascending
+    // match-attr ordering on both sides regardless of the asof direction.
+    const tailLeft = leftOrdering[partitionLen];
+    const tailRight = rightOrdering[partitionLen];
+    if (tailLeft.attrId !== node.matchAttr.leftAttrId) {
+        log('Left ordering tail (attr=%d) is not the match attr (attr=%d)', tailLeft.attrId, node.matchAttr.leftAttrId);
+        return null;
+    }
+    if (tailRight.attrId !== node.matchAttr.rightAttrId) {
+        log('Right ordering tail (attr=%d) is not the match attr (attr=%d)', tailRight.attrId, node.matchAttr.rightAttrId);
+        return null;
+    }
+    if (tailLeft.desc || tailRight.desc) {
+        log('Match-attr ordering must be ASC on both sides (left=%s, right=%s)', tailLeft.desc ? 'desc' : 'asc', tailRight.desc ? 'desc' : 'asc');
+        return null;
+    }
+    // Threshold gate.
+    const tuning = ctx.tuning;
+    const rightRows = node.right.estimatedRows ?? tuning.defaultRowEstimate;
+    if (rightRows < tuning.asof.mergeRowThreshold) {
+        log('Right estimated rows (%d) below merge threshold (%d); keeping hash', rightRows, tuning.asof.mergeRowThreshold);
+        return null;
+    }
+    log('Promoting AsofScan to merge strategy (rightRows=%d, partitionCols=%d)', rightRows, partitionLen);
+    return node.withStrategy('merge');
+}
+//# sourceMappingURL=rule-asof-strategy-select.js.map

package/dist/src/planner/rules/access/rule-asof-strategy-select.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-asof-strategy-select.js","sourceRoot":"","sources":["../../../../../src/planner/rules/access/rule-asof-strategy-select.ts"],"names":[],"mappings":"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"}

package/dist/src/planner/rules/access/rule-monotonic-limit-pushdown.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Rule: Monotonic LIMIT/OFFSET pushdown
+ *
+ * Pattern (the rule peels through these in order, top-down from the
+ * LimitOffsetNode toward the leaf):
+ *
+ *   LimitOffsetNode
+ *     └─ SortNode?           (single trivial column ref matching leaf monotonicOn)
+ *           └─ (ProjectNode | AliasNode)*   (only trivial column-reference projections)
+ *                 └─ IndexScan / IndexSeek / SeqScan
+ *                       (advertises monotonicOn AND accessCapabilities.ordinalSeek)
+ *
+ * On a successful match, the entire `LimitOffset[/Sort]/.../leaf` subtree is
+ * replaced with `…/OrdinalSlice(leaf)` — the OrdinalSlice slots in directly
+ * above the leaf, threading the resolved offset/limit into the leaf's
+ * FilterInfo so the vtab can seek directly to the kth row in O(log N)
+ * instead of buffering k+n rows.
+ *
+ * Trivial Project nodes (all projections are bare ColumnReferenceNodes) and
+ * Alias wrappers preserve row count and order, so we can descend through
+ * them — the OrdinalSlice still slices the leaf in monotonic order.
+ *
+ * The rule rejects all of:
+ *   - `Sort` whose key isn't a single trivial column ref into the leaf
+ *   - `Sort` direction mismatching the advertised `monotonicOn.direction`
+ *   - any non-trivial intermediate node (Filter, Distinct, Aggregate, etc.)
+ *   - leaf advertising `monotonicOn` but not `ordinalSeek`
+ *   - multi-key `ORDER BY`
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleMonotonicLimitPushdown(node: PlanNode, _context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-monotonic-limit-pushdown.d.ts.map

package/dist/src/planner/rules/access/rule-monotonic-limit-pushdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-monotonic-limit-pushdown.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/access/rule-monotonic-limit-pushdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAsB,MAAM,0BAA0B,CAAC;AAE7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AA+F7D,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA0EhG"}

package/dist/src/planner/rules/access/rule-monotonic-limit-pushdown.js

@@ -0,0 +1,162 @@
+/**
+ * Rule: Monotonic LIMIT/OFFSET pushdown
+ *
+ * Pattern (the rule peels through these in order, top-down from the
+ * LimitOffsetNode toward the leaf):
+ *
+ *   LimitOffsetNode
+ *     └─ SortNode?           (single trivial column ref matching leaf monotonicOn)
+ *           └─ (ProjectNode | AliasNode)*   (only trivial column-reference projections)
+ *                 └─ IndexScan / IndexSeek / SeqScan
+ *                       (advertises monotonicOn AND accessCapabilities.ordinalSeek)
+ *
+ * On a successful match, the entire `LimitOffset[/Sort]/.../leaf` subtree is
+ * replaced with `…/OrdinalSlice(leaf)` — the OrdinalSlice slots in directly
+ * above the leaf, threading the resolved offset/limit into the leaf's
+ * FilterInfo so the vtab can seek directly to the kth row in O(log N)
+ * instead of buffering k+n rows.
+ *
+ * Trivial Project nodes (all projections are bare ColumnReferenceNodes) and
+ * Alias wrappers preserve row count and order, so we can descend through
+ * them — the OrdinalSlice still slices the leaf in monotonic order.
+ *
+ * The rule rejects all of:
+ *   - `Sort` whose key isn't a single trivial column ref into the leaf
+ *   - `Sort` direction mismatching the advertised `monotonicOn.direction`
+ *   - any non-trivial intermediate node (Filter, Distinct, Aggregate, etc.)
+ *   - leaf advertising `monotonicOn` but not `ordinalSeek`
+ *   - multi-key `ORDER BY`
+ */
+import { createLogger } from '../../../common/logger.js';
+import { isRelationalNode } from '../../nodes/plan-node.js';
+import { LimitOffsetNode } from '../../nodes/limit-offset.js';
+import { SortNode } from '../../nodes/sort.js';
+import { AliasNode } from '../../nodes/alias-node.js';
+import { ProjectNode } from '../../nodes/project-node.js';
+import { SeqScanNode, IndexScanNode, IndexSeekNode } from '../../nodes/table-access-nodes.js';
+import { ColumnReferenceNode } from '../../nodes/reference.js';
+import { OrdinalSliceNode } from '../../nodes/ordinal-slice-node.js';
+const log = createLogger('optimizer:rule:monotonic-limit-pushdown');
+function isAccessLeaf(node) {
+    return node instanceof SeqScanNode || node instanceof IndexScanNode || node instanceof IndexSeekNode;
+}
+/**
+ * A Project is "trivial" iff every projection is a bare ColumnReferenceNode.
+ * Trivial projects preserve row count, order, and per-row identity, so an
+ * OrdinalSlice underneath them still computes the right slice indices.
+ *
+ * Computed/expression projections might mutate cardinality (impossible for
+ * pure scalars, but the conservative check keeps the rule simple) or change
+ * the meaning of "kth row" if combined with subqueries; we exclude them.
+ */
+function isTrivialProject(project) {
+    return project.projections.every(p => p.node instanceof ColumnReferenceNode);
+}
+/**
+ * Walk down from `chainRoot` toward the access leaf, descending only through
+ * trivial Project / Alias wrappers. Returns null if we hit a non-trivial node
+ * before reaching the leaf.
+ */
+function peelToLeaf(chainRoot) {
+    let cursor = chainRoot;
+    let sort;
+    if (cursor instanceof SortNode) {
+        sort = cursor;
+        cursor = cursor.source;
+    }
+    let safety = 16;
+    while (safety-- > 0) {
+        if (isAccessLeaf(cursor)) {
+            return { leaf: cursor, chainRoot, sort };
+        }
+        if (cursor instanceof AliasNode) {
+            cursor = cursor.source;
+            continue;
+        }
+        if (cursor instanceof ProjectNode && isTrivialProject(cursor)) {
+            cursor = cursor.source;
+            continue;
+        }
+        return null;
+    }
+    return null;
+}
+/**
+ * Rebuild the chain `chainRoot → … → oldLeaf` with `oldLeaf` replaced by
+ * `newLeaf`. Each intermediate node is reconstructed via `withChildren`,
+ * preserving its other children (scalar inputs to Project / Sort).
+ */
+function rebuildChain(chainRoot, oldLeaf, newLeaf) {
+    if (chainRoot === oldLeaf) {
+        return newLeaf;
+    }
+    const originalChildren = chainRoot.getChildren();
+    const newChildren = originalChildren.map(child => {
+        if (isRelationalNode(child)) {
+            return rebuildChain(child, oldLeaf, newLeaf);
+        }
+        return child;
+    });
+    return chainRoot.withChildren(newChildren);
+}
+export function ruleMonotonicLimitPushdown(node, _context) {
+    if (!(node instanceof LimitOffsetNode))
+        return null;
+    // Degenerate LimitOffset (no bounds) — nothing to push down.
+    if (!node.limit && !node.offset)
+        return null;
+    const peeled = peelToLeaf(node.source);
+    if (!peeled) {
+        log('Could not peel down to a physical access leaf from %s', node.source.nodeType);
+        return null;
+    }
+    const physical = peeled.leaf.physical;
+    if (!physical.accessCapabilities?.ordinalSeek) {
+        log('Leaf does not advertise ordinalSeek; skipping');
+        return null;
+    }
+    const monotonicOn = physical.monotonicOn;
+    if (!monotonicOn || monotonicOn.length === 0) {
+        log('Leaf advertises ordinalSeek but no monotonicOn; skipping');
+        return null;
+    }
+    const leafMonotonic = monotonicOn[0];
+    // If a Sort is present, it must be a single trivial column ref whose
+    // attribute id and direction match the leaf's monotonicOn[0].
+    if (peeled.sort) {
+        if (peeled.sort.sortKeys.length !== 1) {
+            log('Sort has %d keys; multi-key ORDER BY not supported', peeled.sort.sortKeys.length);
+            return null;
+        }
+        const key = peeled.sort.sortKeys[0];
+        if (!(key.expression instanceof ColumnReferenceNode)) {
+            log('Sort key is not a trivial column reference');
+            return null;
+        }
+        if (key.expression.attributeId !== leafMonotonic.attrId) {
+            log('Sort key attr=%d does not match leaf monotonicOn attr=%d', key.expression.attributeId, leafMonotonic.attrId);
+            return null;
+        }
+        if (key.direction !== leafMonotonic.direction) {
+            log('Sort direction %s does not match leaf monotonicOn direction %s', key.direction, leafMonotonic.direction);
+            return null;
+        }
+    }
+    // Build OrdinalSlice over the leaf, then re-stitch the chain above it.
+    const slice = new OrdinalSliceNode(node.scope, peeled.leaf, leafMonotonic.attrId, node.offset, node.limit, leafMonotonic.direction);
+    // `chainRoot` is the original LimitOffset.source — could be Sort, Project,
+    // Alias, or the leaf itself. We replace the leaf in that chain with the
+    // slice and drop the Sort if present (the slice preserves emit order).
+    let rewrittenSource;
+    if (peeled.sort) {
+        // Drop the Sort entirely: the slice's source already emits in the
+        // requested order, so re-sorting would be wasteful.
+        rewrittenSource = rebuildChain(peeled.sort.source, peeled.leaf, slice);
+    }
+    else {
+        rewrittenSource = rebuildChain(peeled.chainRoot, peeled.leaf, slice);
+    }
+    log('Replaced LimitOffset[/Sort]/leaf with OrdinalSlice (attr=%d, %s)', leafMonotonic.attrId, leafMonotonic.direction);
+    return rewrittenSource;
+}
+//# sourceMappingURL=rule-monotonic-limit-pushdown.js.map

package/dist/src/planner/rules/access/rule-monotonic-limit-pushdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-monotonic-limit-pushdown.js","sourceRoot":"","sources":["../../../../../src/planner/rules/access/rule-monotonic-limit-pushdown.ts"],"names":[],"mappings":"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"}

package/dist/src/planner/rules/access/rule-monotonic-range-access.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Rule: Monotonic range scan recognition
+ *
+ * Two responsibilities, gated by node type:
+ *
+ * 1. **Annotation (leaf nodes — IndexScan / IndexSeek / SeqScan)**:
+ *    When the leaf advertises `monotonicOn(x)` and its `FilterInfo.constraints`
+ *    carries a handled range/equality on `x`, set `physical.rangeBoundedOn` so
+ *    EXPLAIN and downstream rules can read off the symbolic bound. This is a
+ *    pure annotation — it does not change the row stream.
+ *
+ * 2. **Defensive `monotonicOn` drop (Filter directly above a leaf)**:
+ *    If a `FilterNode` sits directly above a leaf that advertises
+ *    `monotonicOn(x)` and the filter's predicate contains a range or equality
+ *    on `x` (i.e., the vtab declined to handle the bound), the row stream
+ *    emerging from the *Filter* is no longer monotonic over the WHERE-restricted
+ *    set. Drop `monotonicOn` (and the implied `accessCapabilities`) from the
+ *    leaf so downstream rules (asof, merge-join) don't make false assumptions.
+ *
+ * The rule runs in the PostOptimization pass so it sees physical leaves with
+ * lifted advertisements + resolved FilterInfo. The annotation reads off the
+ * leaf's own `FilterInfo.constraints` (the canonical record of which bounds
+ * the access path is walking with). The defensive escalation reads the parent
+ * Filter's predicate.
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleMonotonicRangeAccess(node: PlanNode, _ctx: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-monotonic-range-access.d.ts.map

package/dist/src/planner/rules/access/rule-monotonic-range-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-monotonic-range-access.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/access/rule-monotonic-range-access.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAuN7D,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAQ1F"}

package/dist/src/planner/rules/access/rule-monotonic-range-access.js

@@ -0,0 +1,175 @@
+/**
+ * Rule: Monotonic range scan recognition
+ *
+ * Two responsibilities, gated by node type:
+ *
+ * 1. **Annotation (leaf nodes — IndexScan / IndexSeek / SeqScan)**:
+ *    When the leaf advertises `monotonicOn(x)` and its `FilterInfo.constraints`
+ *    carries a handled range/equality on `x`, set `physical.rangeBoundedOn` so
+ *    EXPLAIN and downstream rules can read off the symbolic bound. This is a
+ *    pure annotation — it does not change the row stream.
+ *
+ * 2. **Defensive `monotonicOn` drop (Filter directly above a leaf)**:
+ *    If a `FilterNode` sits directly above a leaf that advertises
+ *    `monotonicOn(x)` and the filter's predicate contains a range or equality
+ *    on `x` (i.e., the vtab declined to handle the bound), the row stream
+ *    emerging from the *Filter* is no longer monotonic over the WHERE-restricted
+ *    set. Drop `monotonicOn` (and the implied `accessCapabilities`) from the
+ *    leaf so downstream rules (asof, merge-join) don't make false assumptions.
+ *
+ * The rule runs in the PostOptimization pass so it sees physical leaves with
+ * lifted advertisements + resolved FilterInfo. The annotation reads off the
+ * leaf's own `FilterInfo.constraints` (the canonical record of which bounds
+ * the access path is walking with). The defensive escalation reads the parent
+ * Filter's predicate.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { IndexConstraintOp } from '../../../common/constants.js';
+import { SeqScanNode, IndexScanNode, IndexSeekNode } from '../../nodes/table-access-nodes.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { LiteralNode } from '../../nodes/scalar.js';
+import { extractConstraints, createTableInfoFromNode } from '../../analysis/constraint-extractor.js';
+const log = createLogger('optimizer:rule:monotonic-range-access');
+function isAccessLeaf(node) {
+    return node instanceof SeqScanNode || node instanceof IndexScanNode || node instanceof IndexSeekNode;
+}
+const GE_OR_GT = new Set([IndexConstraintOp.GE, IndexConstraintOp.GT]);
+const LE_OR_LT = new Set([IndexConstraintOp.LE, IndexConstraintOp.LT]);
+/**
+ * Walk the leaf's `FilterInfo.constraints` looking for handled bounds on the
+ * given column index. Returns the synthesized RangeBounds (literals included
+ * when the corresponding seek key is a LiteralNode); returns null when no
+ * range/equality bound exists.
+ */
+function extractRangeBounds(filterInfo, seekKeys, colIdx) {
+    const out = {};
+    let any = false;
+    for (const entry of filterInfo.constraints) {
+        const c = entry.constraint;
+        if (c.iColumn !== colIdx)
+            continue;
+        // argvIndex is 1-based into seekKeys (when seekKeys is the IndexSeekNode's seekKeys array).
+        const seekKey = seekKeys && entry.argvIndex >= 1 && entry.argvIndex <= seekKeys.length
+            ? seekKeys[entry.argvIndex - 1]
+            : undefined;
+        const valueLiteral = seekKey instanceof LiteralNode ? seekKey.expression.value : undefined;
+        if (GE_OR_GT.has(c.op)) {
+            const op = c.op === IndexConstraintOp.GE ? '>=' : '>';
+            out.lower = valueLiteral !== undefined ? { op, valueLiteral } : { op };
+            any = true;
+        }
+        else if (LE_OR_LT.has(c.op)) {
+            const op = c.op === IndexConstraintOp.LE ? '<=' : '<';
+            out.upper = valueLiteral !== undefined ? { op, valueLiteral } : { op };
+            any = true;
+        }
+        else if (c.op === IndexConstraintOp.EQ) {
+            // Equality is a degenerate range [v, v]. Lift to both bounds.
+            const lo = valueLiteral !== undefined ? { op: '>=', valueLiteral } : { op: '>=' };
+            const hi = valueLiteral !== undefined ? { op: '<=', valueLiteral } : { op: '<=' };
+            out.lower = lo;
+            out.upper = hi;
+            any = true;
+        }
+    }
+    return any ? out : null;
+}
+function findColIndexForAttr(leaf, attrId) {
+    const attrs = leaf.source.getAttributes();
+    for (let i = 0; i < attrs.length; i++) {
+        if (attrs[i].id === attrId)
+            return i;
+    }
+    return -1;
+}
+/** Clone a leaf, attaching `rangeBoundedOn` to its physical properties. */
+function leafWithRangeBound(leaf, rb) {
+    if (leaf instanceof SeqScanNode) {
+        return new SeqScanNode(leaf.scope, leaf.source, leaf.filterInfo, undefined, rb, leaf.suppressMonotonic);
+    }
+    if (leaf instanceof IndexScanNode) {
+        return new IndexScanNode(leaf.scope, leaf.source, leaf.filterInfo, leaf.indexName, leaf.providesOrdering, undefined, leaf.advertisement, rb, leaf.suppressMonotonic);
+    }
+    // IndexSeekNode
+    return new IndexSeekNode(leaf.scope, leaf.source, leaf.filterInfo, leaf.indexName, leaf.seekKeys, leaf.isRange, leaf.providesOrdering, undefined, leaf.advertisement, rb, leaf.suppressMonotonic);
+}
+/** Clone a leaf, suppressing the lifted `monotonicOn` advertisement. */
+function leafWithMonotonicSuppressed(leaf) {
+    if (leaf instanceof SeqScanNode) {
+        return new SeqScanNode(leaf.scope, leaf.source, leaf.filterInfo, undefined, leaf.rangeBoundedOn, true);
+    }
+    if (leaf instanceof IndexScanNode) {
+        return new IndexScanNode(leaf.scope, leaf.source, leaf.filterInfo, leaf.indexName, leaf.providesOrdering, undefined, leaf.advertisement, leaf.rangeBoundedOn, true);
+    }
+    return new IndexSeekNode(leaf.scope, leaf.source, leaf.filterInfo, leaf.indexName, leaf.seekKeys, leaf.isRange, leaf.providesOrdering, undefined, leaf.advertisement, leaf.rangeBoundedOn, true);
+}
+/**
+ * Annotation pass for a physical access leaf. Sets `rangeBoundedOn` when the
+ * leaf advertises `monotonicOn(x)` AND its FilterInfo carries a handled
+ * range/equality on `x`. No-op otherwise.
+ */
+function applyAnnotation(leaf) {
+    // Don't re-annotate if we've already set rangeBoundedOn.
+    if (leaf.rangeBoundedOn)
+        return null;
+    const monotonicOn = leaf.physical.monotonicOn;
+    if (!monotonicOn || monotonicOn.length === 0)
+        return null;
+    const attrId = monotonicOn[0].attrId;
+    const colIdx = findColIndexForAttr(leaf, attrId);
+    if (colIdx < 0)
+        return null;
+    const seekKeys = leaf instanceof IndexSeekNode ? leaf.seekKeys : undefined;
+    const bounds = extractRangeBounds(leaf.filterInfo, seekKeys, colIdx);
+    if (!bounds)
+        return null;
+    const rb = {
+        attrId,
+        ...(bounds.lower ? { lower: bounds.lower } : {}),
+        ...(bounds.upper ? { upper: bounds.upper } : {}),
+    };
+    log('Annotating %s with rangeBoundedOn (attrId=%d)', leaf.nodeType, attrId);
+    return leafWithRangeBound(leaf, rb);
+}
+/**
+ * Defensive escalation: when a Filter sits directly above a leaf that
+ * advertises monotonicOn(x), and the Filter's predicate contains a range or
+ * equality on x, drop monotonicOn from the leaf — the row stream emerging
+ * from the Filter is not monotonic over the WHERE-restricted tuple set.
+ */
+function applyDefensiveDrop(filter) {
+    if (!isAccessLeaf(filter.source))
+        return null;
+    const leaf = filter.source;
+    const monotonicOn = leaf.physical.monotonicOn;
+    if (!monotonicOn || monotonicOn.length === 0)
+        return null;
+    if (leaf.suppressMonotonic)
+        return null;
+    const attrId = monotonicOn[0].attrId;
+    const colIdx = findColIndexForAttr(leaf, attrId);
+    if (colIdx < 0)
+        return null;
+    // Walk the Filter predicate to see if it carries a range/equality on the
+    // monotonic column. We use the constraint extractor to canonicalize the
+    // predicate, then look for a constraint on the matching attribute id.
+    const tableInfo = createTableInfoFromNode(leaf.source);
+    const result = extractConstraints(filter.predicate, [tableInfo]);
+    const offending = result.allConstraints.some(c => c.attributeId === attrId &&
+        (c.op === '=' || c.op === '>' || c.op === '>=' || c.op === '<' || c.op === '<='));
+    if (!offending)
+        return null;
+    log('Filter directly above leaf carries unhandled range on monotonic attr %d; suppressing monotonicOn', attrId);
+    const newLeaf = leafWithMonotonicSuppressed(leaf);
+    return filter.withChildren([newLeaf, filter.predicate]);
+}
+export function ruleMonotonicRangeAccess(node, _ctx) {
+    if (node instanceof FilterNode) {
+        return applyDefensiveDrop(node);
+    }
+    if (isAccessLeaf(node)) {
+        return applyAnnotation(node);
+    }
+    return null;
+}
+//# sourceMappingURL=rule-monotonic-range-access.js.map

package/dist/src/planner/rules/access/rule-monotonic-range-access.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-monotonic-range-access.js","sourceRoot":"","sources":["../../../../../src/planner/rules/access/rule-monotonic-range-access.ts"],"names":[],"mappings":"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"}

package/dist/src/planner/rules/access/rule-select-access-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-select-access-path.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/access/rule-select-access-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,0BAA0B,CAAC;AAEzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAmB7D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA0DzF"}
+{"version":3,"file":"rule-select-access-path.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/access/rule-select-access-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,0BAA0B,CAAC;AAEzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAoC7D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA0EzF"}