@quereus/quereus 0.1.0

package/src/planner/planning-context.ts

@@ -0,0 +1,168 @@
+import type { SqlParameters } from '../common/types.js';
+import type { Database } from '../core/database.js';
+import type { SchemaManager } from '../schema/manager.js';
+import type { Scope } from './scopes/scope.js';
+import type { ScalarPlanNode } from './nodes/plan-node.js';
+
+/**
+ * Debug options for query planning and execution.
+ */
+export interface DebugOptions {
+  /** Enable runtime instruction tracing (logs inputs/outputs) */
+  traceInstructions?: boolean;
+  /** Enable detailed plan tree output */
+  showPlan?: boolean;
+  /** Enable instruction program output */
+  showProgram?: boolean;
+  /** Custom debug context for additional logging */
+  debugContext?: Record<string, any>;
+}
+
+/**
+ * Represents a dependency on a schema object that was resolved during planning.
+ * Used for plan invalidation when schema changes.
+ */
+export interface SchemaDependency {
+	readonly type: 'table' | 'function' | 'vtab_module' | 'collation';
+	readonly schemaName?: string; // undefined for functions, collations, and vtab modules
+	readonly objectName: string;
+	readonly objectVersion?: number; // For future versioning support
+}
+
+/**
+ * Tracks schema dependencies during planning and provides invalidation callbacks.
+ */
+export class BuildTimeDependencyTracker {
+	private dependencies = new Set<string>();
+	private resolvedObjects = new Map<string, WeakRef<any>>();
+	private invalidationCallbacks = new Set<() => void>();
+
+	/**
+	 * Records a dependency on a schema object and stores a weak reference to it.
+	 */
+	recordDependency(dep: SchemaDependency, object: any): void {
+		const key = this.dependencyKey(dep);
+		this.dependencies.add(key);
+		this.resolvedObjects.set(key, new WeakRef(object));
+	}
+
+	/**
+	 * Adds a callback to be invoked when schema dependencies become invalid.
+	 */
+	addInvalidationCallback(callback: () => void): () => void {
+		this.invalidationCallbacks.add(callback);
+		return () => this.invalidationCallbacks.delete(callback);
+	}
+
+	/**
+	 * Checks if all dependencies are still valid by verifying weak references.
+	 */
+	checkIntegrity(): boolean {
+		for (const [_key, weakRef] of this.resolvedObjects.entries()) {
+			if (weakRef.deref() === undefined) {
+				// Object was garbage collected, dependency is invalid
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Gets all tracked dependencies.
+	 */
+	getDependencies(): SchemaDependency[] {
+		return Array.from(this.dependencies).map(key => this.parseDependencyKey(key));
+	}
+
+	/**
+	 * Checks if any dependencies are tracked.
+	 */
+	hasAnyDependencies(): boolean {
+		return this.dependencies.size > 0;
+	}
+
+	/**
+	 * Notifies all invalidation callbacks.
+	 */
+	notifyInvalidation(): void {
+		for (const callback of this.invalidationCallbacks) {
+			try {
+				callback();
+			} catch (error) {
+				console.error('Error in schema invalidation callback:', error);
+			}
+		}
+	}
+
+	private dependencyKey(dep: SchemaDependency): string {
+		const schema = dep.schemaName || '';
+		const version = dep.objectVersion || 0;
+		return `${dep.type}:${schema}:${dep.objectName}:${version}`;
+	}
+
+	private parseDependencyKey(key: string): SchemaDependency {
+		const [type, schemaName, objectName, versionStr] = key.split(':');
+		return {
+			type: type as SchemaDependency['type'],
+			schemaName: schemaName || undefined,
+			objectName,
+			objectVersion: parseInt(versionStr) || undefined
+		};
+	}
+}
+
+/**
+ * Provides contextual information necessary during the query planning phase.
+ * This object is passed to various planning functions to give them access to
+ * the database schema, current symbol resolution scope, and other relevant details.
+ */
+export interface PlanningContext {
+  /**
+   * The Database instance, providing access to the schema manager, function registry, etc.
+   */
+  readonly db: Database;
+
+  /**
+   * The SchemaManager instance, for direct access if needed (also available via db.schemaManager).
+   */
+  readonly schemaManager: SchemaManager; // Redundant if db is present, but can be convenient
+
+  /**
+   * The current Scope for symbol resolution (columns, parameters, CTEs).
+   * Planning functions for nested structures (like subqueries) will typically create a new Scope
+   * with the current scope as its parent and pass that down in a new PlanningContext.
+   */
+  readonly scope: Scope;
+
+	/**
+	 * The current parameters for the statement, as discovered by references.
+	 */
+	readonly parameters: SqlParameters;
+
+  /**
+   * Debug options controlling tracing and diagnostics output.
+   */
+  readonly debug?: DebugOptions;
+
+  /**
+   * Aggregates from the SELECT list (used when building HAVING expressions).
+   * This allows buildExpression to recognize when an aggregate function in HAVING
+   * refers to an already-computed aggregate from SELECT.
+   */
+  readonly aggregates?: Array<{
+    expression: ScalarPlanNode;
+    alias: string;
+    columnIndex: number;
+    attributeId: number;
+  }>;
+
+  /**
+   * Schema dependency tracker for this planning session.
+   */
+  readonly schemaDependencies: BuildTimeDependencyTracker;
+
+  /**
+   * Schema object cache for resolved objects during planning.
+   */
+  readonly schemaCache: Map<string, any>;
+}

package/src/planner/resolve.ts

@@ -0,0 +1,100 @@
+import { Ambiguous, type Scope } from "./scopes/scope.js";
+import * as AST from "../parser/ast.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: Scope, exp: AST.IdentifierExpr, selectedSchema: string = 'main'): TableReferenceNode | typeof Ambiguous | undefined {
+	// 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: Scope, exp: AST.ColumnExpr, selectedSchema: string = 'main'): ColumnReferenceNode | typeof Ambiguous | undefined {
+	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: Scope, exp: AST.ParameterExpr): ParameterReferenceNode | typeof Ambiguous | undefined {
+	// 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: Scope, exp: AST.FunctionExpr): FunctionReferenceNode | typeof Ambiguous | undefined {
+	// 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);
+}

package/src/planner/rules/README.md

@@ -0,0 +1,96 @@
+# Optimizer Rules Directory
+
+This directory contains optimization rules for the Quereus Titan optimizer, organized by functional area.
+
+## Directory Structure
+
+```
+rules/
+├── rewrite/          # Logical-to-logical transformations
+│   ├── predicate-pushdown/
+│   ├── join-reordering/
+│   └── subquery-rewrite/
+├── access/           # Table access path optimization
+│   ├── index-selection/
+│   └── scan-strategy/
+├── join/             # Join algorithm selection and optimization
+│   ├── algorithm-selection/
+│   └── join-ordering/
+├── aggregate/        # Aggregation optimization
+│   ├── streaming/
+│   └── hash-aggregate/
+├── cache/            # Caching and materialization
+│   ├── materialization/
+│   └── cache-injection/
+└── physical/         # Physical property propagation
+    ├── ordering/
+    └── uniqueness/
+```
+
+## Rule Categories
+
+### Rewrite Rules (Logical → Logical)
+Transform logical plan structure without changing to physical nodes:
+- Predicate pushdown
+- Join reordering based on cardinality
+- Subquery → join conversions
+- Constant folding and elimination
+
+### Access Rules (Logical → Physical)
+Choose optimal table access strategies:
+- Index vs. sequential scan selection
+- Index seek vs. scan decisions
+- Column pruning integration
+
+### Join Rules (Logical → Physical)
+Select join algorithms and optimize join trees:
+- Nested loop vs. hash join selection
+- Join order optimization
+- Cache injection for inner sides
+
+### Aggregate Rules (Logical → Physical)
+Choose aggregation implementation strategies:
+- Stream vs. hash aggregation
+- Sort requirement analysis
+- Grouping optimization
+
+### Cache Rules
+Inject caching where beneficial:
+- CTE materialization decisions
+- Nested loop inner caching
+- Spill-to-disk strategies
+
+### Physical Rules
+Propagate and optimize physical properties:
+- Ordering preservation and requirements
+- Uniqueness key propagation
+- Constant and deterministic flags
+
+## Rule Naming Convention
+
+Rules follow the pattern: `rule-<description>.ts`
+
+Examples:
+- `rule-predicate-pushdown.ts`
+- `rule-aggregate-streaming.ts`
+- `rule-join-hash-conversion.ts`
+- `rule-cache-cte-materialization.ts`
+
+## Implementation Requirements
+
+Each rule must:
+1. Follow the function signature: `(node: PlanNode, optimizer: Optimizer) => PlanNode | null`
+2. Include comprehensive unit tests in co-located `.spec.ts` file
+3. Use consistent logging with `createLogger('optimizer:rule:<name>')`
+4. Preserve attribute IDs when creating new nodes
+5. Set appropriate physical properties using `PlanNode.setDefaultPhysical()`
+
+## Getting Started
+
+1. Choose the appropriate category directory
+2. Copy the rule template from `docs/optimizer-conventions.md`
+3. Implement the rule following the established patterns
+4. Add comprehensive unit tests
+5. Register the rule in the appropriate registry file
+
+See `docs/optimizer-conventions.md` for detailed implementation guidelines. 

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

@@ -0,0 +1,180 @@
+/**
+ * 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 type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+import { TableScanNode } from '../../nodes/scan.js';
+import { SeqScanNode, IndexScanNode, IndexSeekNode } from '../../nodes/physical-access-nodes.js';
+import { seqScanCost } from '../../cost/index.js';
+import type { ColumnMeta, PredicateConstraint, BestAccessPlanRequest, BestAccessPlanResult, ConstraintOp } from '../../../vtab/best-access-plan.js';
+
+const log = createLogger('optimizer:rule:select-access-path');
+
+export function ruleSelectAccessPath(node: PlanNode, context: OptContext): PlanNode | null {
+	// 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: BestAccessPlanRequest = {
+			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
+			} as ColumnMeta)),
+			filters: constraints,
+			estimatedRows: node.source.estimatedRows
+		};
+
+		// Call getBestAccessPlan
+		const accessPlan = (vtabModule as any).getBestAccessPlan(context.db, tableSchema, request) as BestAccessPlanResult;
+
+		// 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: TableScanNode, _tableSchema: any): PredicateConstraint[] {
+	const constraints: PredicateConstraint[] = [];
+
+	// 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: number): ConstraintOp {
+	// 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: TableScanNode,
+	accessPlan: BestAccessPlanResult,
+	constraints: PredicateConstraint[]
+): SeqScanNode | IndexScanNode | IndexSeekNode {
+
+	// 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: TableScanNode, cost?: number): SeqScanNode {
+	const tableRows = originalNode.source.estimatedRows || 1000;
+	const scanCost = cost ?? seqScanCost(tableRows);
+
+	const seqScan = new SeqScanNode(
+		originalNode.scope,
+		originalNode.source,
+		originalNode.filterInfo,
+		scanCost
+	);
+
+	return seqScan;
+}

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

@@ -0,0 +1,76 @@
+/**
+ * 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 type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.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: PlanNode, _context: OptContext): PlanNode | null {
+	// 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' as const,
+			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;
+	}
+}

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

@@ -0,0 +1,66 @@
+/**
+ * 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 type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.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: PlanNode, context: OptContext): PlanNode | null {
+	// 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
+}