@quereus/quereus 2.9.0 → 3.0.0

package/dist/src/planner/rules/aggregate/rule-groupby-fd-simplification.js

@@ -0,0 +1,116 @@
+/**
+ * Rule: GROUP BY FD simplification
+ *
+ * Drops GROUP BY columns that are functionally determined by other remaining
+ * GROUP BY columns under the aggregate-output FDs and equivalence classes.
+ * Each dropped column is re-emitted as a `MIN(<original-column>)` picker
+ * aggregate so the output attribute IDs (and therefore downstream binding)
+ * are preserved.
+ *
+ * The aggregate's own `physical.fds` and `physical.equivClasses` are already
+ * projected onto its output column indices by `propagateAggregateFds`, so
+ * the rule reasons in aggregate-output space directly:
+ *
+ *   - candidate set = bare `ColumnReferenceNode` GROUP BY output indices
+ *   - ECs expand to bi-directional FDs over those indices
+ *   - `minimalCover` returns the surviving indices; the rest are dropped
+ *
+ * Soundness: aggregate-output FDs only survive for bare-column GROUP BYs
+ * (per `propagateAggregateFds`), and EC-derived FDs from `WHERE a = b` are
+ * sound because every surviving row has equal values on the EC members.
+ *
+ * Rewrite preserves the output schema (positions may shift, attribute IDs do
+ * not): kept GROUP BYs come first, then the picker MIN aggregates re-emitting
+ * the dropped columns at their original attribute IDs (via
+ * `preserveAttributeIds`), then the original aggregate expressions.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { AggregateNode } from '../../nodes/aggregate-node.js';
+import { AggregateFunctionCallNode } from '../../nodes/aggregate-function.js';
+import { ColumnReferenceNode } from '../../nodes/reference.js';
+import { expandEcsToFds, minimalCover } from '../../util/fd-utils.js';
+import { isAggregateFunctionSchema } from '../../../schema/function.js';
+const log = createLogger('optimizer:rule:groupby-fd-simplification');
+export function ruleGroupByFdSimplification(node, context) {
+    if (!(node instanceof AggregateNode))
+        return null;
+    if (node.groupBy.length <= 1)
+        return null;
+    const aggAttrs = node.getAttributes();
+    // Build the set of candidate output indices: bare-column GROUP BYs only.
+    // Map outIdx → original ColumnReferenceNode so we can wire pickers later.
+    const candidateExprs = new Map();
+    for (let i = 0; i < node.groupBy.length; i++) {
+        const gb = node.groupBy[i];
+        if (gb instanceof ColumnReferenceNode) {
+            candidateExprs.set(i, gb);
+        }
+    }
+    if (candidateExprs.size <= 1)
+        return null;
+    const candidateSet = new Set(candidateExprs.keys());
+    const sourceFds = node.physical.fds ?? [];
+    const ecs = node.physical.equivClasses ?? [];
+    const combinedFds = expandEcsToFds(ecs, sourceFds);
+    const cover = minimalCover(candidateSet, combinedFds);
+    if (cover.size === candidateSet.size)
+        return null;
+    const dropped = new Set();
+    for (const idx of candidateSet) {
+        if (!cover.has(idx))
+            dropped.add(idx);
+    }
+    if (dropped.size === 0)
+        return null;
+    // Build new groupBy: keep non-candidates (expressions) AND kept candidates,
+    // preserving original relative order. Track the new output index each old
+    // index maps to so we can rebuild preserveAttributeIds correctly.
+    const keptGroupBy = [];
+    const keptGroupByOldIdx = [];
+    const droppedOldIdx = [];
+    for (let i = 0; i < node.groupBy.length; i++) {
+        if (candidateSet.has(i) && !cover.has(i)) {
+            droppedOldIdx.push(i);
+        }
+        else {
+            keptGroupBy.push(node.groupBy[i]);
+            keptGroupByOldIdx.push(i);
+        }
+    }
+    // Synthesize picker MIN aggregates for each dropped column, in original order.
+    const minSchema = context.db._findFunction('min', 1);
+    if (!minSchema || !isAggregateFunctionSchema(minSchema)) {
+        log('min/1 not registered as aggregate; skipping');
+        return null;
+    }
+    const pickerAggregates = [];
+    for (const oldIdx of droppedOldIdx) {
+        const colRef = candidateExprs.get(oldIdx);
+        const origAttr = aggAttrs[oldIdx];
+        const minExpr = {
+            type: 'function',
+            name: 'min',
+            args: [colRef.expression],
+            distinct: false,
+        };
+        const inferredType = minSchema.inferReturnType
+            ? minSchema.inferReturnType([colRef.getType().logicalType])
+            : undefined;
+        const pickerCall = new AggregateFunctionCallNode(node.scope, minExpr, 'min', minSchema, [colRef], false, undefined, undefined, inferredType);
+        pickerAggregates.push({ expression: pickerCall, alias: origAttr.name });
+    }
+    // Rebuild preserveAttributeIds in the new physical order:
+    //   [kept-gb attrs..., dropped-gb attrs (as picker outputs)..., orig-agg attrs...]
+    const groupByCount = node.groupBy.length;
+    const newAttrs = [];
+    for (const oldIdx of keptGroupByOldIdx)
+        newAttrs.push(aggAttrs[oldIdx]);
+    for (const oldIdx of droppedOldIdx)
+        newAttrs.push(aggAttrs[oldIdx]);
+    for (let i = groupByCount; i < aggAttrs.length; i++)
+        newAttrs.push(aggAttrs[i]);
+    const newAggregates = [...pickerAggregates, ...node.aggregates];
+    log('Dropped %d/%d GROUP BY column(s); picker aggregates: %d', dropped.size, candidateSet.size, pickerAggregates.length);
+    return new AggregateNode(node.scope, node.source, keptGroupBy, newAggregates, undefined, newAttrs);
+}
+//# sourceMappingURL=rule-groupby-fd-simplification.js.map

package/dist/src/planner/rules/aggregate/rule-groupby-fd-simplification.js.map

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

package/dist/src/planner/rules/distinct/rule-distinct-elimination.d.ts

@@ -3,15 +3,15 @@ import type { OptContext } from '../../framework/context.js';
 /**
  * Rule: DISTINCT Elimination
  *
- * When a DistinctNode's source already guarantees unique rows (via logical keys
- * from RelationType or physical uniqueKeys), the DISTINCT is redundant and can
- * be removed.
+ * When a DistinctNode's source already guarantees unique rows, the DISTINCT is
+ * redundant and can be removed.
  *
- * Checks both:
- * 1. Physical uniqueKeys (from computePhysical, available after physical pass)
- * 2. Logical keys (from RelationType.keys, available at any time)
+ * Sources of uniqueness proof:
+ * 1. Logical keys (`RelationType.keys`) — schema-declared, available at any time.
+ * 2. Physical FD set — encodes derived keys as `K → all_other_cols` FDs, plus
+ *    the singleton `∅ → all_cols` for at-most-one-row claims.
  *
- * A key that is present in the source proves it already produces unique rows —
+ * A non-empty key proof on the source proves it already produces unique rows —
  * DISTINCT is a no-op.
  */
 export declare function ruleDistinctElimination(node: PlanNode, _context: OptContext): PlanNode | null;

package/dist/src/planner/rules/distinct/rule-distinct-elimination.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-distinct-elimination.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/distinct/rule-distinct-elimination.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAK7D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAoB7F"}
+{"version":3,"file":"rule-distinct-elimination.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/distinct/rule-distinct-elimination.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAM7D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAqB7F"}

package/dist/src/planner/rules/distinct/rule-distinct-elimination.js

@@ -1,37 +1,39 @@
 import { createLogger } from '../../../common/logger.js';
 import { DistinctNode } from '../../nodes/distinct-node.js';
+import { hasAnyKey, hasSingletonFd } from '../../util/fd-utils.js';
 const log = createLogger('optimizer:rule:distinct-elimination');
 /**
  * Rule: DISTINCT Elimination
  *
- * When a DistinctNode's source already guarantees unique rows (via logical keys
- * from RelationType or physical uniqueKeys), the DISTINCT is redundant and can
- * be removed.
+ * When a DistinctNode's source already guarantees unique rows, the DISTINCT is
+ * redundant and can be removed.
  *
- * Checks both:
- * 1. Physical uniqueKeys (from computePhysical, available after physical pass)
- * 2. Logical keys (from RelationType.keys, available at any time)
+ * Sources of uniqueness proof:
+ * 1. Logical keys (`RelationType.keys`) — schema-declared, available at any time.
+ * 2. Physical FD set — encodes derived keys as `K → all_other_cols` FDs, plus
+ *    the singleton `∅ → all_cols` for at-most-one-row claims.
  *
- * A key that is present in the source proves it already produces unique rows —
+ * A non-empty key proof on the source proves it already produces unique rows —
  * DISTINCT is a no-op.
  */
 export function ruleDistinctElimination(node, _context) {
     if (!(node instanceof DistinctNode))
         return null;
-    // Check physical uniqueKeys (available if physical pass has run or compute is triggered)
-    const sourcePhys = node.source.physical;
-    if (sourcePhys?.uniqueKeys && sourcePhys.uniqueKeys.length > 0) {
-        log('Eliminating redundant DISTINCT: source has physical uniqueKeys %j', sourcePhys.uniqueKeys);
-        return node.source;
-    }
-    // Check logical keys from RelationType
-    // If the source's logical type declares any key, the source already produces
-    // unique rows (since any superset of a key is also unique).
+    // Logical keys (RelationType.keys) are the schema-level claim.
     const sourceType = node.source.getType();
     if (sourceType.keys && sourceType.keys.length > 0) {
         log('Eliminating redundant DISTINCT: source has logical keys %j', sourceType.keys);
         return node.source;
     }
+    // Physical FDs: an FD whose determinants form a non-trivial superkey of the
+    // source columns proves uniqueness; the singleton `∅ → all_cols` proves
+    // at-most-one-row (also unique).
+    const sourcePhys = node.source.physical;
+    const colCount = node.source.getAttributes().length;
+    if (hasAnyKey(sourcePhys?.fds, colCount) || hasSingletonFd(sourcePhys?.fds, colCount)) {
+        log('Eliminating redundant DISTINCT: source FDs imply unique rows');
+        return node.source;
+    }
     return null;
 }
 //# sourceMappingURL=rule-distinct-elimination.js.map

package/dist/src/planner/rules/distinct/rule-distinct-elimination.js.map

@@ -1 +1 @@
-{"version":3,"file":"rule-distinct-elimination.js","sourceRoot":"","sources":["../../../../../src/planner/rules/distinct/rule-distinct-elimination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,MAAM,GAAG,GAAG,YAAY,CAAC,qCAAqC,CAAC,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAc,EAAE,QAAoB;IAC3E,IAAI,CAAC,CAAC,IAAI,YAAY,YAAY,CAAC;QAAE,OAAO,IAAI,CAAC;IAEjD,yFAAyF;IACzF,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;IACxC,IAAI,UAAU,EAAE,UAAU,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAChE,GAAG,CAAC,mEAAmE,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;QAChG,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAED,uCAAuC;IACvC,6EAA6E;IAC7E,4DAA4D;IAC5D,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IACzC,IAAI,UAAU,CAAC,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnD,GAAG,CAAC,4DAA4D,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;QACnF,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAED,OAAO,IAAI,CAAC;AACb,CAAC"}
+{"version":3,"file":"rule-distinct-elimination.js","sourceRoot":"","sources":["../../../../../src/planner/rules/distinct/rule-distinct-elimination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEnE,MAAM,GAAG,GAAG,YAAY,CAAC,qCAAqC,CAAC,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAc,EAAE,QAAoB;IAC3E,IAAI,CAAC,CAAC,IAAI,YAAY,YAAY,CAAC;QAAE,OAAO,IAAI,CAAC;IAEjD,+DAA+D;IAC/D,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IACzC,IAAI,UAAU,CAAC,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnD,GAAG,CAAC,4DAA4D,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;QACnF,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAED,4EAA4E;IAC5E,wEAAwE;IACxE,iCAAiC;IACjC,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;IACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC,MAAM,CAAC;IACpD,IAAI,SAAS,CAAC,UAAU,EAAE,GAAG,EAAE,QAAQ,CAAC,IAAI,cAAc,CAAC,UAAU,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC;QACvF,GAAG,CAAC,8DAA8D,CAAC,CAAC;QACpE,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAED,OAAO,IAAI,CAAC;AACb,CAAC"}

package/dist/src/planner/rules/join/rule-join-elimination.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Rule: Join Elimination (FK→PK)
+ *
+ * Eliminates a join whose non-preserved side is never referenced above the join
+ * and is guaranteed at-most-one-matching per FK→PK alignment.
+ *
+ * The rule fires on ProjectNode and walks down through a whitelist of
+ * pass-through nodes (Filter, Sort, LimitOffset, Distinct, Alias) collecting
+ * the set of attribute IDs that any caller above the join still demands. When
+ * the walk reaches a JoinNode, the demanded set is final for that chain:
+ *
+ *   - If the demanded set only references the preserved side and the equi-join
+ *     condition aligns FK columns on the preserved side with the PK on the
+ *     other side, the join is rewritten away.
+ *   - For LEFT/RIGHT outer joins, only the non-preserved side may be eliminated
+ *     (the preserved side is required by SQL semantics).
+ *   - For INNER joins, either side may be eliminated, but additionally the FK
+ *     columns must be NOT NULL — otherwise NULL FK rows that wouldn't have
+ *     matched on the join would now survive.
+ *
+ * Non-equi residual conjuncts in the ON-clause disqualify the rewrite (they
+ * may alter cardinality beyond the FK→PK guarantee).
+ */
+import type { PlanNode, ScalarPlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleJoinElimination(node: PlanNode, _context: OptContext): PlanNode | null;
+/**
+ * AND-of-equalities check: every conjunct must be `colRef = colRef`. Any other
+ * predicate shape (range comparison, non-equality, OR, function calls, …)
+ * disqualifies the rewrite — those residuals can change row counts beyond what
+ * the FK→PK guarantee covers.
+ */
+export declare function isAndOfColumnEqualities(expr: ScalarPlanNode): boolean;
+/**
+ * Aggregate counterpart of `ruleJoinElimination`: when an Aggregate sits over
+ * a chain ending in an FK-covered inner join and the aggregate's payload only
+ * depends on the FK (left) side, drop the join.
+ *
+ * Why correct for `count(*)` and similar cardinality-only aggregates: a
+ * non-null FK with the IND `L.fk ⊆ R.pk` and an unfiltered R guarantees
+ * `|L ⋈ R| == |L|`, so `count(*)` over the join equals `count(*)` over L.
+ * More generally, when no aggregate argument or group key references R, the
+ * inner join's only effect is to gate L by `fk IS NOT NULL`, which the
+ * NOT-NULL precondition already rules out.
+ *
+ * Implementation mirrors the Project entrypoint: collect attribute IDs the
+ * Aggregate demands (group-key expressions + every aggregate expression),
+ * walk the wrapper chain to find the Join, run the same FK-PK alignment +
+ * row-preserving checks as the inner-join case, then rebuild the chain on
+ * the preserved side.
+ *
+ * Only `inner` joins are eligible here — outer joins reduce to inner in this
+ * context only when both sides demand attrs, which we'd have rejected already.
+ */
+export declare function ruleJoinEliminationUnderAggregate(node: PlanNode, _context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-join-elimination.d.ts.map

package/dist/src/planner/rules/join/rule-join-elimination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-join-elimination.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-elimination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAsB,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE7F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AA6B7D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAuDzF;AA+DD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAgBrE;AA8ED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAwDvG"}

package/dist/src/planner/rules/join/rule-join-elimination.js

@@ -0,0 +1,326 @@
+/**
+ * Rule: Join Elimination (FK→PK)
+ *
+ * Eliminates a join whose non-preserved side is never referenced above the join
+ * and is guaranteed at-most-one-matching per FK→PK alignment.
+ *
+ * The rule fires on ProjectNode and walks down through a whitelist of
+ * pass-through nodes (Filter, Sort, LimitOffset, Distinct, Alias) collecting
+ * the set of attribute IDs that any caller above the join still demands. When
+ * the walk reaches a JoinNode, the demanded set is final for that chain:
+ *
+ *   - If the demanded set only references the preserved side and the equi-join
+ *     condition aligns FK columns on the preserved side with the PK on the
+ *     other side, the join is rewritten away.
+ *   - For LEFT/RIGHT outer joins, only the non-preserved side may be eliminated
+ *     (the preserved side is required by SQL semantics).
+ *   - For INNER joins, either side may be eliminated, but additionally the FK
+ *     columns must be NOT NULL — otherwise NULL FK rows that wouldn't have
+ *     matched on the join would now survive.
+ *
+ * Non-equi residual conjuncts in the ON-clause disqualify the rewrite (they
+ * may alter cardinality beyond the FK→PK guarantee).
+ */
+import { createLogger } from '../../../common/logger.js';
+import { isRelationalNode } from '../../nodes/plan-node.js';
+import { ProjectNode } from '../../nodes/project-node.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { SortNode } from '../../nodes/sort.js';
+import { LimitOffsetNode } from '../../nodes/limit-offset.js';
+import { DistinctNode } from '../../nodes/distinct-node.js';
+import { AliasNode } from '../../nodes/alias-node.js';
+import { AggregateNode } from '../../nodes/aggregate-node.js';
+import { JoinNode, extractEquiPairsFromCondition } from '../../nodes/join-node.js';
+import { ColumnReferenceNode } from '../../nodes/reference.js';
+import { BinaryOpNode } from '../../nodes/scalar.js';
+import { normalizePredicate } from '../../analysis/predicate-normalizer.js';
+import { checkFkPkAlignment, extractTableSchema } from '../../util/key-utils.js';
+import { lookupCoveringFK, isRowPreservingPathToTable } from '../../util/ind-utils.js';
+const log = createLogger('optimizer:rule:join-elimination');
+export function ruleJoinElimination(node, _context) {
+    if (!(node instanceof ProjectNode))
+        return null;
+    const demanded = new Set();
+    for (const proj of node.projections) {
+        collectAttrIds(proj.node, demanded);
+    }
+    const walk = walkChain(node.source, demanded);
+    if (!walk)
+        return null;
+    const { join, chain } = walk;
+    if (join.joinType !== 'left' && join.joinType !== 'right' && join.joinType !== 'inner')
+        return null;
+    if (!join.condition)
+        return null;
+    const leftAttrs = join.left.getAttributes();
+    const rightAttrs = join.right.getAttributes();
+    const pairs = extractEquiPairsFromCondition(join.condition, leftAttrs, rightAttrs);
+    if (pairs.length === 0)
+        return null;
+    const normalized = normalizePredicate(join.condition);
+    if (!isAndOfColumnEqualities(normalized))
+        return null;
+    const leftIds = new Set(leftAttrs.map(a => a.id));
+    const rightIds = new Set(rightAttrs.map(a => a.id));
+    const usesLeft = setsIntersect(demanded, leftIds);
+    const usesRight = setsIntersect(demanded, rightIds);
+    let preserved = null;
+    switch (join.joinType) {
+        case 'left':
+            if (usesRight)
+                return null;
+            preserved = tryEliminate(join, 'right', pairs);
+            break;
+        case 'right':
+            if (usesLeft)
+                return null;
+            preserved = tryEliminate(join, 'left', pairs);
+            break;
+        case 'inner':
+            if (!usesRight) {
+                preserved = tryEliminate(join, 'right', pairs);
+            }
+            if (!preserved && !usesLeft) {
+                preserved = tryEliminate(join, 'left', pairs);
+            }
+            break;
+    }
+    if (!preserved)
+        return null;
+    log('Eliminating %s join under Project; preserved side has %d attrs', join.joinType, preserved.getAttributes().length);
+    const newSource = rebuildChain(chain, preserved);
+    return rebuildProject(node, newSource);
+}
+function collectAttrIds(expr, out) {
+    if (expr instanceof ColumnReferenceNode) {
+        out.add(expr.attributeId);
+        return;
+    }
+    for (const child of expr.getChildren()) {
+        collectAttrIds(child, out);
+    }
+}
+function walkChain(root, demanded) {
+    const chain = [];
+    let current = root;
+    while (true) {
+        if (current instanceof JoinNode) {
+            return { join: current, chain };
+        }
+        if (current instanceof FilterNode) {
+            collectAttrIds(current.predicate, demanded);
+            chain.push({ kind: 'filter', node: current });
+            current = current.source;
+            continue;
+        }
+        if (current instanceof SortNode) {
+            for (const k of current.sortKeys) {
+                collectAttrIds(k.expression, demanded);
+            }
+            chain.push({ kind: 'sort', node: current });
+            current = current.source;
+            continue;
+        }
+        if (current instanceof LimitOffsetNode) {
+            chain.push({ kind: 'limit', node: current });
+            current = current.source;
+            continue;
+        }
+        if (current instanceof DistinctNode) {
+            // DISTINCT collapses duplicates that the join (with at-most-one matching)
+            // would never have produced anyway; safe to walk through.
+            chain.push({ kind: 'distinct', node: current });
+            current = current.source;
+            continue;
+        }
+        if (current instanceof AliasNode) {
+            chain.push({ kind: 'alias', node: current });
+            current = current.source;
+            continue;
+        }
+        return null;
+    }
+}
+function setsIntersect(a, b) {
+    const [small, large] = a.size <= b.size ? [a, b] : [b, a];
+    for (const v of small) {
+        if (large.has(v))
+            return true;
+    }
+    return false;
+}
+/**
+ * AND-of-equalities check: every conjunct must be `colRef = colRef`. Any other
+ * predicate shape (range comparison, non-equality, OR, function calls, …)
+ * disqualifies the rewrite — those residuals can change row counts beyond what
+ * the FK→PK guarantee covers.
+ */
+export function isAndOfColumnEqualities(expr) {
+    if (!(expr instanceof BinaryOpNode))
+        return false;
+    const stack = [expr];
+    while (stack.length > 0) {
+        const n = stack.pop();
+        if (!(n instanceof BinaryOpNode))
+            return false;
+        const op = n.expression.operator;
+        if (op === 'AND') {
+            stack.push(n.left, n.right);
+            continue;
+        }
+        if (op !== '=')
+            return false;
+        if (!(n.left instanceof ColumnReferenceNode))
+            return false;
+        if (!(n.right instanceof ColumnReferenceNode))
+            return false;
+    }
+    return true;
+}
+/**
+ * Validate FK→PK alignment for eliminating `sideToRemove` and return the
+ * preserved side relational node when safe.
+ */
+function tryEliminate(join, sideToRemove, pairs) {
+    const leftSchema = extractTableSchema(join.left);
+    const rightSchema = extractTableSchema(join.right);
+    if (!leftSchema || !rightSchema)
+        return null;
+    // FK side is the preserved side; PK side is the side being removed.
+    const fkSchema = sideToRemove === 'right' ? leftSchema : rightSchema;
+    const pkSchema = sideToRemove === 'right' ? rightSchema : leftSchema;
+    const fkEquiCols = pairs.map(p => sideToRemove === 'right' ? p.left : p.right);
+    const pkEquiCols = pairs.map(p => sideToRemove === 'right' ? p.right : p.left);
+    if (!checkFkPkAlignment(fkSchema, pkSchema, fkEquiCols, pkEquiCols))
+        return null;
+    // INNER joins additionally require:
+    //  1. NOT NULL on every FK column — with nullable FK, rows with NULL FKs
+    //     wouldn't survive the inner join but would survive elimination.
+    //  2. The eliminable side must produce the underlying PK table's full row
+    //     set — any row-reducing wrapper (Filter, LimitOffset, Distinct,
+    //     RetrieveNode with a non-trivial pipeline) between the join and the
+    //     base table would have dropped rows that the FK→PK guarantee assumes
+    //     are present, so eliminating would silently survive orphaned FK rows.
+    if (join.joinType === 'inner') {
+        const match = lookupCoveringFK(fkSchema, pkSchema, fkEquiCols, pkEquiCols);
+        if (!match)
+            return null;
+        if (match.nullable)
+            return null;
+        const eliminableSide = sideToRemove === 'right' ? join.right : join.left;
+        if (!isRowPreservingPathToTable(eliminableSide))
+            return null;
+    }
+    return (sideToRemove === 'right' ? join.left : join.right);
+}
+function rebuildChain(chain, bottom) {
+    let current = bottom;
+    // Chain was collected top→bottom (root pushed first); rebuild bottom→top.
+    for (let i = chain.length - 1; i >= 0; i--) {
+        const entry = chain[i];
+        switch (entry.kind) {
+            case 'filter': {
+                current = new FilterNode(entry.node.scope, current, entry.node.predicate);
+                break;
+            }
+            case 'sort': {
+                current = new SortNode(entry.node.scope, current, entry.node.sortKeys);
+                break;
+            }
+            case 'limit': {
+                current = new LimitOffsetNode(entry.node.scope, current, entry.node.limit, entry.node.offset);
+                break;
+            }
+            case 'distinct': {
+                current = new DistinctNode(entry.node.scope, current);
+                break;
+            }
+            case 'alias': {
+                current = new AliasNode(entry.node.scope, current, entry.node.alias);
+                break;
+            }
+        }
+    }
+    return current;
+}
+/**
+ * Aggregate counterpart of `ruleJoinElimination`: when an Aggregate sits over
+ * a chain ending in an FK-covered inner join and the aggregate's payload only
+ * depends on the FK (left) side, drop the join.
+ *
+ * Why correct for `count(*)` and similar cardinality-only aggregates: a
+ * non-null FK with the IND `L.fk ⊆ R.pk` and an unfiltered R guarantees
+ * `|L ⋈ R| == |L|`, so `count(*)` over the join equals `count(*)` over L.
+ * More generally, when no aggregate argument or group key references R, the
+ * inner join's only effect is to gate L by `fk IS NOT NULL`, which the
+ * NOT-NULL precondition already rules out.
+ *
+ * Implementation mirrors the Project entrypoint: collect attribute IDs the
+ * Aggregate demands (group-key expressions + every aggregate expression),
+ * walk the wrapper chain to find the Join, run the same FK-PK alignment +
+ * row-preserving checks as the inner-join case, then rebuild the chain on
+ * the preserved side.
+ *
+ * Only `inner` joins are eligible here — outer joins reduce to inner in this
+ * context only when both sides demand attrs, which we'd have rejected already.
+ */
+export function ruleJoinEliminationUnderAggregate(node, _context) {
+    if (!(node instanceof AggregateNode))
+        return null;
+    const demanded = new Set();
+    for (const groupExpr of node.groupBy) {
+        collectAttrIds(groupExpr, demanded);
+    }
+    for (const agg of node.aggregates) {
+        collectAttrIds(agg.expression, demanded);
+    }
+    const walk = walkChain(node.source, demanded);
+    if (!walk)
+        return null;
+    const { join, chain } = walk;
+    // Only inner-eliminable shapes — see `ruleJoinElimination` notes.
+    if (join.joinType !== 'inner')
+        return null;
+    if (!join.condition)
+        return null;
+    const leftAttrs = join.left.getAttributes();
+    const rightAttrs = join.right.getAttributes();
+    const pairs = extractEquiPairsFromCondition(join.condition, leftAttrs, rightAttrs);
+    if (pairs.length === 0)
+        return null;
+    const normalized = normalizePredicate(join.condition);
+    if (!isAndOfColumnEqualities(normalized))
+        return null;
+    const leftIds = new Set(leftAttrs.map(a => a.id));
+    const rightIds = new Set(rightAttrs.map(a => a.id));
+    const usesLeft = setsIntersect(demanded, leftIds);
+    const usesRight = setsIntersect(demanded, rightIds);
+    let preserved = null;
+    if (!usesRight) {
+        preserved = tryEliminate(join, 'right', pairs);
+    }
+    if (!preserved && !usesLeft) {
+        preserved = tryEliminate(join, 'left', pairs);
+    }
+    if (!preserved)
+        return null;
+    log('Eliminating inner join under Aggregate; preserved side has %d attrs', preserved.getAttributes().length);
+    const newSource = rebuildChain(chain, preserved);
+    if (!isRelationalNode(newSource)) {
+        throw new Error('rule-join-elimination-aggregate: rebuilt source must be relational');
+    }
+    return new AggregateNode(node.scope, newSource, node.groupBy, node.aggregates, undefined, node.getAttributes());
+}
+function rebuildProject(project, newSource) {
+    const attributes = project.getAttributes();
+    const newProjections = project.projections.map((p, i) => ({
+        node: p.node,
+        alias: p.alias,
+        attributeId: attributes[i].id,
+    }));
+    if (!isRelationalNode(newSource)) {
+        throw new Error('rule-join-elimination: rebuilt source must be relational');
+    }
+    return new ProjectNode(project.scope, newSource, newProjections, undefined, attributes, project.preserveInputColumns);
+}
+//# sourceMappingURL=rule-join-elimination.js.map

package/dist/src/planner/rules/join/rule-join-elimination.js.map

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

package/dist/src/planner/rules/join/rule-join-greedy-commute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-join-greedy-commute.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-greedy-commute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAsB,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAK7D;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA4B3F"}
+{"version":3,"file":"rule-join-greedy-commute.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-greedy-commute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAsB,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAa7D;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA4B3F"}