@quereus/quereus 0.1.0 → 0.2.1

package/src/planner/nodes/function.ts

@@ -1,93 +1,93 @@
-import type { ScalarType } from '../../common/datatype.js';
-import type * as AST from '../../parser/ast.js';
-import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type NaryScalarNode, type ScalarPlanNode, type PhysicalProperties } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import { formatExpressionList, formatScalarType } from '../../util/plan-formatter.js';
-import type { FunctionSchema } from '../../schema/function.js';
-import { FunctionFlags } from '../../common/constants.js';
-
-export class ScalarFunctionCallNode extends PlanNode implements NaryScalarNode {
-	override readonly nodeType = PlanNodeType.ScalarFunctionCall;
-
-	constructor(
-		scope: Scope,
-		public readonly expression: AST.FunctionExpr,
-		public readonly functionSchema: FunctionSchema,
-		public readonly operands: ScalarPlanNode[]
-	) {
-		super(scope);
-	}
-
-	getType(): ScalarType {
-		return this.functionSchema.returnType as ScalarType;
-	}
-
-	getChildren(): readonly ScalarPlanNode[] {
-		return this.operands;
-	}
-
-	getRelations(): readonly [] {
-		return [];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== this.operands.length) {
-			throw new Error(`ScalarFunctionCallNode expects ${this.operands.length} children, got ${newChildren.length}`);
-		}
-
-		// Type check
-		for (const child of newChildren) {
-			if (!('expression' in child)) {
-				throw new Error('ScalarFunctionCallNode: all children must be ScalarPlanNodes');
-			}
-		}
-
-		// Check if anything changed
-		const childrenChanged = newChildren.some((child, i) => child !== this.operands[i]);
-		if (!childrenChanged) {
-			return this;
-		}
-
-		// Create new instance
-		return new ScalarFunctionCallNode(
-			this.scope,
-			this.expression,
-			this.functionSchema,
-			newChildren as ScalarPlanNode[]
-		);
-	}
-
-	override toString(): string {
-		return `${this.expression.name}(${formatExpressionList(this.operands)})`;
-	}
-
-	override computePhysical(_childrenPhysical: PhysicalProperties[]): Partial<PhysicalProperties> {
-		// Function calls derive properties from their arguments and the function itself
-		const result: Partial<PhysicalProperties> = {};
-
-		// Use function schema to determine deterministic and readonly properties
-		const functionIsDeterministic = (this.functionSchema.flags & FunctionFlags.DETERMINISTIC) !== 0;
-		const functionIsReadonly = (this.functionSchema.returnType as ScalarType).isReadOnly ?? true;
-
-		// Function is deterministic only if both function and all arguments are deterministic
-		if (!functionIsDeterministic) {
-			result.deterministic = false;
-		}
-
-		// Function is readonly only if both function and all arguments are readonly
-		if (!functionIsReadonly) {
-			result.readonly = false;
-		}
-
-		return result;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			function: this.expression.name,
-			arguments: this.operands.map(op => op.toString()),
-			resultType: formatScalarType(this.functionSchema.returnType as ScalarType)
-		};
-	}
-}
+import type { ScalarType } from '../../common/datatype.js';
+import type * as AST from '../../parser/ast.js';
+import type { Scope } from '../scopes/scope.js';
+import { PlanNode, type NaryScalarNode, type ScalarPlanNode, type PhysicalProperties } from './plan-node.js';
+import { PlanNodeType } from './plan-node-type.js';
+import { formatExpressionList, formatScalarType } from '../../util/plan-formatter.js';
+import type { FunctionSchema } from '../../schema/function.js';
+import { FunctionFlags } from '../../common/constants.js';
+
+export class ScalarFunctionCallNode extends PlanNode implements NaryScalarNode {
+	override readonly nodeType = PlanNodeType.ScalarFunctionCall;
+
+	constructor(
+		scope: Scope,
+		public readonly expression: AST.FunctionExpr,
+		public readonly functionSchema: FunctionSchema,
+		public readonly operands: ScalarPlanNode[]
+	) {
+		super(scope);
+	}
+
+	getType(): ScalarType {
+		return this.functionSchema.returnType as ScalarType;
+	}
+
+	getChildren(): readonly ScalarPlanNode[] {
+		return this.operands;
+	}
+
+	getRelations(): readonly [] {
+		return [];
+	}
+
+	withChildren(newChildren: readonly PlanNode[]): PlanNode {
+		if (newChildren.length !== this.operands.length) {
+			throw new Error(`ScalarFunctionCallNode expects ${this.operands.length} children, got ${newChildren.length}`);
+		}
+
+		// Type check
+		for (const child of newChildren) {
+			if (!('expression' in child)) {
+				throw new Error('ScalarFunctionCallNode: all children must be ScalarPlanNodes');
+			}
+		}
+
+		// Check if anything changed
+		const childrenChanged = newChildren.some((child, i) => child !== this.operands[i]);
+		if (!childrenChanged) {
+			return this;
+		}
+
+		// Create new instance
+		return new ScalarFunctionCallNode(
+			this.scope,
+			this.expression,
+			this.functionSchema,
+			newChildren as ScalarPlanNode[]
+		);
+	}
+
+	override toString(): string {
+		return `${this.expression.name}(${formatExpressionList(this.operands)})`;
+	}
+
+	override computePhysical(_childrenPhysical: PhysicalProperties[]): Partial<PhysicalProperties> {
+		// Function calls derive properties from their arguments and the function itself
+		const result: Partial<PhysicalProperties> = {};
+
+		// Use function schema to determine deterministic and readonly properties
+		const functionIsDeterministic = (this.functionSchema.flags & FunctionFlags.DETERMINISTIC) !== 0;
+		const functionIsReadonly = (this.functionSchema.returnType as ScalarType).isReadOnly ?? true;
+
+		// Function is deterministic only if both function and all arguments are deterministic
+		if (!functionIsDeterministic) {
+			result.deterministic = false;
+		}
+
+		// Function is readonly only if both function and all arguments are readonly
+		if (!functionIsReadonly) {
+			result.readonly = false;
+		}
+
+		return result;
+	}
+
+	override getLogicalAttributes(): Record<string, unknown> {
+		return {
+			function: this.expression.name,
+			arguments: this.operands.map(op => op.toString()),
+			resultType: formatScalarType(this.functionSchema.returnType as ScalarType)
+		};
+	}
+}

package/src/planner/nodes/insert-node.ts

@@ -1,5 +1,5 @@
 import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type RelationalPlanNode, type Attribute, type RowDescriptor } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type Attribute, type RowDescriptor, type PhysicalProperties, isRelationalNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { TableReferenceNode } from './reference.js';
 import type { ColumnDef, RelationType } from '../../common/datatype.js';
@@ -67,14 +67,37 @@ export class InsertNode extends PlanNode implements RelationalPlanNode {
   }
 
   override getChildren(): readonly PlanNode[] {
-    return [];
+    // Return the source relation as a child so optimizer can traverse it
+    return [this.source];
   }
 
   withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== 0) {
-      throw new Error(`InsertNode expects 0 children, got ${newChildren.length}`);
+    if (newChildren.length !== 1) {
+      throw new Error(`InsertNode expects 1 child (source), got ${newChildren.length}`);
     }
-    return this; // No children in getChildren(), source is accessed via getRelations()
+
+    const newSource = newChildren[0] as RelationalPlanNode;
+    if (!isRelationalNode(newSource)) {
+      throw new Error('InsertNode: child must be a RelationalPlanNode');
+    }
+
+    if (newSource === this.source) {
+      return this;
+    }
+
+    return new InsertNode(
+      this.scope,
+      this.table,
+      this.targetColumns,
+      newSource,
+      this.flatRowDescriptor
+    );
+  }
+
+  computePhysical(): Partial<PhysicalProperties> {
+    return {
+      readonly: false,  // INSERT has side effects
+    };
   }
 
   override toString(): string {

package/src/planner/nodes/internal-recursive-cte-ref-node.ts

@@ -0,0 +1,76 @@
+import { ZeroAryRelationalBase, type Attribute, type TableDescriptor } from './plan-node.js';
+import type { RelationType } from '../../common/datatype.js';
+import { PlanNodeType } from './plan-node-type.js';
+import type { Scope } from '../scopes/scope.js';
+import { Cached } from '../../util/cached.js';
+
+/**
+ * Plan node for internal recursive CTE references.
+ * This represents a reference to the working table within a recursive CTE's recursive case.
+ * Unlike CTEReferenceNode, this doesn't materialize the CTE but looks up the working table
+ * from the runtime table context.
+ */
+export class InternalRecursiveCTERefNode extends ZeroAryRelationalBase {
+	readonly nodeType = PlanNodeType.InternalRecursiveCTERef;
+
+	private attributesCache: Cached<Attribute[]>;
+	private typeCache: Cached<RelationType>;
+
+	constructor(
+		scope: Scope,
+		public readonly cteName: string,
+		public readonly attributes: Attribute[],
+		public readonly relationType: RelationType,
+		public readonly workingTableDescriptor: TableDescriptor,
+		public readonly alias?: string
+	) {
+		super(scope, 0.01); // Very low cost since we're just reading from working table
+		this.attributesCache = new Cached(() => this.buildAttributes());
+		this.typeCache = new Cached(() => this.buildType());
+	}
+
+	private buildAttributes(): Attribute[] {
+		// Return the attributes as provided, with proper source relation
+		return this.attributes.map((attr: any) => ({
+			id: attr.id,
+			name: attr.name,
+			type: attr.type,
+			sourceRelation: `recursive_ref:${this.cteName}`
+		}));
+	}
+
+	private buildType(): RelationType {
+		return {
+			typeClass: 'relation',
+			isReadOnly: true, // Working table is read-only from recursive case perspective
+			isSet: this.relationType.isSet,
+			columns: this.getAttributes().map((attr: any) => ({
+				name: attr.name,
+				type: attr.type
+			})),
+			keys: [],
+			rowConstraints: []
+		};
+	}
+
+	getAttributes(): Attribute[] {
+		return this.attributesCache.value;
+	}
+
+	getType(): RelationType {
+		return this.typeCache.value;
+	}
+
+	toString(): string {
+		const aliasText = this.alias ? ` AS ${this.alias}` : '';
+		return `INTERNAL_RECURSIVE_REF ${this.cteName}${aliasText}`;
+	}
+
+	getLogicalAttributes(): Record<string, unknown> {
+		return {
+			cteName: this.cteName,
+			alias: this.alias,
+			workingTableDescriptor: this.workingTableDescriptor
+		};
+	}
+}

package/src/planner/nodes/join-node.ts

@@ -1,4 +1,4 @@
-import { PlanNode } from './plan-node.js';
+import { isRelationalNode, PlanNode } from './plan-node.js';
 import type { RelationalPlanNode, Attribute, BinaryRelationalNode, ScalarPlanNode } from './plan-node.js';
 import type { RelationType } from '../../common/datatype.js';
 import { PlanNodeType } from './plan-node-type.js';
@@ -131,10 +131,10 @@ export class JoinNode extends PlanNode implements BinaryRelationalNode {
 		const [newLeft, newRight, newCondition] = newChildren;
 
 		// Type check
-		if (!('getAttributes' in newLeft) || typeof (newLeft as any).getAttributes !== 'function') {
+		if (!isRelationalNode(newLeft)) {
 			quereusError('JoinNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
 		}
-		if (!('getAttributes' in newRight) || typeof (newRight as any).getAttributes !== 'function') {
+		if (!isRelationalNode(newRight)) {
 			quereusError('JoinNode: second child must be a RelationalPlanNode', StatusCode.INTERNAL);
 		}
 		if (newCondition && !('expression' in newCondition)) {

package/src/planner/nodes/limit-offset.ts

@@ -1,5 +1,5 @@
 import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode, type UnaryRelationalNode, type ScalarPlanNode, type Attribute } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type UnaryRelationalNode, type ScalarPlanNode, type Attribute, isRelationalNode } from './plan-node.js';
 import type { RelationType } from '../../common/datatype.js';
 import type { Scope } from '../scopes/scope.js';
 import { formatExpression } from '../../util/plan-formatter.js';
@@ -88,7 +88,7 @@ export class LimitOffsetNode extends PlanNode implements UnaryRelationalNode {
     const [newSource, ...restChildren] = newChildren;
 
     // Type check
-    if (!('getAttributes' in newSource) || typeof (newSource as any).getAttributes !== 'function') {
+    if (!isRelationalNode(newSource)) {
       quereusError('LimitOffsetNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
     }
 

package/src/planner/nodes/plan-node-type.ts

@@ -3,7 +3,6 @@ export enum PlanNodeType {
   Block = 'Block',
   TableReference = 'TableReference',
   CTEReference = 'CTEReference',
-  TableScan = 'TableScan',
   TableSeek = 'TableSeek',
   Filter = 'Filter',
   Project = 'Project',
@@ -16,6 +15,7 @@ export enum PlanNodeType {
   SetOperation = 'SetOperation',
   CTE = 'CTE',
   RecursiveCTE = 'RecursiveCTE',
+  InternalRecursiveCTERef = 'InternalRecursiveCTERef',
   In = 'In',
   Exists = 'Exists',
   Sequencing = 'Sequencing',

package/src/planner/nodes/plan-node.ts

@@ -74,6 +74,8 @@ export interface Attribute {
   type: ScalarType;
   /** Source relation that originally produced this column */
   sourceRelation?: string;
+  /** Relation name for qualified access (e.g. table name or alias) */
+  relationName?: string;
 }
 
 /**
@@ -126,7 +128,7 @@ export abstract class PlanNode {
    */
 	getRelations(): readonly RelationalPlanNode[] {
     return this.getChildren()
-    	.filter((c): c is RelationalPlanNode => 'getAttributes' in c && typeof (c as any).getAttributes === 'function');
+    	.filter(isRelationalNode);
   }
 
   /**
@@ -195,7 +197,7 @@ export abstract class PlanNode {
 					deterministic: childrenPhysical.every(child => child.deterministic),
 					idempotent: childrenPhysical.every(child => child.idempotent),
 					readonly: childrenPhysical.every(child => child.readonly),
-					constant: childrenPhysical.every(child => child.constant),
+					// constant: DON'T INHERIT - only ValueNodes can be directly constant
 				}
 				: DEFAULT_PHYSICAL;
 
@@ -269,6 +271,13 @@ export interface RelationalPlanNode extends PlanNode {
   getAttributes(): Attribute[];
 }
 
+/**
+ * Check if a node is relational (can be cached)
+ */
+export function isRelationalNode(node: PlanNode): node is RelationalPlanNode {
+	return node.getType().typeClass === 'relation';
+}
+
 /**
  * Base interface for PlanNodes that produce a scalar value (Expression Nodes).
  * Note: this is an interface that concrete ScalarNode classes will implement.
@@ -278,6 +287,13 @@ export interface ScalarPlanNode extends PlanNode {
   getType(): ScalarType;
 }
 
+/**
+ * Check if a node is a scalar node
+ */
+export function isScalarNode(node: PlanNode): node is ScalarPlanNode {
+	return node.getType().typeClass === 'scalar';
+}
+
 // --- Arity-based Base Abstractions (Interfaces, to be implemented by concrete node classes) ---
 
 /** A relational plan node that has no relational inputs (a leaf in the relational algebra tree).
@@ -322,6 +338,11 @@ export interface BinaryScalarNode extends ScalarPlanNode {
   getChildren(): readonly [ScalarPlanNode, ScalarPlanNode];
 }
 
+/** A scalar plan node that operates on three scalar inputs. */
+export interface TernaryScalarNode extends ScalarPlanNode {
+  getChildren(): readonly [ScalarPlanNode, ScalarPlanNode, ScalarPlanNode];
+}
+
 /** A scalar plan node that operates on N scalar inputs. */
 export interface NaryScalarNode extends ScalarPlanNode {
   readonly operands: ReadonlyArray<ScalarPlanNode>;
@@ -442,6 +463,22 @@ export abstract class BinaryScalarBase extends PlanNode implements BinaryScalarN
   abstract withChildren(newChildren: readonly PlanNode[]): PlanNode;
 }
 
+/**
+ * Base class for scalar nodes with three scalar inputs
+ */
+export abstract class TernaryScalarBase extends PlanNode implements TernaryScalarNode {
+  abstract readonly expression: Expression;
+  abstract getType(): ScalarType;
+  abstract getChildren(): readonly [ScalarPlanNode, ScalarPlanNode, ScalarPlanNode];
+
+  withChildren(newChildren: readonly PlanNode[]): PlanNode {
+    if (newChildren.length !== 3) {
+      quereusError(`${this.nodeType} expects 3 children, got ${newChildren.length}`);
+    }
+    return this;
+  }
+}
+
 /**
  * Base class for scalar nodes with N scalar inputs
  */

package/src/planner/nodes/project-node.ts

@@ -1,5 +1,5 @@
 import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode, type UnaryRelationalNode, type ScalarPlanNode, type Attribute } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type UnaryRelationalNode, type ScalarPlanNode, type Attribute, isRelationalNode } from './plan-node.js';
 import type { RelationType } from '../../common/datatype.js';
 import type { Scope } from '../scopes/scope.js';
 import { Cached } from '../../util/cached.js';
@@ -32,7 +32,9 @@ export class ProjectNode extends PlanNode implements UnaryRelationalNode {
 		public readonly projections: ReadonlyArray<Projection>,
 		estimatedCostOverride?: number,
 		/** Optional predefined attributes for preserving IDs during optimization */
-		predefinedAttributes?: Attribute[]
+		predefinedAttributes?: Attribute[],
+		/** Whether to preserve input columns in the output (default: true) */
+		public readonly preserveInputColumns: boolean = true
 	) {
 		super(scope, estimatedCostOverride);
 
@@ -97,35 +99,52 @@ export class ProjectNode extends PlanNode implements UnaryRelationalNode {
 			// Get the computed column names from the type
 			const outputType = this.getType();
 
-			// For each projection, preserve attribute ID if it's a simple column reference
+			// If preserveInputColumns is false, only create attributes for projections
+			if (!this.preserveInputColumns) {
+				return this.projections.map((proj, index) => ({
+					id: proj.attributeId ?? PlanNode.nextAttrId(),
+					name: outputType.columns[index].name,
+					type: proj.node.getType(),
+					sourceRelation: `${this.nodeType}:${this.id}`,
+					relationName: 'projection'
+				}));
+			}
+
+			// For each projection, preserve attribute ID for simple column references
 			return this.projections.map((proj, index) => {
-				// Check if projection has a predefined attribute ID
+				// Use predefined attribute ID if supplied (optimizer path)
 				if (proj.attributeId !== undefined) {
 					return {
 						id: proj.attributeId,
 						name: outputType.columns[index].name,
 						type: proj.node.getType(),
-						sourceRelation: `${this.nodeType}:${this.id}`
+						sourceRelation: `${this.nodeType}:${this.id}`,
+						relationName: 'projection'
 					};
 				}
 
-				// If this projection is a simple column reference, preserve its attribute ID
 				if (proj.node instanceof ColumnReferenceNode) {
+					// Always preserve the original attribute ID so that any reference
+					// to the underlying column (e.g., in ORDER BY) remains valid even
+					// after aliasing. The alias is purely a name change, not a new column.
+					const colRef = proj.node as ColumnReferenceNode;
 					return {
-						id: proj.node.attributeId,
-						name: outputType.columns[index].name, // Use the deduplicated name
-						type: proj.node.getType(),
-						sourceRelation: `${this.nodeType}:${this.id}`
-					};
-				} else {
-					// For computed expressions, generate new attribute ID
-					return {
-						id: PlanNode.nextAttrId(),
-						name: outputType.columns[index].name, // Use the deduplicated name
+						id: colRef.attributeId,
+						name: outputType.columns[index].name,
 						type: proj.node.getType(),
-						sourceRelation: `${this.nodeType}:${this.id}`
+						sourceRelation: `${this.nodeType}:${this.id}`,
+						relationName: 'projection'
 					};
 				}
+
+				// Computed expression or aliased column – generate fresh attribute ID
+				return {
+					id: PlanNode.nextAttrId(),
+					name: outputType.columns[index].name,
+					type: proj.node.getType(),
+					sourceRelation: `${this.nodeType}:${this.id}`,
+					relationName: 'projection'
+				};
 			});
 		});
 	}
@@ -189,7 +208,7 @@ export class ProjectNode extends PlanNode implements UnaryRelationalNode {
 		const [newSource, ...newProjectionNodes] = newChildren;
 
 		// Type check
-		if (!('getAttributes' in newSource) || typeof (newSource as any).getAttributes !== 'function') {
+		if (!isRelationalNode(newSource)) {
 			quereusError('ProjectNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
 		}
 
@@ -217,7 +236,8 @@ export class ProjectNode extends PlanNode implements UnaryRelationalNode {
 			newSource as RelationalPlanNode,
 			newProjections,
 			undefined, // estimatedCostOverride
-			originalAttributes // Pass original attributes to preserve IDs
+			originalAttributes, // Pass original attributes to preserve IDs
+			this.preserveInputColumns // Preserve the flag
 		);
 	}
 }

package/src/planner/nodes/recursive-cte-node.ts

@@ -1,4 +1,4 @@
-import { PlanNode, type RelationalPlanNode, type Attribute, type TableDescriptor } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type Attribute, type TableDescriptor, isRelationalNode } from './plan-node.js';
 import type { RelationType } from '../../common/datatype.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
@@ -12,7 +12,7 @@ import type { CTEPlanNode } from './cte-node.js';
 export class RecursiveCTENode extends PlanNode implements CTEPlanNode {
 	readonly nodeType = PlanNodeType.RecursiveCTE;
 	readonly isRecursive = true; // Always true for recursive CTEs
-	readonly tableDescriptor: TableDescriptor = {}; // Identity object for table context lookup
+	readonly tableDescriptor: TableDescriptor;
 
 	private attributesCache: Cached<Attribute[]>;
 	private typeCache: Cached<RelationType>;
@@ -26,10 +26,12 @@ export class RecursiveCTENode extends PlanNode implements CTEPlanNode {
 		recursiveCaseQuery: RelationalPlanNode,
 		public readonly isUnionAll: boolean,
 		public readonly materializationHint: 'materialized' | 'not_materialized' | undefined = 'materialized',
-		public readonly maxRecursion?: number
+		public readonly maxRecursion?: number,
+		tableDescriptor?: TableDescriptor
 	) {
 		super(scope, baseCaseQuery.getTotalCost() + recursiveCaseQuery.getTotalCost() + 50); // Higher cost for recursion
 		this._recursiveCaseQuery = recursiveCaseQuery;
+		this.tableDescriptor = tableDescriptor || {}; // Identity object for table context lookup
 		this.attributesCache = new Cached(() => this.buildAttributes());
 		this.typeCache = new Cached(() => this.buildType());
 	}
@@ -58,7 +60,7 @@ export class RecursiveCTENode extends PlanNode implements CTEPlanNode {
 		const columnNames = this.columns || baseCaseType.columns.map((c: any) => c.name);
 
 		return baseCaseAttributes.map((attr: any, index: number) => ({
-			id: PlanNode.nextAttrId(),
+			id: attr.id, // Preserve original attribute ID for proper context resolution
 			name: columnNames[index] || attr.name,
 			type: attr.type,
 			sourceRelation: `recursive_cte:${this.cteName}`
@@ -87,8 +89,8 @@ export class RecursiveCTENode extends PlanNode implements CTEPlanNode {
 		return this.typeCache.value;
 	}
 
-	getChildren(): readonly [] {
-		return [];
+	getChildren(): readonly [RelationalPlanNode, RelationalPlanNode] {
+		return [this.baseCaseQuery, this.recursiveCaseQuery];
 	}
 
 	// For recursive CTEs, we consider the base case as the primary source
@@ -101,10 +103,36 @@ export class RecursiveCTENode extends PlanNode implements CTEPlanNode {
 	}
 
 	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 0) {
-			throw new Error(`RecursiveCTENode expects 0 children, got ${newChildren.length}`);
+		if (newChildren.length !== 2) {
+			throw new Error(`RecursiveCTENode expects 2 children, got ${newChildren.length}`);
 		}
-		return this; // No children in getChildren(), sources are accessed via getRelations()
+
+		const [newBaseCaseQuery, newRecursiveCaseQuery] = newChildren;
+
+		// Type check
+		if (!isRelationalNode(newBaseCaseQuery) || !isRelationalNode(newRecursiveCaseQuery)) {
+			throw new Error('RecursiveCTENode: children must be RelationalPlanNodes');
+		}
+
+		// Return same instance if nothing changed
+		if (newBaseCaseQuery === this.baseCaseQuery && newRecursiveCaseQuery === this.recursiveCaseQuery) {
+			return this;
+		}
+
+		// Create new instance with updated children
+		const newNode = new RecursiveCTENode(
+			this.scope,
+			this.cteName,
+			this.columns,
+			newBaseCaseQuery as RelationalPlanNode,
+			newRecursiveCaseQuery as RelationalPlanNode,
+			this.isUnionAll,
+			this.materializationHint,
+			this.maxRecursion,
+			this.tableDescriptor
+		);
+
+		return newNode;
 	}
 
 	override toString(): string {

package/src/planner/nodes/reference.ts

@@ -41,7 +41,8 @@ export class TableReferenceNode extends PlanNode implements ZeroAryRelationalNod
 					isReadOnly: false,
 					collationName: column.collation
 				},
-				sourceRelation: `${this.tableSchema.schemaName}.${this.tableSchema.name}`
+				sourceRelation: `${this.tableSchema.schemaName}.${this.tableSchema.name}`,
+				relationName: this.tableSchema.name
 			}));
 		});
 	}
@@ -108,7 +109,8 @@ export class TableFunctionReferenceNode extends PlanNode implements ZeroAryRelat
 					id: PlanNode.nextAttrId(),
 					name: column.name,
 					type: column.type,
-					sourceRelation: `${this.functionSchema.name}()`
+					sourceRelation: `${this.functionSchema.name}()`,
+					relationName: this.functionSchema.name
 				}));
 			}
 			return [];