@quereus/quereus 0.1.0 → 0.2.1

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

@@ -1,5 +1,5 @@
 import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type RelationalPlanNode, type Attribute } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type Attribute, isRelationalNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { ScalarPlanNode } from './plan-node.js';
 import type { RelationType } from '../../common/datatype.js';
@@ -150,25 +150,37 @@ export class ReturningNode extends PlanNode implements RelationalPlanNode {
     return [this.executor];
   }
 
-  getChildren(): readonly ScalarPlanNode[] {
-    return this.projections.map(proj => proj.node);
+  getChildren(): readonly PlanNode[] {
+    // Return executor first, then all projection expressions
+    return [this.executor, ...this.projections.map(proj => proj.node)];
   }
 
   withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== this.projections.length) {
-      throw new Error(`ReturningNode expects ${this.projections.length} children, got ${newChildren.length}`);
+    const expectedChildren = 1 + this.projections.length; // executor + projections
+    if (newChildren.length !== expectedChildren) {
+      throw new Error(`ReturningNode expects ${expectedChildren} children, got ${newChildren.length}`);
     }
 
-    // Type check
-    for (const child of newChildren) {
-      if (!('expression' in child)) {
-        throw new Error('ReturningNode: all children must be ScalarPlanNodes');
+    const [newExecutor, ...newProjectionNodes] = newChildren;
+
+    // Type check the executor
+    if (!isRelationalNode(newExecutor)) {
+      throw new Error('ReturningNode: first child must be a RelationalPlanNode (executor)');
+    }
+
+    // Type check projection expressions
+    for (let i = 0; i < newProjectionNodes.length; i++) {
+      const expr = newProjectionNodes[i];
+      if (!('expression' in expr)) {
+        throw new Error(`ReturningNode: projection child ${i + 1} must be a ScalarPlanNode`);
       }
     }
 
     // Check if anything changed
-    const childrenChanged = newChildren.some((child, i) => child !== this.projections[i].node);
-    if (!childrenChanged) {
+    const executorChanged = newExecutor !== this.executor;
+    const projectionsChanged = newProjectionNodes.some((child, i) => child !== this.projections[i].node);
+
+    if (!executorChanged && !projectionsChanged) {
       return this;
     }
 
@@ -177,7 +189,7 @@ export class ReturningNode extends PlanNode implements RelationalPlanNode {
 
     // Create new projections with preserved attribute IDs
     const newProjections = this.projections.map((proj, i) => ({
-      node: newChildren[i] as ScalarPlanNode,
+      node: newProjectionNodes[i] as ScalarPlanNode,
       alias: proj.alias,
       attributeId: originalAttributes[i].id // Preserve original attribute ID
     }));
@@ -185,7 +197,7 @@ export class ReturningNode extends PlanNode implements RelationalPlanNode {
     // Create new instance with preserved attributes
     return new ReturningNode(
       this.scope,
-      this.executor, // Executor doesn't change via withChildren
+      newExecutor as RelationalPlanNode,
       newProjections,
       originalAttributes // Pass original attributes to preserve IDs
     );

package/src/planner/nodes/scalar.ts

@@ -1,6 +1,6 @@
 import type { ScalarType } from "../../common/datatype.js";
 import { OutputValue, SqlDataType } from "../../common/types.js";
-import { PlanNode, type ScalarPlanNode, type UnaryScalarNode, type NaryScalarNode, type ZeroAryScalarNode, type BinaryScalarNode, PhysicalProperties, type ConstantNode } from "./plan-node.js";
+import { PlanNode, type ScalarPlanNode, type UnaryScalarNode, type NaryScalarNode, type ZeroAryScalarNode, type BinaryScalarNode, PhysicalProperties, type ConstantNode, type TernaryScalarNode } from "./plan-node.js";
 import type * as AST from "../../parser/ast.js";
 import type { Scope } from "../scopes/scope.js";
 import { PlanNodeType } from "./plan-node-type.js";
@@ -150,7 +150,6 @@ export class BinaryOpNode extends PlanNode implements BinaryScalarNode {
 			case 'IS':
 			case 'IS NOT':
 			case 'IN':
-			case 'BETWEEN':
 				datatype = SqlDataType.INTEGER;
 				break;
 			case '||':
@@ -227,15 +226,28 @@ export class BinaryOpNode extends PlanNode implements BinaryScalarNode {
 
 export class LiteralNode extends PlanNode implements ZeroAryScalarNode, ConstantNode {
 	readonly nodeType = PlanNodeType.Literal;
-
+	/**
+	 * When constant folding replaces an expression with a literal, we still need to
+	 * preserve the *type metadata* (affinity, collation, nullability, etc.).
+	 *
+	 * The optional `explicitType` allows the caller to override the
+	 * automatically-derived type so that information (e.g. COLLATE NOCASE)
+	 * survives the folding pass.
+	 */
 	constructor(
 		public readonly scope: Scope,
 		public readonly expression: AST.LiteralExpr,
+		private readonly explicitType?: ScalarType,
 	) {
 		super(scope, 0.001); // Minimal cost
 	}
 
 	getType(): ScalarType {
+		// If a caller supplied an explicit type (to preserve metadata such as
+		// collation) honour it verbatim.
+		if (this.explicitType) {
+			return this.explicitType;
+		}
 		const value = this.expression.value;
 		if (value === null) {
 			return {
@@ -667,7 +679,7 @@ export class CollateNode extends PlanNode implements UnaryScalarNode {
 		public readonly expression: AST.CollateExpr,
 		public readonly operand: ScalarPlanNode,
 	) {
-		super(scope, 0); // No runtime cost - collation is metadata
+		super(scope, 0.001); // Minimal cost for COLLATE
 		this.cachedType = new Cached(this.generateType);
 	}
 
@@ -678,14 +690,9 @@ export class CollateNode extends PlanNode implements UnaryScalarNode {
 	generateType = (): ScalarType => {
 		const operandType = this.operand.getType();
 
-		// COLLATE preserves the operand type but changes the collation
 		return {
-			typeClass: 'scalar',
-			affinity: operandType.affinity,
-			nullable: operandType.nullable,
-			isReadOnly: operandType.isReadOnly,
-			datatype: operandType.datatype,
-			collationName: this.expression.collation.toUpperCase(),
+			...operandType,
+			collationName: this.expression.collation.toUpperCase()
 		};
 	}
 
@@ -734,3 +741,80 @@ export class CollateNode extends PlanNode implements UnaryScalarNode {
 		};
 	}
 }
+
+export class BetweenNode extends PlanNode implements TernaryScalarNode {
+	readonly nodeType = PlanNodeType.Between;
+
+	constructor(
+		public readonly scope: Scope,
+		public readonly expression: AST.BetweenExpr,
+		public readonly expr: ScalarPlanNode,
+		public readonly lower: ScalarPlanNode,
+		public readonly upper: ScalarPlanNode,
+	) {
+		super(scope, 0.03); // Cost for three comparisons
+	}
+
+	getType(): ScalarType {
+		// BETWEEN always returns INTEGER (0 or 1)
+		return {
+			typeClass: 'scalar',
+			affinity: SqlDataType.INTEGER,
+			nullable: false,
+			isReadOnly: true,
+			datatype: SqlDataType.INTEGER,
+		};
+	}
+
+	getChildren(): readonly [ScalarPlanNode, ScalarPlanNode, ScalarPlanNode] {
+		return [this.expr, this.lower, this.upper];
+	}
+
+	getRelations(): readonly [] {
+		return [];
+	}
+
+	withChildren(newChildren: readonly PlanNode[]): PlanNode {
+		if (newChildren.length !== 3) {
+			quereusError(`BetweenNode expects 3 children, got ${newChildren.length}`, StatusCode.INTERNAL);
+		}
+
+		const [newExpr, newLower, newUpper] = newChildren;
+
+		// Type check
+		for (const child of newChildren) {
+			if (!('expression' in child)) {
+				quereusError('BetweenNode: all children must be ScalarPlanNodes', StatusCode.INTERNAL);
+			}
+		}
+
+		// Return same instance if nothing changed
+		if (newExpr === this.expr && newLower === this.lower && newUpper === this.upper) {
+			return this;
+		}
+
+		// Create new instance
+		return new BetweenNode(
+			this.scope,
+			this.expression,
+			newExpr as ScalarPlanNode,
+			newLower as ScalarPlanNode,
+			newUpper as ScalarPlanNode
+		);
+	}
+
+	override toString(): string {
+		const notPrefix = this.expression.not ? 'NOT ' : '';
+		return `${formatExpression(this.expr)} ${notPrefix}BETWEEN ${formatExpression(this.lower)} AND ${formatExpression(this.upper)}`;
+	}
+
+	override getLogicalAttributes(): Record<string, unknown> {
+		return {
+			expr: formatExpression(this.expr),
+			lower: formatExpression(this.lower),
+			upper: formatExpression(this.upper),
+			not: this.expression.not ?? false,
+			resultType: formatScalarType(this.getType())
+		};
+	}
+}

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

@@ -1,5 +1,5 @@
 import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type Attribute, type RelationalPlanNode, type UnaryRelationalNode } from './plan-node.js';
+import { isRelationalNode, PlanNode, type Attribute, type RelationalPlanNode, type UnaryRelationalNode } from './plan-node.js';
 import type { RelationType } from '../../common/datatype.js';
 import type { Scope } from '../scopes/scope.js';
 import { Cached } from '../../util/cached.js';
@@ -79,7 +79,7 @@ export class SequencingNode extends PlanNode implements UnaryRelationalNode {
 		const [newSource] = newChildren;
 
 		// Type check
-		if (!('getAttributes' in newSource) || typeof (newSource as any).getAttributes !== 'function') {
+		if (!isRelationalNode(newSource)) {
 			throw new Error('SequencingNode: child must be a RelationalPlanNode');
 		}
 

package/src/planner/nodes/set-operation-node.ts

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

package/src/planner/nodes/single-row.ts

@@ -1,14 +1,15 @@
 import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type ZeroAryRelationalNode, type Attribute, PhysicalProperties } from './plan-node.js';
+import { PlanNode, type ZeroAryRelationalNode, type Attribute, PhysicalProperties, type ConstantNode } from './plan-node.js';
 import type { RelationType } from '../../common/datatype.js';
 import { EmptyScope } from '../scopes/empty.js';
 import type { Scope } from '../scopes/scope.js';
+import type { Row } from '../../common/types.js';
 
 /**
  * A dummy relational node that produces a single row with no columns.
  * Used as a source for SELECT statements without a FROM clause.
  */
-export class SingleRowNode extends PlanNode implements ZeroAryRelationalNode {
+export class SingleRowNode extends PlanNode implements ZeroAryRelationalNode, ConstantNode {
   override readonly nodeType = PlanNodeType.SingleRow;
 
   private static readonly singleInstance = new SingleRowNode(EmptyScope.instance); // HACK: null scope for singleton
@@ -77,4 +78,8 @@ export class SingleRowNode extends PlanNode implements ZeroAryRelationalNode {
 			constant: true,
 		};
 	}
+
+	async *getValue(): AsyncIterable<Row> {
+		yield [];
+	}
 }

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

@@ -30,15 +30,15 @@ export class SinkNode extends PlanNode {
 		};
 	}
 
-	getChildren(): readonly PlanNode[] {
-		return [];
+	getChildren(): readonly [RelationalPlanNode] {
+		return [this.source];
 	}
 
 	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 0) {
-			throw new Error(`SinkNode expects 0 children, got ${newChildren.length}`);
+		if (newChildren.length !== 1) {
+			throw new Error(`SinkNode expects 1 child, got ${newChildren.length}`);
 		}
-		return this; // No children in getChildren(), source is accessed via getRelations()
+		return new SinkNode(this.scope, newChildren[0] as RelationalPlanNode, this.operation);
 	}
 
 	getRelations(): readonly [RelationalPlanNode] {

package/src/planner/nodes/sort.ts

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

package/src/planner/nodes/stream-aggregate.ts

@@ -1,5 +1,5 @@
 import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode, type UnaryRelationalNode, type ScalarPlanNode, type PhysicalProperties, type Attribute } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type UnaryRelationalNode, type ScalarPlanNode, type PhysicalProperties, 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';
@@ -31,15 +31,19 @@ export class StreamAggregateNode extends PlanNode implements UnaryRelationalNode
 
     super(scope, estimatedCostOverride ?? (source.getTotalCost() + streamingCost));
 
+
+
     this.attributesCache = new Cached(() => this.buildAttributes());
   }
 
-  private buildAttributes(): Attribute[] {
-    // If we have preserved attribute IDs, use them
+          private buildAttributes(): Attribute[] {
+    // If we have preserved attribute IDs, use them directly
+    // The optimizer rule now passes both aggregate AND source attributes
     if (this.preserveAttributeIds) {
-      return this.preserveAttributeIds.slice(); // Return a copy
+      return this.preserveAttributeIds.slice();
     }
 
+    // Fallback: build attributes from scratch (used when not created via optimizer)
     const attributes: Attribute[] = [];
 
     // Group by columns come first
@@ -63,6 +67,18 @@ export class StreamAggregateNode extends PlanNode implements UnaryRelationalNode
       });
     });
 
+    // Add source attributes to support HAVING clauses
+    const sourceAttributes = this.source.getAttributes();
+    const existingAttrNames = new Set(attributes.map(attr => attr.name));
+
+    for (const sourceAttr of sourceAttributes) {
+      // Only add if not already present by name (avoid duplicates for GROUP BY columns)
+      if (!existingAttrNames.has(sourceAttr.name)) {
+        attributes.push(sourceAttr);
+        existingAttrNames.add(sourceAttr.name);
+      }
+    }
+
     return attributes;
   }
 
@@ -78,21 +94,44 @@ export class StreamAggregateNode extends PlanNode implements UnaryRelationalNode
   }
 
   getType(): RelationType {
-    // Same output type as logical aggregate
-    const columns = [
+    const columns = [];
+
+    // Start with preserved attributes if we have them, otherwise build GROUP BY + aggregates
+    if (this.preserveAttributeIds) {
+      // Use preserved attributes to match getAttributes() exactly
+      for (const attr of this.preserveAttributeIds) {
+        columns.push({
+          name: attr.name,
+          type: attr.type,
+          generated: false  // Source attributes are not generated
+        });
+      }
+    } else {
       // Group by columns come first
-      ...this.groupBy.map((expr, index) => ({
+      columns.push(...this.groupBy.map((expr, index) => ({
         name: this.getGroupByColumnName(expr, index),
         type: expr.getType(),
         generated: false
-      })),
+      })));
+
       // Then aggregate columns
-      ...this.aggregates.map(agg => ({
+      columns.push(...this.aggregates.map(agg => ({
         name: agg.alias,
         type: agg.expression.getType(),
         generated: true
-      }))
-    ];
+      })));
+
+      // Add all source columns to support HAVING clauses (consistent with getAttributes())
+      const sourceType = this.source.getType();
+      const existingNames = new Set(columns.map(col => col.name));
+
+      for (const sourceCol of sourceType.columns) {
+        // Only add if not already present (avoid duplicates for GROUP BY columns)
+        if (!existingNames.has(sourceCol.name)) {
+          columns.push(sourceCol);
+        }
+      }
+    }
 
     return {
       typeClass: 'relation',
@@ -109,6 +148,31 @@ export class StreamAggregateNode extends PlanNode implements UnaryRelationalNode
     return this.attributesCache.value;
   }
 
+  getProducingExprs(): Map<number, ScalarPlanNode> {
+    const attributes = this.getAttributes();
+    const map = new Map<number, ScalarPlanNode>();
+
+    // Map GROUP BY expressions to their attribute IDs
+    for (let i = 0; i < this.groupBy.length; i++) {
+      const expr = this.groupBy[i];
+      const attr = attributes[i];
+      if (attr) {
+        map.set(attr.id, expr);
+      }
+    }
+
+    // Map aggregate expressions to their attribute IDs
+    for (let i = 0; i < this.aggregates.length; i++) {
+      const agg = this.aggregates[i];
+      const attr = attributes[this.groupBy.length + i]; // Aggregates come after GROUP BY
+      if (attr) {
+        map.set(attr.id, agg.expression);
+      }
+    }
+
+    return map;
+  }
+
   getChildren(): readonly PlanNode[] {
     return [this.source, ...this.groupBy, ...this.aggregates.map(agg => agg.expression)];
   }
@@ -193,7 +257,7 @@ export class StreamAggregateNode extends PlanNode implements UnaryRelationalNode
     const newAggregateExpressions = restChildren.slice(this.groupBy.length);
 
     // Type check
-    if (!('getAttributes' in newSource) || typeof (newSource as any).getAttributes !== 'function') {
+    if (!isRelationalNode(newSource)) {
       quereusError('StreamAggregateNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
     }
 

package/src/planner/nodes/subquery.ts

@@ -7,6 +7,8 @@ import type { Scope } from "../scopes/scope.js";
 import { compareSqlValues } from "../../util/comparison.js";
 import type { Expression } from "../../parser/ast.js";
 import { formatExpression, formatScalarType } from "../../util/plan-formatter.js";
+import { quereusError } from "../../common/errors.js";
+import { StatusCode } from "../../common/types.js";
 
 export class ScalarSubqueryNode extends PlanNode implements ScalarPlanNode {
 	override readonly nodeType = PlanNodeType.ScalarSubquery;
@@ -36,8 +38,9 @@ export class ScalarSubqueryNode extends PlanNode implements ScalarPlanNode {
 		};
 	}
 
-	getChildren(): readonly [] {
-		return [];
+	getChildren(): readonly PlanNode[] {
+		// Include the subquery so the optimizer can visit it
+		return [this.subquery];
 	}
 
 	getRelations(): readonly [RelationalPlanNode] {
@@ -45,10 +48,28 @@ export class ScalarSubqueryNode extends PlanNode implements ScalarPlanNode {
 	}
 
 	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 0) {
-			throw new Error(`ScalarSubqueryNode expects 0 children, got ${newChildren.length}`);
+		if (newChildren.length !== 1) {
+			quereusError(`ScalarSubqueryNode expects 1 child, got ${newChildren.length}`, StatusCode.INTERNAL);
+		}
+
+		const [newSubquery] = newChildren;
+
+		// Type check
+		if (newSubquery.getType().typeClass !== 'relation') {
+			quereusError('ScalarSubqueryNode: child must be a RelationalPlanNode', StatusCode.INTERNAL);
+		}
+
+		// Check if anything changed
+		if (newSubquery === this.subquery) {
+			return this;
 		}
-		return this; // No children in getChildren(), subquery is accessed via getRelations()
+
+		// Create new instance
+		return new ScalarSubqueryNode(
+			this.scope,
+			this.expression,
+			newSubquery as RelationalPlanNode
+		);
 	}
 
 	override toString(): string {
@@ -89,11 +110,16 @@ export class InNode extends PlanNode implements ScalarPlanNode {
 		}
 	}
 
-	getChildren(): readonly ScalarPlanNode[] {
+	getChildren(): readonly PlanNode[] {
+		// Include condition, values (if any), and source subquery (if any)
+		const children: PlanNode[] = [this.condition];
 		if (this.values) {
-			return [this.condition, ...this.values];
+			children.push(...this.values);
 		}
-		return [this.condition];
+		if (this.source) {
+			children.push(this.source);
+		}
+		return children;
 	}
 
 	getRelations(): readonly RelationalPlanNode[] {
@@ -104,29 +130,47 @@ export class InNode extends PlanNode implements ScalarPlanNode {
 	}
 
 	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		const expectedLength = this.values ? 1 + this.values.length : 1;
+		const expectedLength = 1 + (this.values?.length ?? 0) + (this.source ? 1 : 0);
 		if (newChildren.length !== expectedLength) {
-			throw new Error(`InNode expects ${expectedLength} children, got ${newChildren.length}`);
+			quereusError(`InNode expects ${expectedLength} children, got ${newChildren.length}`, StatusCode.INTERNAL);
 		}
 
-		const [newCondition, ...newValues] = newChildren;
+		let childIndex = 0;
+		const newCondition = newChildren[childIndex++];
 
-		// Type check
-		if (!('expression' in newCondition)) {
-			throw new Error('InNode: condition must be a ScalarPlanNode');
+		// Type check condition
+		if (newCondition.getType().typeClass !== 'scalar') {
+			quereusError('InNode: condition must be a ScalarPlanNode', StatusCode.INTERNAL);
+		}
+
+		// Extract new values if they exist
+		let newValues: ScalarPlanNode[] | undefined;
+		if (this.values) {
+			newValues = [];
+			for (let i = 0; i < this.values.length; i++) {
+				const value = newChildren[childIndex++];
+				if (value.getType().typeClass !== 'scalar') {
+					quereusError('InNode: values must be ScalarPlanNodes', StatusCode.INTERNAL);
+				}
+				newValues.push(value as ScalarPlanNode);
+			}
 		}
 
-		for (const value of newValues) {
-			if (!('expression' in value)) {
-				throw new Error('InNode: values must be ScalarPlanNodes');
+		// Extract new source if it exists
+		let newSource: RelationalPlanNode | undefined;
+		if (this.source) {
+			newSource = newChildren[childIndex++] as RelationalPlanNode;
+			if (newSource.getType().typeClass !== 'relation') {
+				quereusError('InNode: source must be a RelationalPlanNode', StatusCode.INTERNAL);
 			}
 		}
 
 		// Check if anything changed
 		const conditionChanged = newCondition !== this.condition;
-		const valuesChanged = this.values && newValues.some((val, i) => val !== this.values![i]);
+		const valuesChanged = this.values && newValues && newValues.some((val, i) => val !== this.values![i]);
+		const sourceChanged = newSource !== this.source;
 
-		if (!conditionChanged && !valuesChanged) {
+		if (!conditionChanged && !valuesChanged && !sourceChanged) {
 			return this;
 		}
 
@@ -135,8 +179,8 @@ export class InNode extends PlanNode implements ScalarPlanNode {
 			this.scope,
 			this.expression,
 			newCondition as ScalarPlanNode,
-			this.source, // Source doesn't change via withChildren
-			this.values ? newValues as ScalarPlanNode[] : undefined
+			newSource,
+			newValues
 		);
 	}
 
@@ -179,19 +223,38 @@ export class ExistsNode extends PlanNode implements ScalarPlanNode {
 		};
 	}
 
-	getChildren(): readonly [] {
-		return [];
+	getChildren(): readonly PlanNode[] {
+		// Include the subquery so the optimizer can visit it
+		return [this.subquery];
 	}
 
-	getRelations(): readonly [RelationalPlanNode] {
+	getRelations(): readonly RelationalPlanNode[] {
 		return [this.subquery];
 	}
 
 	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 0) {
-			throw new Error(`ExistsNode expects 0 children, got ${newChildren.length}`);
+		if (newChildren.length !== 1) {
+			quereusError(`ExistsNode expects 1 child, got ${newChildren.length}`, StatusCode.INTERNAL);
+		}
+
+		const [newSubquery] = newChildren;
+
+		// Type check
+		if (newSubquery.getType().typeClass !== 'relation') {
+			quereusError('ExistsNode: child must be a RelationalPlanNode', StatusCode.INTERNAL);
+		}
+
+		// Check if anything changed
+		if (newSubquery === this.subquery) {
+			return this;
 		}
-		return this; // No children in getChildren(), subquery is accessed via getRelations()
+
+		// Create new instance
+		return new ExistsNode(
+			this.scope,
+			this.expression,
+			newSubquery as RelationalPlanNode
+		);
 	}
 
 	override toString(): string {