@quereus/quereus 0.1.0 → 0.2.1

package/src/planner/building/select-projections.ts

@@ -9,6 +9,8 @@ import { QuereusError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
 import { AggregateFunctionCallNode } from '../nodes/aggregate-function.js';
 import { WindowFunctionCallNode } from '../nodes/window-function.js';
+import { type RelationalPlanNode } from '../nodes/plan-node.js';
+import type { Scope } from '../scopes/scope.js';
 
 /**
  * Checks if an expression contains aggregate functions
@@ -53,48 +55,45 @@ export function isWindowExpression(node: ScalarPlanNode): boolean {
  */
 export function buildStarProjections(
 	column: { type: 'all'; table?: string },
-	input: any,
-	selectScope: any
+	source: RelationalPlanNode,
+	selectScope: Scope
 ): Projection[] {
-	const projections: Projection[] = [];
-	const inputColumns = input.getType().columns;
-	const inputAttributes = input.getAttributes();
-
-	if (column.table) {
-		// Handle qualified SELECT table.*
-		const inputTableName = input.source?.tableSchema?.name;
-		const tableMatches = column.table.toLowerCase() === inputTableName?.toLowerCase();
-		if (!tableMatches) {
-			throw new QuereusError(
-				`Table '${column.table}' not found in FROM clause for qualified SELECT *`,
-				StatusCode.ERROR
-			);
-		}
+	const allAttributes = source.getAttributes();
+
+	// Filter by relation name if qualified (e.g., SELECT t1.*)
+	const matchingAttributes = column.table
+		? allAttributes.filter(attr =>
+			attr.relationName && attr.relationName.toLowerCase() === column.table!.toLowerCase()
+		)
+		: allAttributes;
+
+	if (column.table && matchingAttributes.length === 0) {
+		throw new QuereusError(
+			`Table '${column.table}' not found in FROM clause for qualified SELECT *`,
+			StatusCode.ERROR
+		);
 	}
 
-	// Add a projection for each column in the input relation
-	inputColumns.forEach((columnDef: any, index: number) => {
+	// Convert to projections
+	return matchingAttributes.map((attr, index) => {
 		const columnExpr: AST.ColumnExpr = {
 			type: 'column',
-			name: columnDef.name,
+			name: attr.name,
 		};
 
-		const attr = inputAttributes[index];
 		const columnRef = new ColumnReferenceNode(
 			selectScope,
 			columnExpr,
-			columnDef.type,
+			attr.type,
 			attr.id,
 			index
 		);
 
-		projections.push({
+		return {
 			node: columnRef,
-			alias: columnDef.name
-		});
+			alias: attr.name
+		};
 	});
-
-	return projections;
 }
 
 /**

package/src/planner/building/select-window.ts

@@ -43,6 +43,17 @@ export function buildWindowPhase(
 			// For now, proceed with WindowNode
 		}
 
+		// CRITICAL: Build window specification expressions using the INPUT scope
+		// This ensures expressions reference the correct input attribute IDs,
+		// not premature output attribute IDs that don't exist in the runtime context
+		const partitionExpressions = windowSpec.partitionBy.map(expr =>
+			buildExpression(selectContext, expr, false)
+		);
+
+		const orderByExpressions = windowSpec.orderBy.map(orderClause =>
+			buildExpression(selectContext, orderClause.expr, false)
+		);
+
 		// Create new WindowFunctionCallNode instances with alias information
 		const windowFuncsWithAlias = functions.map(({ func, alias }) =>
 			new WindowFunctionCallNode(
@@ -54,17 +65,9 @@ export function buildWindowPhase(
 			)
 		);
 
-		// Build expressions for window specification
-		const partitionExpressions = windowSpec.partitionBy.map(expr =>
-			buildExpression(selectContext, expr, false)
-		);
-
-		const orderByExpressions = windowSpec.orderBy.map(orderClause =>
-			buildExpression(selectContext, orderClause.expr, false)
-		);
-
 		const functionArguments = buildWindowFunctionArguments(windowFuncsWithAlias, selectContext);
 
+		// Now create the WindowNode with pre-compiled expressions
 		currentInput = new WindowNode(
 			selectContext.scope,
 			currentInput,
@@ -246,3 +249,5 @@ function compareWindowSpecs(originalWindow: any, funcWindow: any): boolean {
 		   originalOrder === funcOrder &&
 		   originalFrame === funcFrame;
 }
+
+

package/src/planner/building/select.ts

@@ -4,7 +4,7 @@ import { QuereusError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
 import type { PlanningContext } from '../planning-context.js';
 import { SingleRowNode } from '../nodes/single-row.js';
-import { buildTableScan } from './table.js';
+import { buildTableReference } from './table.js';
 import { AliasedScope } from '../scopes/aliased.js';
 import { RegisteredScope } from '../scopes/registered.js';
 import type { Scope } from '../scopes/scope.js';
@@ -14,10 +14,12 @@ import { buildExpression } from './expression.js';
 import { FilterNode } from '../nodes/filter.js';
 import { buildTableFunctionCall } from './table-function.js';
 import { CTEReferenceNode } from '../nodes/cte-reference-node.js';
+import { InternalRecursiveCTERefNode } from '../nodes/internal-recursive-cte-ref-node.js';
 import type { CTEPlanNode } from '../nodes/cte-node.js';
 import { JoinNode } from '../nodes/join-node.js';
 import { ColumnReferenceNode } from '../nodes/reference.js';
 import { ValuesNode } from '../nodes/values-node.js';
+import { createLogger } from '../../common/logger.js';
 
 // Import decomposed functionality
 import { buildWithContext } from './select-context.js';
@@ -26,16 +28,19 @@ import { analyzeSelectColumns, buildStarProjections } from './select-projections
 import { buildAggregatePhase, buildFinalAggregateProjections } from './select-aggregates.js';
 import { buildWindowPhase } from './select-window.js';
 import { buildFinalProjections, applyDistinct, applyOrderBy, applyLimitOffset } from './select-modifiers.js';
+import { SortNode, type SortKey } from '../nodes/sort.js';
 
 import { buildInsertStmt } from './insert.js';
 import { buildUpdateStmt } from './update.js';
 import { buildDeleteStmt } from './delete.js';
 
+const logger = createLogger('planner:cte');
+
 /**
  * Creates an initial logical query plan for a SELECT statement.
  *
  * For this initial version, it only supports simple "SELECT ... FROM one_table" queries,
- * effectively returning a TableScanNode for that table.
+ * effectively returning a TableReferenceNode for that table.
  *
  * @param stmt The AST.SelectStmt to plan.
  * @param ctx The parent planning context for this SELECT statement.
@@ -46,7 +51,14 @@ import { buildDeleteStmt } from './delete.js';
 export function buildSelectStmt(
   ctx: PlanningContext,
   stmt: AST.SelectStmt,
-  parentCTEs: Map<string, CTEPlanNode> = new Map()
+  parentCTEs: Map<string, CTEPlanNode> = new Map(),
+  /**
+   * Whether ProjectNodes inside this SELECT should forward all input columns that are not explicitly
+   * listed in the projection list. This is desirable for top-level queries (helps ORDER BY, window
+   * functions, etc.) but must be switched off for scalar/IN/EXISTS sub-queries which are required to
+   * expose only their declared columns.
+   */
+  preserveInputColumns: boolean = true
 ): PlanNode {
 
 	// Phase 0: Handle WITH clause if present
@@ -119,25 +131,82 @@ export function buildSelectStmt(
 		// Build final projections if needed
 		if (aggregateResult.needsFinalProjection) {
 			const finalProjections = buildFinalAggregateProjections(stmt, selectContext, aggregateResult.aggregateScope);
-			input = new ProjectNode(selectScope, input, finalProjections);
+			input = new ProjectNode(selectScope, input, finalProjections, undefined, undefined, preserveInputColumns);
 		}
 	}
 
-	// Handle window functions if present
-	input = buildWindowPhase(input, windowFunctions, selectContext, stmt);
+		// Handle window functions if present
+	if (hasWindowFunctions) {
+		// Check if ORDER BY references columns not in SELECT before applying window functions
+		let preWindowSort = false;
+		if (stmt.orderBy) {
+			const selectedColumns = new Set<string>();
+			for (const column of stmt.columns) {
+				if (column.type === 'column' && column.expr.type === 'column') {
+					selectedColumns.add(column.expr.name.toLowerCase());
+				}
+				if (column.type === 'column' && column.alias) {
+					selectedColumns.add(column.alias.toLowerCase());
+				}
+			}
+
+			// Check if ORDER BY references columns not in SELECT
+			for (const orderByClause of stmt.orderBy) {
+				if (orderByClause.expr.type === 'column') {
+					const orderColumn = orderByClause.expr.name.toLowerCase();
+					if (!selectedColumns.has(orderColumn)) {
+						// Apply ORDER BY before window projections
+						const sortKeys: SortKey[] = stmt.orderBy.map(orderBy => ({
+							expression: buildExpression(selectContext, orderBy.expr),
+							direction: orderBy.direction,
+							nulls: orderBy.nulls
+						}));
+						input = new SortNode(selectContext.scope, input, sortKeys);
+						preWindowSort = true;
+						break;
+					}
+				}
+			}
+		}
+
+		input = buildWindowPhase(input, windowFunctions, selectContext, stmt);
+
+		// Update context to include window output columns
+		const windowOutputScope = new RegisteredScope(selectContext.scope);
+		const windowAttributes = input.getAttributes();
+		input.getType().columns.forEach((col, index) => {
+			const attr = windowAttributes[index];
+			windowOutputScope.registerSymbol(col.name.toLowerCase(), (exp, s) =>
+				new ColumnReferenceNode(s, exp as AST.ColumnExpr, col.type, attr.id, index));
+		});
+
+		// Create combined scope that includes both original columns and window output
+		const combinedScope = new MultiScope([windowOutputScope, selectScope]);
+		selectContext = { ...selectContext, scope: combinedScope };
 
-	// Handle final projections for non-aggregate cases
+		// Don't apply ORDER BY again if we already did it
+		if (preWindowSort) {
+			preAggregateSort = true;
+		}
+	}
+
+	// Handle final projections for non-aggregate, non-window cases
 	if (!hasAggregates && !hasWindowFunctions) {
-		const finalResult = buildFinalProjections(input, projections, selectScope, stmt, selectContext);
+		const finalResult = buildFinalProjections(input, projections, selectScope, stmt, selectContext, preserveInputColumns);
 		input = finalResult.output;
 		selectContext = finalResult.finalContext;
 		preAggregateSort = finalResult.preAggregateSort;
-	}
 
-	// Apply final modifiers
-	input = applyDistinct(input, stmt, selectScope);
-	input = applyOrderBy(input, stmt, selectContext, preAggregateSort);
-	input = applyLimitOffset(input, stmt, selectContext);
+		// Apply final modifiers with projection scope for column alias resolution
+		input = applyDistinct(input, stmt, selectScope);
+		input = applyOrderBy(input, stmt, selectContext, preAggregateSort, finalResult.projectionScope);
+		input = applyLimitOffset(input, stmt, selectContext, finalResult.projectionScope);
+	} else {
+		// Apply final modifiers without projection scope for aggregate/window cases
+		input = applyDistinct(input, stmt, selectScope);
+		input = applyOrderBy(input, stmt, selectContext, preAggregateSort);
+		input = applyLimitOffset(input, stmt, selectContext);
+	}
 
 	return input;
 }
@@ -162,6 +231,22 @@ export function buildValuesStmt(
 	return new ValuesNode(ctx.scope, rows);
 }
 
+/**
+ * Processes a FROM clause item into a relational plan node.
+ *
+ * Handles different types of FROM items:
+ * - Table references - creates a TableReferenceNode
+ * - Subqueries - plans the subquery
+ * - Joins - builds the join structure
+ * - Table functions - creates a table function call node
+ *
+ * For a simple table reference, this calls buildTableReference which
+ * returns a TableReferenceNode for that table.
+ *
+ * @param fromClause The FROM clause AST node to process
+ * @param ctx The planning context
+ * @returns A relational plan node representing the FROM clause
+ */
 export function buildFrom(fromClause: AST.FromClause, parentContext: PlanningContext, cteNodes: Map<string, CTEPlanNode> = new Map()): RelationalPlanNode {
 	let fromTable: RelationalPlanNode;
 	let columnScope: Scope;
@@ -169,27 +254,74 @@ export function buildFrom(fromClause: AST.FromClause, parentContext: PlanningCon
 	if (fromClause.type === 'table') {
 		const tableName = fromClause.table.name.toLowerCase();
 
-		// Check if this is a CTE reference
+				// Check if this is a CTE reference
 		if (cteNodes.has(tableName)) {
 			const cteNode = cteNodes.get(tableName)!;
-			const cteRefNode = new CTEReferenceNode(parentContext.scope, cteNode, fromClause.alias);
-
-			// Create scope for CTE columns
-			const cteScope = new RegisteredScope(parentContext.scope);
-			const cteAttributes = cteNode.getAttributes();
-			cteNode.getType().columns.forEach((c, i) => {
-				const attr = cteAttributes[i];
-				cteScope.registerSymbol(c.name.toLowerCase(), (exp, s) =>
-					new ColumnReferenceNode(s, exp as AST.ColumnExpr, c.type, attr.id, i));
-			});
-
-			if (fromClause.alias) {
-				columnScope = new AliasedScope(cteScope, tableName, fromClause.alias.toLowerCase());
+
+			// Check if this is an internal recursive CTE reference
+			if (cteNode instanceof InternalRecursiveCTERefNode) {
+				// For internal recursive references, use the node directly
+				fromTable = cteNode;
+
+				// Create scope for internal recursive CTE columns
+				const internalScope = new RegisteredScope(parentContext.scope);
+				const internalAttributes = cteNode.getAttributes();
+				cteNode.getType().columns.forEach((c, i) => {
+					const attr = internalAttributes[i];
+					internalScope.registerSymbol(c.name.toLowerCase(), (exp, s) =>
+						new ColumnReferenceNode(s, exp as AST.ColumnExpr, c.type, attr.id, i));
+				});
+
+				if (fromClause.alias) {
+					columnScope = new AliasedScope(internalScope, tableName, fromClause.alias.toLowerCase());
+				} else {
+					columnScope = new AliasedScope(internalScope, tableName, tableName);
+				}
 			} else {
-				columnScope = new AliasedScope(cteScope, tableName, tableName);
-			}
+				// Regular CTE reference - cache by CTE name + alias to ensure consistent attribute IDs
+				const cacheKey = `${tableName}:${fromClause.alias || tableName}`;
+
+				// Initialize cache if not exists
+				if (!parentContext.cteReferenceCache) {
+					parentContext.cteReferenceCache = new Map();
+				}
 
-			fromTable = cteRefNode;
+				let cteRefNode: CTEReferenceNode;
+				if (parentContext.cteReferenceCache.has(cacheKey)) {
+					cteRefNode = parentContext.cteReferenceCache.get(cacheKey)!;
+					const attrs = cteRefNode.getAttributes();
+					logger(`Using cached CTE reference ${cacheKey}, attrs=[${attrs.map(a => a.id).join(',')}]`);
+				} else {
+					cteRefNode = new CTEReferenceNode(parentContext.scope, cteNode, fromClause.alias);
+					parentContext.cteReferenceCache.set(cacheKey, cteRefNode);
+					const attrs = cteRefNode.getAttributes();
+					logger(`Created new CTE reference ${cacheKey}, attrs=[${attrs.map(a => a.id).join(',')}]`);
+				}
+
+				// Create scope for CTE columns using attributes from the reference node
+				// CRITICAL: Use a closure to capture the reference node's attributes
+				// This ensures all column references use the same attribute IDs
+				const cteScope = new RegisteredScope(parentContext.scope);
+				const refAttrs = cteRefNode.getAttributes();
+				cteRefNode.getType().columns.forEach((c, i) => {
+					const attr = refAttrs[i];
+					cteScope.registerSymbol(c.name.toLowerCase(), (exp, s) => {
+						// Always use the cached reference node's attribute ID
+						return new ColumnReferenceNode(s, exp as AST.ColumnExpr, c.type, attr.id, i);
+					});
+				});
+
+				if (fromClause.alias) {
+					columnScope = new AliasedScope(cteScope, tableName, fromClause.alias.toLowerCase());
+				} else {
+					columnScope = new AliasedScope(cteScope, tableName, tableName);
+				}
+
+				// CRITICAL: Cache the reference node so later expression compilation uses the same attribute IDs
+				(columnScope as any).referenceNode = cteRefNode;
+
+				fromTable = cteRefNode;
+			}
 		} else {
 			// Check if this is a view
 			const schemaName = fromClause.table.schema || parentContext.db.schemaManager.getCurrentSchemaName();
@@ -215,7 +347,7 @@ export function buildFrom(fromClause: AST.FromClause, parentContext: PlanningCon
 				}
 			} else {
 				// Regular table
-				fromTable = buildTableScan(fromClause, parentContext);
+				fromTable = buildTableReference(fromClause, parentContext);
 
 				// Create scope for table columns
 				const tableScope = new RegisteredScope(parentContext.scope);

package/src/planner/building/table.ts

@@ -2,10 +2,7 @@ import { QuereusError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
 import type * as AST from '../../parser/ast.js';
 import { TableReferenceNode } from '../nodes/reference.js';
-import { TableScanNode } from '../nodes/scan.js';
 import type { PlanningContext } from '../planning-context.js';
-import type { IndexInfo, IndexConstraintUsage } from '../../vtab/index-info.js';
-import type { FilterInfo } from '../../vtab/filter-info.js';
 import { resolveTableSchema, resolveVtabModule } from './schema-resolution.js';
 
 /**
@@ -18,7 +15,7 @@ import { resolveTableSchema, resolveVtabModule } from './schema-resolution.js';
  */
 export function buildTableReference(fromClause: AST.FromClause, context: PlanningContext): TableReferenceNode {
 	if (fromClause.type !== 'table') {
-		throw new QuereusError('planTableScan currently only supports simple table references.', StatusCode.INTERNAL);
+		throw new QuereusError('buildTableReference currently only supports simple table references.', StatusCode.INTERNAL);
 	}
 
 	// Resolve table schema at build time
@@ -35,39 +32,3 @@ export function buildTableReference(fromClause: AST.FromClause, context: Plannin
 	);
 }
 
-/**
- * Plans a table scan operation based on a FROM clause item.
- *
- * @param fromClause The AST node representing a table in the FROM clause.
- * @param context The planning context to resolve table definitions.
- * @returns A TableScanNode for the specified table.
- * @throws {QuereusError} If the table is not found, the reference is ambiguous, or fromClause is not a simple table.
- */
-export function buildTableScan(fromClause: AST.FromClause, context: PlanningContext): TableScanNode {
-	const tableReference = buildTableReference(fromClause, context);
-
-	const defaultIndexInfo: IndexInfo = {
-		nConstraint: 0,
-		aConstraint: [],
-		nOrderBy: 0,
-		aOrderBy: [],
-		aConstraintUsage: [] as IndexConstraintUsage[],
-		idxNum: 0,
-		idxStr: 'fullscan',
-		orderByConsumed: false,
-		estimatedCost: tableReference.estimatedRows ?? 1000,
-		estimatedRows: BigInt(tableReference.estimatedRows ?? 100),
-		idxFlags: 0,
-		colUsed: 0n,
-	};
-
-	const filterInfo: FilterInfo = {
-		idxNum: 0,
-		idxStr: 'fullscan',
-		constraints: [],
-		args: [],
-		indexInfoOutput: defaultIndexInfo,
-	};
-
-	return new TableScanNode(context.scope, tableReference, filterInfo);
-}

package/src/planner/building/update.ts

@@ -2,7 +2,7 @@ import type * as AST from '../../parser/ast.js';
 import type { PlanningContext } from '../planning-context.js';
 import { UpdateNode, type UpdateAssignment } from '../nodes/update-node.js';
 import { DmlExecutorNode } from '../nodes/dml-executor-node.js';
-import { buildTableReference, buildTableScan } from './table.js';
+import { buildTableReference } from './table.js';
 import { buildExpression } from './expression.js';
 import { PlanNode, type RelationalPlanNode, type ScalarPlanNode } from '../nodes/plan-node.js';
 import { FilterNode } from '../nodes/filter.js';
@@ -12,9 +12,10 @@ import { RegisteredScope } from '../scopes/registered.js';
 import { ColumnReferenceNode } from '../nodes/reference.js';
 import { SinkNode } from '../nodes/sink-node.js';
 import { ConstraintCheckNode } from '../nodes/constraint-check-node.js';
-import { RowOp } from '../../schema/table.js';
+import { RowOpFlag } from '../../schema/table.js';
 import { ReturningNode } from '../nodes/returning-node.js';
 import { buildOldNewRowDescriptors } from '../../util/row-descriptor.js';
+import { buildConstraintChecks } from './constraint-builder.js';
 
 export function buildUpdateStmt(
   ctx: PlanningContext,
@@ -23,7 +24,7 @@ export function buildUpdateStmt(
   const tableReference = buildTableReference({ type: 'table', table: stmt.table }, ctx);
 
   // Plan the source of rows to update. This is typically the table itself, potentially filtered.
-  let sourceNode: RelationalPlanNode = buildTableScan({ type: 'table', table: stmt.table }, ctx);
+  let sourceNode: RelationalPlanNode = buildTableReference({ type: 'table', table: stmt.table }, ctx);
 
   // Create a new scope with the table columns registered for column resolution
   const tableScope = new RegisteredScope(ctx.scope);
@@ -78,6 +79,16 @@ export function buildUpdateStmt(
 
   const { oldRowDescriptor, newRowDescriptor, flatRowDescriptor } = buildOldNewRowDescriptors(oldAttributes, newAttributes);
 
+  // Build constraint checks at plan time
+  const constraintChecks = buildConstraintChecks(
+    updateCtx,
+    tableReference.tableSchema,
+    RowOpFlag.UPDATE,
+    oldAttributes,
+    newAttributes,
+    flatRowDescriptor
+  );
+
   if (stmt.returning && stmt.returning.length > 0) {
     // For RETURNING, create coordinated attribute IDs like we do for INSERT
     const returningScope = new RegisteredScope(updateCtx.scope);
@@ -205,9 +216,11 @@ export function buildUpdateStmt(
       updateCtx.scope,
       updateNodeWithDescriptor,
       tableReference,
-      RowOp.UPDATE,
+      RowOpFlag.UPDATE,
       oldRowDescriptor,
-      newRowDescriptor
+      newRowDescriptor,
+      flatRowDescriptor,
+      constraintChecks
     );
 
     const updateExecutorNode = new DmlExecutorNode(
@@ -239,9 +252,11 @@ export function buildUpdateStmt(
     updateCtx.scope,
     updateNode,
     tableReference,
-    RowOp.UPDATE,
+    RowOpFlag.UPDATE,
     oldRowDescriptor,
-    newRowDescriptor
+    newRowDescriptor,
+    flatRowDescriptor,
+    constraintChecks
   );
 
   const updateExecutorNode = new DmlExecutorNode(

package/src/planner/building/with.ts

@@ -2,6 +2,7 @@ import type * as AST from '../../parser/ast.js';
 import type { PlanningContext } from '../planning-context.js';
 import { CTENode, type CTEPlanNode } from '../nodes/cte-node.js';
 import { RecursiveCTENode } from '../nodes/recursive-cte-node.js';
+import { InternalRecursiveCTERefNode } from '../nodes/internal-recursive-cte-ref-node.js';
 import { buildSelectStmt } from './select.js';
 import type { RelationalPlanNode } from '../nodes/plan-node.js';
 import { QuereusError } from '../../common/errors.js';
@@ -151,27 +152,25 @@ function buildRecursiveCTE(
 		options?.maxRecursion
 	);
 
-	// For the recursive case, we need to create a special context where the CTE name
+		// For the recursive case, we need to create a special context where the CTE name
 	// references the working table (this will be handled at runtime)
 	const recursiveContext = { ...ctx };
 
-	// Create a temporary CTE reference for the recursive case that shares the same tableDescriptor
-	const tempCteNode = new CTENode(
+	// Create an internal recursive reference node that will look up the working table at runtime
+	const internalRefNode = new InternalRecursiveCTERefNode(
 		ctx.scope,
 		cte.name,
-		cte.columns,
-		baseCaseQuery, // Use base case as template
-		'materialized',
-		true
+		recursiveCTENode.getAttributes(),
+		recursiveCTENode.getType(),
+		recursiveCTENode.tableDescriptor
 	);
-	// Share the same tableDescriptor for runtime coordination
-	(tempCteNode as any).tableDescriptor = recursiveCTENode.tableDescriptor;
 
-	// Create a map containing the recursive CTE reference
-	const recursiveCteMap = new Map<string, CTEPlanNode>();
-	recursiveCteMap.set(cte.name.toLowerCase(), tempCteNode);
+	// Build the recursive case query with a simple replacement strategy
+	// We'll replace CTE references with the internal recursive reference during the FROM clause processing
+	const recursiveCteMap = new Map<string, any>();
+	recursiveCteMap.set(cte.name.toLowerCase(), internalRefNode);
 
-	// Build the recursive case query with the CTE map so it can find the table reference
+	// Build the recursive case query
 	const recursiveCaseQuery = buildSelectStmt(recursiveContext, recursiveCaseStmt, recursiveCteMap) as RelationalPlanNode;
 
 	// Now update the recursive CTE node with the actual recursive case query

package/src/planner/cache/correlation-detector.ts

@@ -0,0 +1,83 @@
+/**
+ * Utility to detect correlated subqueries
+ * A subquery is correlated if it references columns from outer query scopes
+ */
+
+import { isRelationalNode, type PlanNode, type RelationalPlanNode } from '../nodes/plan-node.js';
+import { PlanNodeType } from '../nodes/plan-node-type.js';
+import type { ColumnReferenceNode } from '../nodes/reference.js';
+
+/**
+ * Detects if a subquery is correlated by checking if it references any attributes
+ * that are not defined within its own scope.
+ */
+export function isCorrelatedSubquery(subqueryNode: RelationalPlanNode): boolean {
+	// Collect all attributes defined within the subquery
+	const definedAttributes = new Set<number>();
+	collectDefinedAttributes(subqueryNode, definedAttributes);
+
+	// Check if any column references use attributes not defined within the subquery
+	return hasExternalReferences(subqueryNode, definedAttributes);
+}
+
+/**
+ * Recursively collect all attributes defined by relational nodes within a subtree
+ */
+function collectDefinedAttributes(node: PlanNode, definedAttributes: Set<number>): void {
+	// If this is a relational node, add its attributes
+	const isRelational = isRelationalNode(node);
+	if (isRelational) {
+		const attributes = node.getAttributes();
+		for (const attr of attributes) {
+			definedAttributes.add(attr.id);
+		}
+	}
+
+	// Recursively process all children
+	const children = node.getChildren();
+	for (const child of children) {
+		collectDefinedAttributes(child, definedAttributes);
+	}
+
+	// Also process relational children if any
+	if (isRelational) {
+		const relations = node.getRelations();
+		for (const relation of relations) {
+			collectDefinedAttributes(relation, definedAttributes);
+		}
+	}
+}
+
+/**
+ * Check if the subtree contains any column references to attributes not in the defined set
+ */
+function hasExternalReferences(node: PlanNode, definedAttributes: Set<number>): boolean {
+	// Check if this is a column reference
+	if (node.nodeType === PlanNodeType.ColumnReference) {
+		const colRef = node as ColumnReferenceNode;
+		// If the referenced attribute is not defined within the subquery, it's an external reference
+		if (!definedAttributes.has(colRef.attributeId)) {
+			return true; // Found a correlated reference
+		}
+	}
+
+	// Check all children
+	const children = node.getChildren();
+	for (const child of children) {
+		if (hasExternalReferences(child, definedAttributes)) {
+			return true;
+		}
+	}
+
+	// Also check relational children if any
+	if (isRelationalNode(node)) {
+		const relations = node.getRelations();
+		for (const relation of relations) {
+			if (hasExternalReferences(relation, definedAttributes)) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}