@quereus/quereus 0.1.0 → 0.2.1

package/src/planner/nodes/{physical-access-nodes.ts → table-access-nodes.ts}

@@ -1,6 +1,6 @@
 /**
-* Physical table access nodes for seek and range scan operations
- * These replace logical TableScanNode during optimization
+ * Physical table access nodes for seek and range scan operations
+ * These replace logical TableReferenceNode during optimization
  */
 
 import { PlanNodeType } from './plan-node-type.js';
@@ -16,7 +16,7 @@ import type { ScalarPlanNode } from './plan-node.js';
  * Base class for physical table access operations
  * Provides common functionality for sequential scan, index scan, and index seek
  */
-export abstract class PhysicalTableAccessNode extends PlanNode implements UnaryRelationalNode {
+export abstract class TableAccessNode extends PlanNode implements UnaryRelationalNode {
 	private attributesCache: Cached<Attribute[]>;
 	private outputType: Cached<RelationType>;
 
@@ -88,7 +88,7 @@ export abstract class PhysicalTableAccessNode extends PlanNode implements UnaryR
  * Sequential scan - reads entire table without using indexes
  * Used when no suitable index exists or for small tables
  */
-export class SeqScanNode extends PhysicalTableAccessNode {
+export class SeqScanNode extends TableAccessNode {
 	override readonly nodeType = PlanNodeType.SeqScan;
 
 	computePhysical(): Partial<PhysicalProperties> {
@@ -134,7 +134,7 @@ export class SeqScanNode extends PhysicalTableAccessNode {
  * Index scan - uses an index to read table data in order
  * Provides ordering and can handle range queries efficiently
  */
-export class IndexScanNode extends PhysicalTableAccessNode {
+export class IndexScanNode extends TableAccessNode {
 	override readonly nodeType = PlanNodeType.IndexScan;
 
 	constructor(
@@ -204,7 +204,7 @@ export class IndexScanNode extends PhysicalTableAccessNode {
  * Index seek - point lookup or tight range using an index
  * Very efficient for equality constraints and small ranges
  */
-export class IndexSeekNode extends PhysicalTableAccessNode {
+export class IndexSeekNode extends TableAccessNode {
 	override readonly nodeType = PlanNodeType.IndexSeek;
 
 	constructor(

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

@@ -1,6 +1,6 @@
 import type * as AST from '../../parser/ast.js';
 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, isRelationalNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { TableReferenceNode } from './reference.js';
 import type { ScalarPlanNode } from './plan-node.js';
@@ -8,6 +8,7 @@ import type { ConflictResolution } from '../../common/constants.js';
 import type { RelationType } from '../../common/datatype.js';
 import { formatExpression } from '../../util/plan-formatter.js';
 import { buildAttributesFromFlatDescriptor } from '../../util/row-descriptor.js';
+import type { PhysicalProperties } from './plan-node.js';
 
 export interface UpdateAssignment {
   targetColumn: AST.ColumnExpr; // Could be resolved ColumnReferenceNode or just index
@@ -24,7 +25,7 @@ export class UpdateNode extends PlanNode implements RelationalPlanNode {
     scope: Scope,
     public readonly table: TableReferenceNode,
     public readonly assignments: ReadonlyArray<UpdateAssignment>,
-    public readonly source: RelationalPlanNode, // Typically a FilterNode wrapping a TableScanNode
+    		public readonly source: RelationalPlanNode, // Typically a FilterNode wrapping a TableReferenceNode
 		public readonly onConflict: ConflictResolution | undefined,
     public readonly oldRowDescriptor: RowDescriptor, // For constraint checking
     public readonly newRowDescriptor: RowDescriptor, // For constraint checking
@@ -46,32 +47,43 @@ export class UpdateNode extends PlanNode implements RelationalPlanNode {
     return [this.source, this.table];
   }
 
-  getChildren(): readonly ScalarPlanNode[] {
-    return this.assignments.map(a => a.value);
+  getChildren(): readonly PlanNode[] {
+    // Return ALL child nodes: the source relation and the scalar assignment values
+    return [this.source, ...this.assignments.map(a => a.value)];
   }
 
   withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== this.assignments.length) {
-      throw new Error(`UpdateNode expects ${this.assignments.length} children, got ${newChildren.length}`);
+    const expectedChildCount = 1 + this.assignments.length; // source + assignment values
+    if (newChildren.length !== expectedChildCount) {
+      throw new Error(`UpdateNode expects ${expectedChildCount} children (1 source + ${this.assignments.length} assignments), got ${newChildren.length}`);
     }
 
-    // Type check
-    for (const child of newChildren) {
+    // First child is the source
+    const newSource = newChildren[0] as RelationalPlanNode;
+    if (!isRelationalNode(newSource)) {
+      throw new Error('UpdateNode: first child must be a RelationalPlanNode (source)');
+    }
+
+    // Remaining children are assignment values
+    const newAssignmentValues = newChildren.slice(1);
+    for (const child of newAssignmentValues) {
       if (!('expression' in child)) {
-        throw new Error('UpdateNode: all children must be ScalarPlanNodes');
+        throw new Error('UpdateNode: assignment children must be ScalarPlanNodes');
       }
     }
 
     // Check if anything changed
-    const childrenChanged = newChildren.some((child, i) => child !== this.assignments[i].value);
-    if (!childrenChanged) {
+    const sourceChanged = newSource !== this.source;
+    const assignmentsChanged = newAssignmentValues.some((child, i) => child !== this.assignments[i].value);
+
+    if (!sourceChanged && !assignmentsChanged) {
       return this;
     }
 
     // Create new assignments with updated values
     const newAssignments = this.assignments.map((assignment, i) => ({
       targetColumn: assignment.targetColumn,
-      value: newChildren[i] as ScalarPlanNode
+      value: newAssignmentValues[i] as ScalarPlanNode
     }));
 
     // Create new instance
@@ -79,7 +91,7 @@ export class UpdateNode extends PlanNode implements RelationalPlanNode {
       this.scope,
       this.table,
       newAssignments,
-      this.source, // Source doesn't change via withChildren
+      newSource,
       this.onConflict,
       this.oldRowDescriptor,
       this.newRowDescriptor,
@@ -87,6 +99,12 @@ export class UpdateNode extends PlanNode implements RelationalPlanNode {
     );
   }
 
+  computePhysical(): Partial<PhysicalProperties> {
+    return {
+      readonly: false,  // UPDATE has side effects
+    };
+  }
+
   get estimatedRows(): number | undefined {
     return this.source.estimatedRows;
   }

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

@@ -84,16 +84,23 @@ export class WindowNode extends PlanNode implements UnaryRelationalNode {
 	}
 
 	getChildren(): readonly PlanNode[] {
-		// Return all scalar expressions: partition expressions, order by expressions, and function arguments
-		const children: PlanNode[] = [];
-		children.push(...this.partitionExpressions);
-		children.push(...this.orderByExpressions);
-		children.push(...this.functionArguments.filter(arg => arg !== null) as ScalarPlanNode[]);
-		return children;
+		return [
+			// Include *both* the relational source and all scalar expression children so
+			// that generic optimizer passes (e.g. access-path selection) can traverse
+			// into the relational subtree.
+			this.source,
+
+			// Scalar expressions: partition expressions, order-by expressions, and
+			// any non-null function arguments
+			...this.partitionExpressions,
+			...this.orderByExpressions,
+			...this.functionArguments.filter(arg => arg !== null) as ScalarPlanNode[]
+		];
 	}
 
 	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		const expectedLength = this.partitionExpressions.length +
+		const expectedLength = 1 + // relational source
+			this.partitionExpressions.length +
 			this.orderByExpressions.length +
 			this.functionArguments.filter(arg => arg !== null).length;
 
@@ -101,15 +108,11 @@ export class WindowNode extends PlanNode implements UnaryRelationalNode {
 			throw new Error(`WindowNode expects ${expectedLength} children, got ${newChildren.length}`);
 		}
 
-		// Type check
-		for (const child of newChildren) {
-			if (!('expression' in child)) {
-				throw new Error('WindowNode: all children must be ScalarPlanNodes');
-			}
-		}
+		// First child is the relational *source*.
+		const newSource = newChildren[0] as RelationalPlanNode;
+		let childIndex = 1;
 
-		// Split children back into their respective arrays
-		let childIndex = 0;
+		// Remaining children are scalar expressions.
 		const newPartitionExpressions = newChildren.slice(childIndex, childIndex + this.partitionExpressions.length) as ScalarPlanNode[];
 		childIndex += this.partitionExpressions.length;
 
@@ -129,29 +132,32 @@ export class WindowNode extends PlanNode implements UnaryRelationalNode {
 			}
 		}
 
-		// Check if anything changed
+		// Detect changes
+		const sourceChanged = newSource !== this.source;
 		const partitionChanged = newPartitionExpressions.some((expr, i) => expr !== this.partitionExpressions[i]);
 		const orderByChanged = newOrderByExpressions.some((expr, i) => expr !== this.orderByExpressions[i]);
 		const functionArgsChanged = newFunctionArguments.some((arg, i) => arg !== this.functionArguments[i]);
 
-		if (!partitionChanged && !orderByChanged && !functionArgsChanged) {
+		if (!sourceChanged && !partitionChanged && !orderByChanged && !functionArgsChanged) {
 			return this;
 		}
 
 		// **CRITICAL**: Preserve original attribute IDs to maintain column reference stability
 		const originalAttributes = this.getAttributes();
 
-		// Create new instance with preserved attributes
 		return new WindowNode(
 			this.scope,
-			this.source, // Source doesn't change via withChildren
+			newSource,
 			this.windowSpec,
-			this.functions, // Functions don't change via withChildren
+			this.functions,
 			newPartitionExpressions,
 			newOrderByExpressions,
 			newFunctionArguments,
-			undefined, // estimatedCostOverride
-			originalAttributes // Preserve original attribute IDs
+			undefined,
+			// Preserve attributes only when the source is unchanged so that column IDs
+			// stay consistent. If the source relation changed, let the WindowNode rebuild
+			// its attribute list so that descriptors match the new underlying schema.
+			sourceChanged ? undefined : originalAttributes
 		);
 	}