@quereus/quereus 0.1.0 → 0.2.1

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

@@ -1,5 +1,5 @@
 import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type UnaryRelationalNode, type Attribute } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type UnaryRelationalNode, 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';
@@ -95,7 +95,8 @@ export class AggregateNode extends PlanNode implements UnaryRelationalNode {
         id: PlanNode.nextAttrId(),
         name,
         type: expr.getType(),
-        sourceRelation: `${this.nodeType}:${this.id}`
+        sourceRelation: `${this.nodeType}:${this.id}`,
+        relationName: 'aggregate' // AggregateNode creates new relation context
       });
     });
 
@@ -105,7 +106,8 @@ export class AggregateNode extends PlanNode implements UnaryRelationalNode {
         id: PlanNode.nextAttrId(),
         name: agg.alias,
         type: agg.expression.getType(),
-        sourceRelation: `${this.nodeType}:${this.id}`
+        sourceRelation: `${this.nodeType}:${this.id}`,
+        relationName: 'aggregate' // AggregateNode creates new relation context
       });
     });
 
@@ -139,7 +141,7 @@ export class AggregateNode 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('AggregateNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
     }
 

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

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

package/src/planner/nodes/constraint-check-node.ts

@@ -1,9 +1,15 @@
 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 ScalarPlanNode, isRelationalNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { TableReferenceNode } from './reference.js';
 import type { RelationType } from '../../common/datatype.js';
-import type { RowOp } from '../../schema/table.js';
+import type { RowOpFlag } from '../../schema/table.js';
+import type { RowConstraintSchema } from '../../schema/table.js';
+
+export interface ConstraintCheck {
+  constraint: RowConstraintSchema;  // The constraint metadata
+  expression: ScalarPlanNode;       // Pre-built expression node
+}
 
 /**
  * Represents constraint checking for DML operations.
@@ -16,9 +22,11 @@ export class ConstraintCheckNode extends PlanNode implements RelationalPlanNode
     scope: Scope,
     public readonly source: RelationalPlanNode,
     public readonly table: TableReferenceNode,
-    public readonly operation: RowOp,
-    public readonly oldRowDescriptor?: RowDescriptor,
-    public readonly newRowDescriptor?: RowDescriptor,
+    public readonly operation: RowOpFlag,
+    public readonly oldRowDescriptor: RowDescriptor | undefined,
+    public readonly newRowDescriptor: RowDescriptor | undefined,
+    public readonly flatRowDescriptor: RowDescriptor,
+    public readonly constraintChecks: ConstraintCheck[]
   ) {
     super(scope);
   }
@@ -37,26 +45,47 @@ export class ConstraintCheckNode extends PlanNode implements RelationalPlanNode
   }
 
   getChildren(): readonly PlanNode[] {
-    return [this.source];
+    const children: PlanNode[] = [this.source];
+    // Add all constraint expression nodes as children so optimizer can see them
+    this.constraintChecks.forEach(check => {
+      children.push(check.expression);
+    });
+    return children;
   }
 
   withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== 1) {
-      throw new Error(`ConstraintCheckNode expects 1 child, got ${newChildren.length}`);
+    const expectedChildren = 1 + this.constraintChecks.length;
+    if (newChildren.length !== expectedChildren) {
+      throw new Error(`ConstraintCheckNode expects ${expectedChildren} children, got ${newChildren.length}`);
     }
 
-    const [newSource] = newChildren;
+    const [newSource, ...newConstraintExprs] = newChildren;
 
-    // Type check
-    if (!('getAttributes' in newSource) || typeof (newSource as any).getAttributes !== 'function') {
-      throw new Error('ConstraintCheckNode: child must be a RelationalPlanNode');
+    // Type check the source
+    if (!isRelationalNode(newSource)) {
+      throw new Error('ConstraintCheckNode: first child must be a RelationalPlanNode');
+    }
+
+    // Type check constraint expressions
+    for (let i = 0; i < newConstraintExprs.length; i++) {
+      const expr = newConstraintExprs[i];
+      if (!('getType' in expr) || typeof (expr as any).getType !== 'function') {
+        throw new Error(`ConstraintCheckNode: constraint child ${i + 1} must be a ScalarPlanNode`);
+      }
     }
 
     // Return same instance if nothing changed
-    if (newSource === this.source) {
+    if (newSource === this.source &&
+        newConstraintExprs.every((expr, i) => expr === this.constraintChecks[i].expression)) {
       return this;
     }
 
+    // Rebuild constraint checks with new expressions
+    const newConstraintChecks = this.constraintChecks.map((check, i) => ({
+      ...check,
+      expression: newConstraintExprs[i] as ScalarPlanNode
+    }));
+
     // Create new instance
     return new ConstraintCheckNode(
       this.scope,
@@ -64,7 +93,9 @@ export class ConstraintCheckNode extends PlanNode implements RelationalPlanNode
       this.table,
       this.operation,
       this.oldRowDescriptor,
-      this.newRowDescriptor
+      this.newRowDescriptor,
+      this.flatRowDescriptor,
+      newConstraintChecks
     );
   }
 
@@ -76,7 +107,8 @@ export class ConstraintCheckNode extends PlanNode implements RelationalPlanNode
     const opName = this.operation === 1 ? 'INSERT' :
                    this.operation === 2 ? 'UPDATE' :
                    this.operation === 4 ? 'DELETE' : 'UNKNOWN';
-    return `CHECK CONSTRAINTS ON ${opName}`;
+    const constraintCount = this.constraintChecks.length;
+    return `CHECK ${constraintCount} CONSTRAINTS ON ${opName}`;
   }
 
   override getLogicalAttributes(): Record<string, unknown> {
@@ -88,6 +120,8 @@ export class ConstraintCheckNode extends PlanNode implements RelationalPlanNode
       table: this.table.tableSchema.name,
       schema: this.table.tableSchema.schemaName,
       operation: opName,
+      constraintCount: this.constraintChecks.length,
+      constraintNames: this.constraintChecks.map(c => c.constraint.name || '_unnamed'),
       hasOldDescriptor: !!this.oldRowDescriptor,
       hasNewDescriptor: !!this.newRowDescriptor,
     };

package/src/planner/nodes/create-index-node.ts

@@ -1,6 +1,6 @@
 import type * as AST from '../../parser/ast.js';
 import type { Scope } from '../scopes/scope.js';
-import { VoidNode } from './plan-node.js';
+import { PhysicalProperties, VoidNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import { expressionToString } from '../../util/ast-stringify.js';
 
@@ -34,4 +34,8 @@ export class CreateIndexNode extends VoidNode {
       statement: expressionToString(this.statementAst as any) // Convert AST to string
     };
   }
+
+	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
+		return { readonly: false };
+	}
 }

package/src/planner/nodes/create-table-node.ts

@@ -1,6 +1,6 @@
 import type * as AST from '../../parser/ast.js';
 import type { Scope } from '../scopes/scope.js';
-import { VoidNode } from './plan-node.js';
+import { PhysicalProperties, VoidNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import { expressionToString } from '../../util/ast-stringify.js';
 
@@ -28,4 +28,8 @@ export class CreateTableNode extends VoidNode {
       statement: expressionToString(this.statementAst as any) // Convert AST to string
     };
   }
+
+	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
+		return { readonly: false };
+	}
 }

package/src/planner/nodes/create-view-node.ts

@@ -1,5 +1,5 @@
 import type * as AST from '../../parser/ast.js';
-import { VoidNode } from './plan-node.js';
+import { PhysicalProperties, VoidNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
 
@@ -37,4 +37,8 @@ export class CreateViewNode extends VoidNode {
 			selectSql: this.sql
 		};
 	}
+
+	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
+		return { readonly: false };
+	}
 }

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

@@ -1,4 +1,4 @@
-import { PlanNode, type UnaryRelationalNode, type RelationalPlanNode, type Attribute, type TableDescriptor } from './plan-node.js';
+import { PlanNode, type UnaryRelationalNode, 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';
@@ -41,17 +41,27 @@ export class CTENode extends PlanNode implements CTEPlanNode {
 
 	private buildAttributes(): Attribute[] {
 		const queryAttributes = this.source.getAttributes();
-
-		// Use explicit column names if provided, otherwise use query output column names
 		const queryType = this.source.getType();
 		const columnNames = this.columns || queryType.columns.map((c: any) => c.name);
 
-		return queryAttributes.map((attr: any, index: number) => ({
-			id: PlanNode.nextAttrId(),
-			name: columnNames[index] || attr.name,
-			type: attr.type,
-			sourceRelation: `cte:${this.cteName}`
-		}));
+		return columnNames.map((name: string) => {
+			const srcAttr = queryAttributes.find(a => a.name.toLowerCase() === name.toLowerCase());
+			let resolvedType: any = srcAttr?.type;
+			if (!resolvedType) {
+				const colMeta = queryType.columns.find((c: any) => c.name.toLowerCase() === name.toLowerCase());
+				resolvedType = colMeta?.type;
+			}
+			// Fallback: generic TEXT scalar if nothing else is available (should not normally happen)
+			if (!resolvedType) {
+				resolvedType = { typeClass: 'scalar', affinity: 'TEXT', nullable: true, isReadOnly: false } as any;
+			}
+			return {
+				id: srcAttr?.id ?? PlanNode.nextAttrId(),
+				name,
+				type: resolvedType,
+				sourceRelation: `cte:${this.cteName}`
+			};
+		});
 	}
 
 	private buildType(): RelationType {
@@ -77,8 +87,8 @@ export class CTENode extends PlanNode implements CTEPlanNode {
 		return this.typeCache.value;
 	}
 
-	getChildren(): readonly [] {
-		return [];
+	getChildren(): readonly [RelationalPlanNode] {
+		return [this.source];
 	}
 
 	getRelations(): readonly [RelationalPlanNode] {
@@ -86,10 +96,31 @@ export class CTENode extends PlanNode implements CTEPlanNode {
 	}
 
 	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 0) {
-			throw new Error(`CTENode expects 0 children, got ${newChildren.length}`);
+		if (newChildren.length !== 1) {
+			throw new Error(`CTENode expects 1 child, got ${newChildren.length}`);
+		}
+
+		const [newSource] = newChildren;
+
+		// Type check
+		if (!isRelationalNode(newSource)) {
+			throw new Error('CTENode: child must be a RelationalPlanNode');
+		}
+
+		// Return same instance if nothing changed
+		if (newSource === this.source) {
+			return this;
 		}
-		return this; // No children in getChildren(), source is accessed via getRelations()
+
+		// Create new instance with updated source
+		return new CTENode(
+			this.scope,
+			this.cteName,
+			this.columns,
+			newSource as RelationalPlanNode,
+			this.materializationHint,
+			this.isRecursive
+		);
 	}
 
 	override toString(): string {

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

@@ -1,4 +1,4 @@
-import { PlanNode, type UnaryRelationalNode, type RelationalPlanNode, type Attribute } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type Attribute } 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';
@@ -9,30 +9,46 @@ import { Cached } from '../../util/cached.js';
  * Plan node for referencing a CTE in a FROM clause.
  * This points to a materialized CTE result.
  */
-export class CTEReferenceNode extends PlanNode implements UnaryRelationalNode {
+export class CTEReferenceNode extends PlanNode implements RelationalPlanNode {
 	readonly nodeType = PlanNodeType.CTEReference;
+	private static nextRefId = 1;
+	public readonly referenceId: number;
 
+	// Cache of attributes to avoid regenerating new IDs on each plan rewrite
 	private attributesCache: Cached<Attribute[]>;
 	private typeCache: Cached<RelationType>;
 
 	constructor(
 		scope: Scope,
 		public readonly source: CTEPlanNode,
-		public readonly alias?: string
+		public readonly alias?: string,
+		/**
+		 * Optionally provide an attribute list to preserve attribute IDs across
+		 * plan rewrites (e.g. when `withChildren` creates a new instance). When
+		 * omitted, a fresh list will be generated the first time it is requested.
+		 */
+		private readonly existingAttributes?: Attribute[]
 	) {
 		super(scope, 5); // Low cost since CTEs are materialized
-		this.attributesCache = new Cached(() => this.buildAttributes());
+		this.referenceId = CTEReferenceNode.nextRefId++;
+		this.attributesCache = new Cached(() => this.existingAttributes ?? this.buildAttributes());
 		this.typeCache = new Cached(() => this.buildType());
 	}
 
 	private buildAttributes(): Attribute[] {
-		// Preserve original attribute IDs from the CTE to ensure proper context resolution
-		// especially important for recursive CTEs where working table substitution occurs
+		// CRITICAL: Always create fresh attribute IDs for each CTE reference instance.
+		// Since we now cache CTEReferenceNode instances per alias in buildFrom(),
+		// each alias gets its own unique set of attribute IDs that remain consistent
+		// throughout the planning and execution phases.
+		const relationName = this.alias || this.source.cteName;
+		// Only use fresh IDs when we have an alias that differs from the CTE name
+		const useFreshIds = this.alias !== undefined && this.alias.toLowerCase() !== this.source.cteName.toLowerCase();
 		return this.source.getAttributes().map((attr: any) => ({
-			id: attr.id, // Preserve original ID instead of creating new one
+			id: useFreshIds ? PlanNode.nextAttrId() : attr.id,
 			name: attr.name,
 			type: attr.type,
-			sourceRelation: `cte_ref:${this.source.cteName}`
+			sourceRelation: `cte_ref:${this.source.cteName}`,
+			relationName
 		}));
 	}
 
@@ -59,8 +75,8 @@ export class CTEReferenceNode extends PlanNode implements UnaryRelationalNode {
 		return this.typeCache.value;
 	}
 
-	getChildren(): readonly [] {
-		return [];
+	getChildren(): readonly [CTEPlanNode] {
+		return [this.source];
 	}
 
 	getRelations(): readonly [RelationalPlanNode] {
@@ -68,10 +84,30 @@ export class CTEReferenceNode extends PlanNode implements UnaryRelationalNode {
 	}
 
 	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 0) {
-			throw new Error(`CTEReferenceNode expects 0 children, got ${newChildren.length}`);
+		if (newChildren.length !== 1) {
+			throw new Error(`CTEReferenceNode expects 1 child, got ${newChildren.length}`);
+		}
+
+		const [newSource] = newChildren;
+
+		// Type check
+		if (newSource.nodeType !== PlanNodeType.CTE && newSource.nodeType !== PlanNodeType.RecursiveCTE) {
+			throw new Error(`CTEReferenceNode: child (${newSource.nodeType}) must be a CTEPlanNode`);
 		}
-		return this; // No children in getChildren(), source is accessed via getRelations()
+
+		// Return same instance if nothing changed
+		if (newSource === this.source) {
+			return this;
+		}
+
+		// Create new instance with updated source
+		return new CTEReferenceNode(
+			this.scope,
+			newSource as CTEPlanNode,
+			this.alias,
+			// Preserve the original attribute list so IDs remain stable across rewrites
+			this.getAttributes()
+		);
 	}
 
 	override toString(): string {

package/src/planner/nodes/delete-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 { RelationType } from '../../common/datatype.js';
@@ -14,7 +14,7 @@ export class DeleteNode extends PlanNode implements RelationalPlanNode {
   constructor(
     scope: Scope,
     public readonly table: TableReferenceNode,
-    public readonly source: RelationalPlanNode, // Typically a FilterNode wrapping a TableScanNode
+    public readonly source: RelationalPlanNode, // Typically a FilterNode wrapping a TableReferenceNode
     public readonly oldRowDescriptor?: RowDescriptor, // For constraint checking
     public readonly flatRowDescriptor?: RowDescriptor,
   ) {
@@ -38,15 +38,39 @@ export class DeleteNode extends PlanNode implements RelationalPlanNode {
     return [this.source, this.table];
   }
 
-  getChildren(): readonly [] {
-    return [];
+  getChildren(): readonly PlanNode[] {
+    // 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(`DeleteNode expects 0 children, got ${newChildren.length}`);
+    if (newChildren.length !== 1) {
+      throw new Error(`DeleteNode 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('DeleteNode: child must be a RelationalPlanNode');
+    }
+
+    if (newSource === this.source) {
+      return this;
+    }
+
+    return new DeleteNode(
+      this.scope,
+      this.table,
+      newSource,
+      this.oldRowDescriptor,
+      this.flatRowDescriptor
+    );
+  }
+
+  computePhysical(): Partial<PhysicalProperties> {
+    return {
+      readonly: false,  // DELETE has side effects
+      estimatedRows: this.source.estimatedRows
+    };
   }
 
   get estimatedRows(): number | undefined {

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

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

package/src/planner/nodes/dml-executor-node.ts

@@ -1,10 +1,10 @@
 import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type RelationalPlanNode, type Attribute, type PhysicalProperties } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type Attribute, type PhysicalProperties, isRelationalNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { TableReferenceNode } from './reference.js';
 import type { RelationType } from '../../common/datatype.js';
 import type { ConflictResolution } from '../../common/constants.js';
-import { RowOp } from '../../parser/ast.js';
+import { RowOp } from '../../common/types.js';
 
 /**
  * Executes actual database insert/update/delete operations after constraint validation.
@@ -48,7 +48,7 @@ export class DmlExecutorNode extends PlanNode implements RelationalPlanNode {
     const [newSource] = newChildren;
 
     // Type check
-    if (!('getAttributes' in newSource) || typeof (newSource as any).getAttributes !== 'function') {
+    if (!isRelationalNode(newSource)) {
       throw new Error('UpdateExecutorNode: child must be a RelationalPlanNode');
     }
 

package/src/planner/nodes/drop-table-node.ts

@@ -1,5 +1,5 @@
 import type { Scope } from '../scopes/scope.js';
-import { VoidNode } from './plan-node.js';
+import { PhysicalProperties, VoidNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type * as AST from '../../parser/ast.js';
 import { expressionToString } from '../../util/ast-stringify.js';
@@ -28,4 +28,8 @@ export class DropTableNode extends VoidNode {
       statement: expressionToString(this.statementAst as any)
     };
   }
+
+	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
+		return { readonly: false };
+	}
 }

package/src/planner/nodes/drop-view-node.ts

@@ -1,4 +1,4 @@
-import { VoidNode } from './plan-node.js';
+import { PhysicalProperties, VoidNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
 
@@ -30,4 +30,8 @@ export class DropViewNode extends VoidNode {
 			ifExists: this.ifExists
 		};
 	}
+
+	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
+		return { readonly: false };
+	}
 }

package/src/planner/nodes/filter.ts

@@ -1,5 +1,5 @@
 import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type UnaryRelationalNode, type Attribute } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type UnaryRelationalNode, type Attribute, isRelationalNode, isScalarNode } 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';
@@ -69,10 +69,10 @@ export class FilterNode extends PlanNode implements UnaryRelationalNode {
 		const [newSource, newPredicate] = newChildren;
 
 		// Type check
-		if (!('getAttributes' in newSource) || typeof (newSource as any).getAttributes !== 'function') {
+		if (!isRelationalNode(newSource)) {
 			quereusError('FilterNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
 		}
-		if (!('expression' in newPredicate)) {
+		if (!isScalarNode(newPredicate)) {
 			quereusError('FilterNode: second child must be a ScalarPlanNode', StatusCode.INTERNAL);
 		}