@quereus/quereus 0.1.0

package/dist/src/planner/resolve.js

@@ -0,0 +1,91 @@
+import { Ambiguous } from "./scopes/scope.js";
+import { ColumnReferenceNode, FunctionReferenceNode, ParameterReferenceNode, TableReferenceNode } from "./nodes/reference.js";
+import { QuereusError } from "../common/errors.js";
+import { StatusCode } from "../common/types.js";
+export function resolveTable(scope, exp, selectedSchema = 'main') {
+    // table: [schema.]name
+    const idName = exp.name;
+    const idSchema = exp.schema;
+    const symbolKey = idSchema ? `${idSchema}.${idName}` : `${selectedSchema}.${idName}`;
+    const result = scope.resolveSymbol(symbolKey, exp);
+    if (result === Ambiguous || result instanceof TableReferenceNode) {
+        return result;
+    }
+    throw new QuereusError(`${symbolKey} isn't a table`, StatusCode.ERROR);
+}
+// TODO: pragma resolution
+// export function resolveSchema(scope: Scope, exp: AST.IdentifierExpr): PragmaReferenceNode | typeof Ambiguous | undefined {
+// 	// pragma: name
+// 	const idName = exp.name.toLowerCase();
+// 	const result = scope.resolveSymbol(idName);
+// 	if (result === Ambiguous || result instanceof PragmaReferenceNode) {
+// 		return result;
+// 	}
+// 	throw new QuereusError(`${idName} isn't a pragma`, StatusCode.ERROR);
+// }
+export function resolveColumn(scope, exp, selectedSchema = 'main') {
+    const schemaQualifier = exp.schema;
+    const tableQualifier = exp.table;
+    const columnName = exp.name;
+    if (tableQualifier) {
+        if (schemaQualifier) {
+            // Fully qualified: schema.table.column
+            const symbolKey = `${schemaQualifier}.${tableQualifier}.${columnName}`;
+            const result = scope.resolveSymbol(symbolKey, exp);
+            if (result === Ambiguous || result instanceof ColumnReferenceNode) {
+                return result;
+            }
+            throw new QuereusError(`${symbolKey} isn't a column`, StatusCode.ERROR);
+        }
+        else {
+            // Table qualified: table.column
+            // Try without schema first, then with schema if that fails
+            const unqualifiedKey = `${tableQualifier}.${columnName}`;
+            const result = scope.resolveSymbol(unqualifiedKey, exp);
+            if (result === Ambiguous || result instanceof ColumnReferenceNode) {
+                return result;
+            }
+            // If unqualified fails, try with the selected schema
+            const qualifiedKey = `${selectedSchema}.${tableQualifier}.${columnName}`;
+            const qualifiedResult = scope.resolveSymbol(qualifiedKey, exp);
+            if (qualifiedResult === Ambiguous || qualifiedResult instanceof ColumnReferenceNode) {
+                return qualifiedResult;
+            }
+            throw new QuereusError(`${unqualifiedKey} isn't a column`, StatusCode.ERROR);
+        }
+    }
+    else {
+        // Unqualified: column
+        const result = scope.resolveSymbol(columnName, exp);
+        if (result === Ambiguous || result instanceof ColumnReferenceNode) {
+            return result;
+        }
+        throw new QuereusError(`Column not found: ${columnName}`, StatusCode.ERROR);
+    }
+}
+export function resolveParameter(scope, exp) {
+    // For anonymous parameters (?), use '?' as the symbolKey
+    // For named parameters (:name), use ':name' as the symbolKey
+    const symbolKey = exp.name ? `:${exp.name}` : '?';
+    const result = scope.resolveSymbol(symbolKey, exp);
+    if (result === Ambiguous || result instanceof ParameterReferenceNode) {
+        return result;
+    }
+    throw new QuereusError(`${symbolKey} isn't a parameter`, StatusCode.ERROR);
+}
+export function resolveFunction(scope, exp) {
+    // First try exact argument count
+    const symbolKey = exp.name.toLowerCase() + '/' + exp.args.length;
+    let result = scope.resolveSymbol(symbolKey, exp);
+    if (result === Ambiguous || result instanceof FunctionReferenceNode) {
+        return result;
+    }
+    // If exact match not found, try variable argument function (numArgs = -1)
+    const varArgSymbolKey = exp.name.toLowerCase() + '/-1';
+    result = scope.resolveSymbol(varArgSymbolKey, exp);
+    if (result === Ambiguous || result instanceof FunctionReferenceNode) {
+        return result;
+    }
+    throw new QuereusError(`Function not found/ambiguous: ${exp.name}/${exp.args.length}`, StatusCode.ERROR);
+}
+//# sourceMappingURL=resolve.js.map

package/dist/src/planner/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../../src/planner/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAc,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC9H,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,MAAM,UAAU,YAAY,CAAC,KAAY,EAAE,GAAuB,EAAE,iBAAyB,MAAM;IAClG,uBAAuB;IACvB,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC;IACxB,MAAM,QAAQ,GAAG,GAAG,CAAC,MAAM,CAAC;IAC5B,MAAM,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,IAAI,MAAM,EAAE,CAAC,CAAC,CAAC,GAAG,cAAc,IAAI,MAAM,EAAE,CAAC;IAErF,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IACnD,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,YAAY,kBAAkB,EAAE,CAAC;QAClE,OAAO,MAAM,CAAC;IACf,CAAC;IACD,MAAM,IAAI,YAAY,CAAC,GAAG,SAAS,gBAAgB,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;AACxE,CAAC;AAED,0BAA0B;AAC1B,6HAA6H;AAC7H,mBAAmB;AACnB,0CAA0C;AAC1C,+CAA+C;AAC/C,wEAAwE;AACxE,mBAAmB;AACnB,KAAK;AACL,yEAAyE;AACzE,IAAI;AAEJ,MAAM,UAAU,aAAa,CAAC,KAAY,EAAE,GAAmB,EAAE,iBAAyB,MAAM;IAC/F,MAAM,eAAe,GAAG,GAAG,CAAC,MAAM,CAAC;IACnC,MAAM,cAAc,GAAG,GAAG,CAAC,KAAK,CAAC;IACjC,MAAM,UAAU,GAAG,GAAG,CAAC,IAAI,CAAC;IAE5B,IAAI,cAAc,EAAE,CAAC;QACpB,IAAI,eAAe,EAAE,CAAC;YACrB,uCAAuC;YACvC,MAAM,SAAS,GAAG,GAAG,eAAe,IAAI,cAAc,IAAI,UAAU,EAAE,CAAC;YACvE,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;YACnD,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,YAAY,mBAAmB,EAAE,CAAC;gBACnE,OAAO,MAAM,CAAC;YACf,CAAC;YACD,MAAM,IAAI,YAAY,CAAC,GAAG,SAAS,iBAAiB,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;QACzE,CAAC;aAAM,CAAC;YACP,gCAAgC;YAChC,2DAA2D;YAC3D,MAAM,cAAc,GAAG,GAAG,cAAc,IAAI,UAAU,EAAE,CAAC;YACzD,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;YACxD,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,YAAY,mBAAmB,EAAE,CAAC;gBACnE,OAAO,MAAM,CAAC;YACf,CAAC;YAED,qDAAqD;YACrD,MAAM,YAAY,GAAG,GAAG,cAAc,IAAI,cAAc,IAAI,UAAU,EAAE,CAAC;YACzE,MAAM,eAAe,GAAG,KAAK,CAAC,aAAa,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;YAC/D,IAAI,eAAe,KAAK,SAAS,IAAI,eAAe,YAAY,mBAAmB,EAAE,CAAC;gBACrF,OAAO,eAAe,CAAC;YACxB,CAAC;YAED,MAAM,IAAI,YAAY,CAAC,GAAG,cAAc,iBAAiB,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;QAC9E,CAAC;IACF,CAAC;SAAM,CAAC;QACP,sBAAsB;QACtB,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;QACpD,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,YAAY,mBAAmB,EAAE,CAAC;YACnE,OAAO,MAAM,CAAC;QACf,CAAC;QACD,MAAM,IAAI,YAAY,CAAC,qBAAqB,UAAU,EAAE,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;IAC7E,CAAC;AACF,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,KAAY,EAAE,GAAsB;IACpE,yDAAyD;IACzD,6DAA6D;IAC7D,MAAM,SAAS,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;IAClD,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IACnD,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,YAAY,sBAAsB,EAAE,CAAC;QACtE,OAAO,MAAM,CAAC;IACf,CAAC;IACD,MAAM,IAAI,YAAY,CAAC,GAAG,SAAS,oBAAoB,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAY,EAAE,GAAqB;IAClE,iCAAiC;IACjC,MAAM,SAAS,GAAG,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC;IACjE,IAAI,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IACjD,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,YAAY,qBAAqB,EAAE,CAAC;QACrE,OAAO,MAAM,CAAC;IACf,CAAC;IAED,0EAA0E;IAC1E,MAAM,eAAe,GAAG,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC;IACvD,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;IACnD,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,YAAY,qBAAqB,EAAE,CAAC;QACrE,OAAO,MAAM,CAAC;IACf,CAAC;IAED,MAAM,IAAI,YAAY,CAAC,iCAAiC,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;AAC1G,CAAC"}

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

@@ -0,0 +1,11 @@
+/**
+ * Rule: Select Access Path
+ *
+ * Transforms: TableScanNode → SeqScanNode | IndexScanNode | IndexSeekNode
+ * Conditions: When logical table access needs to be made physical
+ * Benefits: Enables cost-based access path selection and index utilization
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleSelectAccessPath(node: PlanNode, context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-select-access-path.d.ts.map

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

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

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

@@ -0,0 +1,133 @@
+/**
+ * Rule: Select Access Path
+ *
+ * Transforms: TableScanNode → SeqScanNode | IndexScanNode | IndexSeekNode
+ * Conditions: When logical table access needs to be made physical
+ * Benefits: Enables cost-based access path selection and index utilization
+ */
+import { createLogger } from '../../../common/logger.js';
+import { TableScanNode } from '../../nodes/scan.js';
+import { SeqScanNode, IndexScanNode, IndexSeekNode } from '../../nodes/physical-access-nodes.js';
+import { seqScanCost } from '../../cost/index.js';
+const log = createLogger('optimizer:rule:select-access-path');
+export function ruleSelectAccessPath(node, context) {
+    // Guard: only apply to TableScanNode
+    if (!(node instanceof TableScanNode)) {
+        return null;
+    }
+    // Guard: already physical
+    if (node.physical) {
+        return null;
+    }
+    log('Selecting access path for table %s', node.source.tableSchema.name);
+    try {
+        // Get table schema and virtual table module
+        const tableSchema = node.source.tableSchema;
+        const vtabModule = tableSchema.vtabModule;
+        // If no virtual table module, fall back to sequential scan
+        if (!vtabModule || typeof vtabModule !== 'object' || !('getBestAccessPlan' in vtabModule)) {
+            log('No getBestAccessPlan support, using sequential scan for %s', tableSchema.name);
+            return createSeqScan(node);
+        }
+        // Extract constraints from current filter info
+        const constraints = extractConstraintsFromFilterInfo(node, tableSchema);
+        // Build request for getBestAccessPlan
+        const request = {
+            columns: tableSchema.columns.map((col, index) => ({
+                index,
+                name: col.name,
+                type: col.affinity,
+                isPrimaryKey: col.primaryKey || false,
+                isUnique: col.primaryKey || false // For now, assume only PK columns are unique
+            })),
+            filters: constraints,
+            estimatedRows: node.source.estimatedRows
+        };
+        // Call getBestAccessPlan
+        const accessPlan = vtabModule.getBestAccessPlan(context.db, tableSchema, request);
+        // Choose physical node based on access plan
+        const physicalNode = selectPhysicalNode(node, accessPlan, constraints);
+        log('Selected %s for table %s (cost: %f, rows: %s)', physicalNode.nodeType, tableSchema.name, accessPlan.cost, accessPlan.rows);
+        return physicalNode;
+    }
+    catch (error) {
+        log('Error selecting access path for %s: %s', node.source.tableSchema.name, error);
+        // Fall back to sequential scan on error
+        return createSeqScan(node);
+    }
+}
+/**
+ * Extract predicate constraints from FilterInfo
+ */
+function extractConstraintsFromFilterInfo(node, _tableSchema) {
+    const constraints = [];
+    // Extract from FilterInfo.indexInfoOutput.aConstraint if available
+    const indexConstraints = node.filterInfo.indexInfoOutput.aConstraint;
+    if (indexConstraints) {
+        for (let i = 0; i < indexConstraints.length; i++) {
+            const constraint = indexConstraints[i];
+            if (constraint && constraint.usable) {
+                constraints.push({
+                    columnIndex: constraint.iColumn,
+                    op: mapConstraintOp(constraint.op),
+                    usable: constraint.usable,
+                    // Note: actual value would need to be extracted from args
+                    value: undefined
+                });
+            }
+        }
+    }
+    return constraints;
+}
+/**
+ * Map internal constraint op to public constraint op
+ */
+function mapConstraintOp(_internalOp) {
+    // This mapping would need to be based on the actual constants used
+    // For now, assume equality - in a real implementation this would map
+    // from IndexConstraintOp constants to ConstraintOp
+    return '=';
+}
+/**
+ * Select the appropriate physical node based on access plan
+ */
+function selectPhysicalNode(originalNode, accessPlan, constraints) {
+    // Analyze the access plan to determine node type
+    const hasEqualityConstraints = constraints.some(c => c.op === '=' && accessPlan.handledFilters[constraints.indexOf(c)]);
+    const hasRangeConstraints = constraints.some(c => ['>', '>=', '<', '<='].includes(c.op) && accessPlan.handledFilters[constraints.indexOf(c)]);
+    // Convert OrderingSpec[] to the format expected by physical nodes
+    const providesOrdering = accessPlan.providesOrdering?.map(spec => ({
+        column: spec.columnIndex,
+        desc: spec.desc
+    }));
+    // Decision logic for access method
+    if (hasEqualityConstraints && (accessPlan.rows || 0) <= 10) {
+        // Small result set with equality - use index seek
+        log('Using index seek (equality constraint, small result)');
+        return new IndexSeekNode(originalNode.scope, originalNode.source, originalNode.filterInfo, 'primary', // Default to primary index
+        [], // seekKeys would be populated from constraints
+        false, // not a range
+        providesOrdering, accessPlan.cost);
+    }
+    else if (hasRangeConstraints || providesOrdering) {
+        // Range constraints or ordering required - use index scan
+        log('Using index scan (range constraints or ordering)');
+        return new IndexScanNode(originalNode.scope, originalNode.source, originalNode.filterInfo, 'primary', // Default to primary index
+        providesOrdering, accessPlan.cost);
+    }
+    else {
+        // Fall back to sequential scan
+        log('Using sequential scan (no beneficial index access)');
+        return createSeqScan(originalNode, accessPlan.cost);
+    }
+}
+/**
+ * Create a sequential scan node
+ */
+function createSeqScan(originalNode, cost) {
+    const tableRows = originalNode.source.estimatedRows || 1000;
+    const scanCost = cost ?? seqScanCost(tableRows);
+    const seqScan = new SeqScanNode(originalNode.scope, originalNode.source, originalNode.filterInfo, scanCost);
+    return seqScan;
+}
+//# sourceMappingURL=rule-select-access-path.js.map

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

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

package/dist/src/planner/rules/aggregate/rule-aggregate-streaming.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Rule: Aggregate Streaming
+ *
+ * Transforms: AggregateNode → StreamAggregateNode (with Sort if needed)
+ * Conditions: Logical aggregate node needs physical implementation
+ * Benefits: Enables streaming aggregation with proper grouping order
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleAggregateStreaming(node: PlanNode, _context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-aggregate-streaming.d.ts.map

package/dist/src/planner/rules/aggregate/rule-aggregate-streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-aggregate-streaming.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/aggregate/rule-aggregate-streaming.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAO7D,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA0D5F"}

package/dist/src/planner/rules/aggregate/rule-aggregate-streaming.js

@@ -0,0 +1,53 @@
+/**
+ * Rule: Aggregate Streaming
+ *
+ * Transforms: AggregateNode → StreamAggregateNode (with Sort if needed)
+ * Conditions: Logical aggregate node needs physical implementation
+ * Benefits: Enables streaming aggregation with proper grouping order
+ */
+import { createLogger } from '../../../common/logger.js';
+import { AggregateNode } from '../../nodes/aggregate-node.js';
+import { StreamAggregateNode } from '../../nodes/stream-aggregate.js';
+import { SortNode } from '../../nodes/sort.js';
+const log = createLogger('optimizer:rule:aggregate-streaming');
+export function ruleAggregateStreaming(node, _context) {
+    // Guard: only apply to AggregateNode
+    if (!(node instanceof AggregateNode)) {
+        return null;
+    }
+    log('Applying aggregate streaming rule to node %s', node.id);
+    // Source is already optimized by framework
+    const source = node.source;
+    // For now, always use StreamAggregate
+    // TODO: Check if source is ordered on groupBy columns
+    // TODO: Consider HashAggregate for unordered inputs
+    if (node.groupBy.length > 0) {
+        // Need to ensure ordering for streaming aggregate
+        // For now, always insert a sort
+        // TODO: Check if source already provides the required ordering
+        const sortKeys = node.groupBy.map(expr => ({
+            expression: expr,
+            direction: 'asc',
+            nulls: undefined
+        }));
+        const sortNode = new SortNode(node.scope, source, sortKeys);
+        const result = new StreamAggregateNode(node.scope, sortNode, node.groupBy, node.aggregates, undefined, // estimatedCostOverride
+        node.getAttributes() // **CRITICAL**: Preserve original attribute IDs
+        );
+        // Let framework set physical properties via markPhysical()
+        // Both SortNode and StreamAggregateNode have getPhysical() methods
+        log('Transformed AggregateNode to StreamAggregateNode with sort');
+        return result;
+    }
+    else {
+        // No GROUP BY - can stream aggregate without sorting
+        const result = new StreamAggregateNode(node.scope, source, node.groupBy, node.aggregates, undefined, // estimatedCostOverride
+        node.getAttributes() // **CRITICAL**: Preserve original attribute IDs
+        );
+        // Let framework set physical properties via markPhysical()
+        // StreamAggregateNode has getPhysical() method
+        log('Transformed AggregateNode to StreamAggregateNode without sort');
+        return result;
+    }
+}
+//# sourceMappingURL=rule-aggregate-streaming.js.map

package/dist/src/planner/rules/aggregate/rule-aggregate-streaming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-aggregate-streaming.js","sourceRoot":"","sources":["../../../../../src/planner/rules/aggregate/rule-aggregate-streaming.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C,MAAM,GAAG,GAAG,YAAY,CAAC,oCAAoC,CAAC,CAAC;AAE/D,MAAM,UAAU,sBAAsB,CAAC,IAAc,EAAE,QAAoB;IAC1E,qCAAqC;IACrC,IAAI,CAAC,CAAC,IAAI,YAAY,aAAa,CAAC,EAAE,CAAC;QACtC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,GAAG,CAAC,8CAA8C,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IAE7D,2CAA2C;IAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAE3B,sCAAsC;IACtC,sDAAsD;IACtD,oDAAoD;IAEpD,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC7B,kDAAkD;QAClD,gCAAgC;QAChC,+DAA+D;QAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC1C,UAAU,EAAE,IAAI;YAChB,SAAS,EAAE,KAAc;YACzB,KAAK,EAAE,SAAS;SAChB,CAAC,CAAC,CAAC;QAEJ,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QAE5D,MAAM,MAAM,GAAG,IAAI,mBAAmB,CACrC,IAAI,CAAC,KAAK,EACV,QAAQ,EACR,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,UAAU,EACf,SAAS,EAAE,wBAAwB;QACnC,IAAI,CAAC,aAAa,EAAE,CAAC,gDAAgD;SACrE,CAAC;QAEF,2DAA2D;QAC3D,mEAAmE;QAEnE,GAAG,CAAC,4DAA4D,CAAC,CAAC;QAClE,OAAO,MAAM,CAAC;IACf,CAAC;SAAM,CAAC;QACP,qDAAqD;QACrD,MAAM,MAAM,GAAG,IAAI,mBAAmB,CACrC,IAAI,CAAC,KAAK,EACV,MAAM,EACN,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,UAAU,EACf,SAAS,EAAE,wBAAwB;QACnC,IAAI,CAAC,aAAa,EAAE,CAAC,gDAAgD;SACrE,CAAC;QAEF,2DAA2D;QAC3D,+CAA+C;QAE/C,GAAG,CAAC,+DAA+D,CAAC,CAAC;QACrE,OAAO,MAAM,CAAC;IACf,CAAC;AACF,CAAC"}

package/dist/src/planner/rules/cache/rule-cte-optimization.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Rule: CTE Optimization
+ *
+ * Transforms: CTENode → CTENode (with caching when beneficial)
+ * Conditions: CTE would benefit from materialization/caching
+ * Benefits: Reduces redundant computation for repeated CTE access
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleCteOptimization(node: PlanNode, context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-cte-optimization.d.ts.map

package/dist/src/planner/rules/cache/rule-cte-optimization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-cte-optimization.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-cte-optimization.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAO7D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAgDxF"}

package/dist/src/planner/rules/cache/rule-cte-optimization.js

@@ -0,0 +1,38 @@
+/**
+ * Rule: CTE Optimization
+ *
+ * Transforms: CTENode → CTENode (with caching when beneficial)
+ * Conditions: CTE would benefit from materialization/caching
+ * Benefits: Reduces redundant computation for repeated CTE access
+ */
+import { createLogger } from '../../../common/logger.js';
+import { CTENode } from '../../nodes/cte-node.js';
+import { CacheNode } from '../../nodes/cache-node.js';
+import { PlanNodeType } from '../../nodes/plan-node-type.js';
+const log = createLogger('optimizer:rule:cte-optimization');
+export function ruleCteOptimization(node, context) {
+    // Guard: only apply to CTENode
+    if (!(node instanceof CTENode)) {
+        return null;
+    }
+    log('Optimizing CTENode %s', node.cteName);
+    // Source is already optimized by framework
+    const source = node.source;
+    // Heuristics for when to cache CTEs:
+    // 1. CTE has materialization hint
+    // 2. CTE is estimated to be reasonably sized
+    // 3. CTE is not already cached
+    const sourceSize = source.estimatedRows ?? context.tuning.defaultRowEstimate;
+    const shouldCache = (node.materializationHint === 'materialized' ||
+        (sourceSize > 0 && sourceSize < context.tuning.cte.maxSizeForCaching)) && source.nodeType !== PlanNodeType.Cache;
+    if (shouldCache) {
+        log('Adding cache to CTE %s (estimated rows: %d)', node.cteName, sourceSize);
+        const cacheThreshold = Math.min(sourceSize * context.tuning.cte.cacheThresholdMultiplier, context.tuning.cte.maxCacheThreshold);
+        const cachedSource = new CacheNode(source.scope, source, 'memory', cacheThreshold);
+        const result = new CTENode(node.scope, node.cteName, node.columns, cachedSource, node.materializationHint, node.isRecursive);
+        log('Created CTE with caching');
+        return result;
+    }
+    return null; // No transformation needed
+}
+//# sourceMappingURL=rule-cte-optimization.js.map

package/dist/src/planner/rules/cache/rule-cte-optimization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-cte-optimization.js","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-cte-optimization.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,MAAM,GAAG,GAAG,YAAY,CAAC,iCAAiC,CAAC,CAAC;AAE5D,MAAM,UAAU,mBAAmB,CAAC,IAAc,EAAE,OAAmB;IACtE,+BAA+B;IAC/B,IAAI,CAAC,CAAC,IAAI,YAAY,OAAO,CAAC,EAAE,CAAC;QAChC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,GAAG,CAAC,uBAAuB,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAE3C,2CAA2C;IAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAE3B,qCAAqC;IACrC,kCAAkC;IAClC,6CAA6C;IAC7C,+BAA+B;IAC/B,MAAM,UAAU,GAAG,MAAM,CAAC,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAC7E,MAAM,WAAW,GAAG,CACnB,IAAI,CAAC,mBAAmB,KAAK,cAAc;QAC3C,CAAC,UAAU,GAAG,CAAC,IAAI,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,CACrE,IAAI,MAAM,CAAC,QAAQ,KAAK,YAAY,CAAC,KAAK,CAAC;IAE5C,IAAI,WAAW,EAAE,CAAC;QACjB,GAAG,CAAC,6CAA6C,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QAC7E,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,CAC9B,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,wBAAwB,EACxD,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,iBAAiB,CACpC,CAAC;QACF,MAAM,YAAY,GAAG,IAAI,SAAS,CACjC,MAAM,CAAC,KAAK,EACZ,MAAM,EACN,QAAQ,EACR,cAAc,CACd,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,OAAO,CACzB,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,OAAO,EACZ,YAAY,EACZ,IAAI,CAAC,mBAAmB,EACxB,IAAI,CAAC,WAAW,CAChB,CAAC;QAEF,GAAG,CAAC,0BAA0B,CAAC,CAAC;QAChC,OAAO,MAAM,CAAC;IACf,CAAC;IAED,OAAO,IAAI,CAAC,CAAC,2BAA2B;AACzC,CAAC"}

package/dist/src/planner/rules/cache/rule-materialization-advisory.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Rule: Materialization Advisory
+ *
+ * Transforms: Any relational node → CacheNode (when beneficial)
+ * Conditions: Node would benefit from caching based on reference analysis
+ * Benefits: Reduces redundant computation for repeated scans and loop contexts
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleMaterializationAdvisory(node: PlanNode, context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-materialization-advisory.d.ts.map

package/dist/src/planner/rules/cache/rule-materialization-advisory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-materialization-advisory.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-materialization-advisory.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAK7D,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAkDhG"}

package/dist/src/planner/rules/cache/rule-materialization-advisory.js

@@ -0,0 +1,51 @@
+/**
+ * Rule: Materialization Advisory
+ *
+ * Transforms: Any relational node → CacheNode (when beneficial)
+ * Conditions: Node would benefit from caching based on reference analysis
+ * Benefits: Reduces redundant computation for repeated scans and loop contexts
+ */
+import { createLogger } from '../../../common/logger.js';
+import { MaterializationAdvisory } from '../../cache/materialization-advisory.js';
+const log = createLogger('optimizer:rule:materialization-advisory');
+export function ruleMaterializationAdvisory(node, context) {
+    // This is a global rule that analyzes the entire tree
+    // It should only be applied to root nodes to avoid duplicate analysis
+    // Simple heuristic: only apply to certain root-level node types
+    // to avoid analyzing the same tree multiple times
+    const rootNodeTypes = new Set([
+        'Select', 'Insert', 'Update', 'Delete', 'Block', 'CTE'
+    ]);
+    if (!rootNodeTypes.has(node.nodeType)) {
+        return null;
+    }
+    log('Applying materialization advisory to tree rooted at %s', node.nodeType);
+    try {
+        // Create advisory with current tuning parameters
+        const advisory = new MaterializationAdvisory(context.tuning);
+        // Analyze the tree for caching opportunities
+        const recommendations = advisory.analyzeTree(node);
+        // Count how many cache recommendations were made
+        const cacheCount = Array.from(recommendations.values())
+            .filter(rec => rec.shouldCache).length;
+        if (cacheCount === 0) {
+            log('No caching opportunities identified');
+            return null;
+        }
+        log('Found %d caching opportunities', cacheCount);
+        // Apply the caching recommendations
+        const cachedTree = advisory.applyCaching(node, recommendations);
+        // If the tree was modified, return the new tree
+        if (cachedTree !== node) {
+            log('Applied materialization advisory, tree modified');
+            return cachedTree;
+        }
+        return null;
+    }
+    catch (error) {
+        log('Error in materialization advisory: %s', error);
+        // Don't fail optimization - just skip caching
+        return null;
+    }
+}
+//# sourceMappingURL=rule-materialization-advisory.js.map

package/dist/src/planner/rules/cache/rule-materialization-advisory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-materialization-advisory.js","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-materialization-advisory.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAElF,MAAM,GAAG,GAAG,YAAY,CAAC,yCAAyC,CAAC,CAAC;AAEpE,MAAM,UAAU,2BAA2B,CAAC,IAAc,EAAE,OAAmB;IAC9E,sDAAsD;IACtD,sEAAsE;IAEtE,gEAAgE;IAChE,kDAAkD;IAClD,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC;QAC7B,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK;KACtD,CAAC,CAAC;IAEH,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QACvC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,GAAG,CAAC,wDAAwD,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAE7E,IAAI,CAAC;QACJ,iDAAiD;QACjD,MAAM,QAAQ,GAAG,IAAI,uBAAuB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAE7D,6CAA6C;QAC7C,MAAM,eAAe,GAAG,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAEnD,iDAAiD;QACjD,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC;aACrD,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC;QAExC,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;YACtB,GAAG,CAAC,qCAAqC,CAAC,CAAC;YAC3C,OAAO,IAAI,CAAC;QACb,CAAC;QAED,GAAG,CAAC,gCAAgC,EAAE,UAAU,CAAC,CAAC;QAElD,oCAAoC;QACpC,MAAM,UAAU,GAAG,QAAQ,CAAC,YAAY,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QAEhE,gDAAgD;QAChD,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;YACzB,GAAG,CAAC,iDAAiD,CAAC,CAAC;YACvD,OAAO,UAAU,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,CAAC;IAEb,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,GAAG,CAAC,uCAAuC,EAAE,KAAK,CAAC,CAAC;QACpD,8CAA8C;QAC9C,OAAO,IAAI,CAAC;IACb,CAAC;AACF,CAAC"}

package/dist/src/planner/rules/cache/rule-mutating-subquery-cache.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Rule: Mutating Subquery Cache Injection
+ *
+ * Transforms: JoinNode with mutating right side → JoinNode with cached right side
+ * Conditions: Right side contains operations with readonly=false physical property
+ * Benefits: Prevents mutating subqueries from being executed multiple times in nested loop joins
+ */
+import { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleMutatingSubqueryCache(node: PlanNode, context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-mutating-subquery-cache.d.ts.map

package/dist/src/planner/rules/cache/rule-mutating-subquery-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-mutating-subquery-cache.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-mutating-subquery-cache.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAO7D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAoD9F"}

package/dist/src/planner/rules/cache/rule-mutating-subquery-cache.js

@@ -0,0 +1,79 @@
+/**
+ * Rule: Mutating Subquery Cache Injection
+ *
+ * Transforms: JoinNode with mutating right side → JoinNode with cached right side
+ * Conditions: Right side contains operations with readonly=false physical property
+ * Benefits: Prevents mutating subqueries from being executed multiple times in nested loop joins
+ */
+import { createLogger } from '../../../common/logger.js';
+import { PlanNode } from '../../nodes/plan-node.js';
+import { JoinNode } from '../../nodes/join-node.js';
+import { CacheNode } from '../../nodes/cache-node.js';
+import { PlanNodeType } from '../../nodes/plan-node-type.js';
+const log = createLogger('optimizer:rule:mutating-subquery-cache');
+export function ruleMutatingSubqueryCache(node, context) {
+    // Guard: only apply to JoinNode
+    if (!(node instanceof JoinNode)) {
+        return null;
+    }
+    log('Checking JoinNode for operations with side effects on right side');
+    // Check if the right side contains operations with side effects
+    const rightSide = node.right;
+    const hasSideEffects = containsOperationsWithSideEffects(rightSide);
+    if (!hasSideEffects) {
+        log('Right side does not contain operations with side effects, skipping');
+        return null;
+    }
+    // Check if right side is already cached
+    if (rightSide.nodeType === PlanNodeType.Cache) {
+        log('Right side is already cached, skipping');
+        return null;
+    }
+    log('Detected operations with side effects on right side of join, injecting cache');
+    // Calculate appropriate cache threshold
+    const estimatedRows = rightSide.estimatedRows ?? context.tuning.defaultRowEstimate;
+    const threshold = Math.min(Math.max(estimatedRows * context.tuning.join.cacheThresholdMultiplier, 1000), context.tuning.join.maxCacheThreshold);
+    // Wrap the right side with a cache node
+    const cachedRightSide = new CacheNode(rightSide.scope, rightSide, 'memory', threshold);
+    // Create new join node with cached right side
+    const result = new JoinNode(node.scope, node.left, // Left side unchanged
+    cachedRightSide, // Right side now cached
+    node.joinType, node.condition, node.usingColumns);
+    log('Successfully injected cache for operations with side effects (threshold: %d)', threshold);
+    return result;
+}
+/**
+ * Recursively check if a plan tree contains operations with side effects
+ */
+function containsOperationsWithSideEffects(node) {
+    // Check if this node has side effects using physical properties
+    if (hasNodeSideEffects(node)) {
+        return true;
+    }
+    // Recursively check children
+    for (const child of node.getChildren()) {
+        if (containsOperationsWithSideEffects(child)) {
+            return true;
+        }
+    }
+    // Check relational children if available
+    if ('getRelations' in node) {
+        for (const relation of node.getRelations()) {
+            if (containsOperationsWithSideEffects(relation)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check if a node has side effects using physical properties
+ */
+function hasNodeSideEffects(node) {
+    // By the time rules run, all children should have physical properties set by the framework
+    if (!node.physical) {
+        throw new Error(`Internal error: Node ${node.nodeType}:${node.id} missing physical properties during rule application`);
+    }
+    return PlanNode.hasSideEffects(node.physical);
+}
+//# sourceMappingURL=rule-mutating-subquery-cache.js.map

package/dist/src/planner/rules/cache/rule-mutating-subquery-cache.js.map

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

package/dist/src/planner/rules/physical/rule-filter-optimization.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Rule: Filter Optimization
+ *
+ * Transforms: FilterNode → FilterNode (optimized)
+ * Conditions: When filter node's source needs optimization
+ * Benefits: Ensures filter nodes have optimized sources and proper physical properties
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleFilterOptimization(node: PlanNode, context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-filter-optimization.d.ts.map

package/dist/src/planner/rules/physical/rule-filter-optimization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-filter-optimization.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/physical/rule-filter-optimization.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAsB,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAM7D,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA4C3F"}