@quereus/quereus 0.7.3 → 0.7.5

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

@@ -1,244 +0,0 @@
-import type { RelationType } from '../../common/datatype.js';
-import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type ScalarPlanNode, type ZeroAryRelationalNode, type Attribute } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import { Cached } from '../../util/cached.js';
-import { formatScalarType } from '../../util/plan-formatter.js';
-import { Row } from '../../common/types.js';
-
-/**
- * Represents a VALUES clause, producing a relation from literal rows.
- */
-export class ValuesNode extends PlanNode implements ZeroAryRelationalNode {
-  override readonly nodeType = PlanNodeType.Values;
-
-  private outputTypeCache: Cached<RelationType>;
-  private attributesCache: Cached<Attribute[]>;
-
-  constructor(
-    scope: Scope,
-    // Each inner array is a row, consisting of ScalarPlanNodes for each cell.
-    public readonly rows: ReadonlyArray<ReadonlyArray<ScalarPlanNode>>,
-    // Optional column names - if not provided, defaults to column_0, column_1, etc.
-    public readonly columnNames?: ReadonlyArray<string>,
-    estimatedCostOverride?: number,
-    /** Optional predefined attributes for preserving IDs during optimization */
-    predefinedAttributes?: Attribute[]
-  ) {
-    super(scope, estimatedCostOverride ?? rows.length * 0.01); // Small cost per row
-
-    this.outputTypeCache = new Cached(() => this.buildOutputType());
-    this.attributesCache = new Cached(() => {
-      // If predefined attributes are provided, use them (for optimization)
-      if (predefinedAttributes) {
-        return predefinedAttributes.slice(); // Return a copy
-      }
-
-      return this.buildAttributes();
-    });
-  }
-
-  private buildOutputType(): RelationType {
-    if (this.rows.length === 0) {
-      return {
-        typeClass: 'relation',
-        isReadOnly: true,
-        isSet: true,
-        columns: [],
-        keys: [],
-        rowConstraints: [],
-      };
-    }
-
-    // Infer column types from the first row
-    const firstRow = this.rows[0];
-    const columns = firstRow.map((expr, index) => ({
-      name: this.columnNames?.[index] ?? `column_${index}`,
-      type: expr.getType(),
-      generated: false,
-    }));
-
-    return {
-      typeClass: 'relation',
-      isReadOnly: true,
-      isSet: false, // VALUES can have duplicate rows
-      columns,
-      keys: [], // VALUES doesn't have inherent keys
-      rowConstraints: [],
-    };
-  }
-
-  private buildAttributes(): Attribute[] {
-    if (this.rows.length === 0) {
-      return [];
-    }
-
-    // Create attributes for each column
-    const firstRow = this.rows[0];
-    return firstRow.map((expr, index) => ({
-      id: PlanNode.nextAttrId(),
-      name: this.columnNames?.[index] ?? `column_${index}`,
-      type: expr.getType(),
-      sourceRelation: `${this.nodeType}:${this.id}`
-    }));
-  }
-
-  getType(): RelationType {
-    return this.outputTypeCache.value;
-  }
-
-  getAttributes(): Attribute[] {
-    return this.attributesCache.value;
-  }
-
-  getChildren(): readonly ScalarPlanNode[] {
-    // All expressions in all rows are children in terms of planning dependencies
-    return this.rows.flat();
-  }
-
-  getRelations(): readonly [] {
-    return [];
-  }
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    const expectedLength = this.rows.flat().length;
-    if (newChildren.length !== expectedLength) {
-      throw new Error(`ValuesNode expects ${expectedLength} children, got ${newChildren.length}`);
-    }
-
-    // Type check
-    for (const child of newChildren) {
-      if (!('expression' in child)) {
-        throw new Error('ValuesNode: all children must be ScalarPlanNodes');
-      }
-    }
-
-    // Check if anything changed
-    const flatChildren = this.rows.flat();
-    const childrenChanged = newChildren.some((child, i) => child !== flatChildren[i]);
-    if (!childrenChanged) {
-      return this;
-    }
-
-    // Rebuild the rows structure
-    const newRows: ScalarPlanNode[][] = [];
-    let childIndex = 0;
-    for (let rowIndex = 0; rowIndex < this.rows.length; rowIndex++) {
-      const rowLength = this.rows[rowIndex].length;
-      const newRow = newChildren.slice(childIndex, childIndex + rowLength) as ScalarPlanNode[];
-      newRows.push(newRow);
-      childIndex += rowLength;
-    }
-
-    // Preserve original attribute IDs to maintain column reference stability
-    const originalAttributes = this.getAttributes();
-
-    // Create new instance with preserved attributes
-    return new ValuesNode(
-      this.scope,
-      newRows,
-      this.columnNames,
-      undefined, // estimatedCostOverride
-      originalAttributes // Preserve original attribute IDs
-    );
-  }
-
-  get estimatedRows(): number {
-    return this.rows.length;
-  }
-
-  override toString(): string {
-    return `VALUES (${this.rows.length} rows)`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    if (this.rows.length === 0) {
-      return {
-        rows: [],
-        numRows: 0
-      };
-    }
-
-    const firstRow = this.rows[0];
-    return {
-      numRows: this.rows.length,
-      numColumns: firstRow.length,
-      columnTypes: firstRow.map(expr => formatScalarType(expr.getType())),
-      rows: this.rows.map(row =>
-        row.map(expr => expr.toString())
-      )
-    };
-  }
-}
-
-/**
- * Represents a table literal (collapsed const), producing a relation from literal rows.
- */
-export class TableLiteralNode extends PlanNode implements ZeroAryRelationalNode {
-	override readonly nodeType = PlanNodeType.TableLiteral;
-
-	private attributesCache: Cached<Attribute[]>;
-
-	constructor(
-		scope: Scope,
-		// Each inner array is a row, consisting of literal values for each cell.
-		public readonly rows: ReadonlyArray<Row> | AsyncIterable<Row>,
-		// The number of rows in the literal.
-		public readonly rowCount: number | undefined,
-		// The relation type defining the structure and column types
-		public readonly type: RelationType,
-	) {
-		super(scope, 0.001); // Minimal cost
-
-		this.attributesCache = new Cached(() => this.buildAttributes());
-	}
-
-	private buildAttributes(): Attribute[] {
-		return this.type.columns.map(column => ({
-			id: PlanNode.nextAttrId(),
-			name: column.name,
-			type: column.type,
-			sourceRelation: `${this.nodeType}:${this.id}`
-		}));
-	}
-
-	getType(): RelationType {
-		return this.type;
-	}
-
-	getAttributes(): Attribute[] {
-		return this.attributesCache.value;
-	}
-
-	getChildren(): readonly ScalarPlanNode[] {
-		return [];
-	}
-
-	getRelations(): readonly [] {
-		return [];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length > 0) {
-			throw new Error('TableLiteralNode does not accept children');
-		}
-		return this;
-	}
-
-	get estimatedRows(): number {
-		return this.rowCount ?? 10;
-	}
-
-	override toString(): string {
-		return `TABLE LITERAL (${this.rowCount} rows)`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		const reltype = this.getType();
-		return {
-			numRows: this.rowCount,
-			numColumns: reltype.columns.length,
-			columnTypes: reltype.columns.map(col => formatScalarType(col.type)),
-		};
-	}
-}

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

@@ -1,97 +0,0 @@
-import { PlanNode, type ZeroAryRelationalNode, 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';
-import type { ViewSchema } from '../../schema/view.js';
-import { Cached } from '../../util/cached.js';
-import { TEXT_TYPE } from '../../types/builtin-types.js';
-
-/**
- * Plan node for referencing a view in a FROM clause.
- * This expands to the view's underlying SELECT statement.
- */
-export class ViewReferenceNode extends PlanNode implements ZeroAryRelationalNode {
-	readonly nodeType = PlanNodeType.TableReference;
-
-	private attributesCache: Cached<Attribute[]>;
-	private typeCache: Cached<RelationType>;
-
-	constructor(
-		scope: Scope,
-		public readonly viewSchema: ViewSchema,
-		public readonly alias?: string
-	) {
-		super(scope, 10); // Low cost since views are just query substitution
-		this.attributesCache = new Cached(() => this.buildAttributes());
-		this.typeCache = new Cached(() => this.buildType());
-	}
-
-	private buildAttributes(): Attribute[] {
-		// For now, we'll create attributes based on the view's SELECT statement
-		// In a full implementation, this should be derived from the planned SELECT
-		// For simplicity, we'll assume the view has been planned elsewhere and use column names
-		const viewColumns = this.viewSchema.columns || [];
-		return viewColumns.map((columnName: string) => ({
-			id: PlanNode.nextAttrId(),
-			name: columnName,
-			type: {
-				typeClass: 'scalar' as const,
-				logicalType: TEXT_TYPE,
-				nullable: true,
-				isReadOnly: false
-			}, // Default type, should be inferred
-			sourceRelation: `view:${this.viewSchema.name}`
-		}));
-	}
-
-	private buildType(): RelationType {
-		return {
-			typeClass: 'relation',
-			isReadOnly: false,
-			isSet: false, // Views can contain duplicates unless they have DISTINCT
-			columns: this.getAttributes().map((attr) => ({
-				name: attr.name,
-				type: attr.type
-			})),
-			keys: [], // Views don't have inherent keys
-			rowConstraints: []
-		};
-	}
-
-	getAttributes(): Attribute[] {
-		return this.attributesCache.value;
-	}
-
-	getType(): RelationType {
-		return this.typeCache.value;
-	}
-
-	getChildren(): readonly [] {
-		return [];
-	}
-
-	getRelations(): readonly [] {
-		return [];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 0) {
-			throw new Error(`ViewReferenceNode expects 0 children, got ${newChildren.length}`);
-		}
-		return this; // No children, so no change
-	}
-
-	override toString(): string {
-		const aliasText = this.alias ? ` AS ${this.alias}` : '';
-		return `VIEW ${this.viewSchema.schemaName}.${this.viewSchema.name}${aliasText}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			viewName: this.viewSchema.name,
-			schemaName: this.viewSchema.schemaName,
-			alias: this.alias,
-			columns: this.viewSchema.columns
-		};
-	}
-}

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

@@ -1,73 +0,0 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type ZeroAryScalarNode } from './plan-node.js';
-import type { ScalarType } from '../../common/datatype.js';
-import type { Scope } from '../scopes/scope.js';
-import type { WindowFunctionExpr } from '../../parser/ast.js';
-import { Cached } from '../../util/cached.js';
-import { formatScalarType } from '../../util/plan-formatter.js';
-import { INTEGER_TYPE, REAL_TYPE } from '../../types/builtin-types.js';
-
-/**
- * Represents a window function call in the query plan.
- * Window functions are computed during window operation execution.
- */
-export class WindowFunctionCallNode extends PlanNode implements ZeroAryScalarNode {
-	override readonly nodeType = PlanNodeType.WindowFunctionCall;
-
-	private outputTypeCache: Cached<ScalarType>;
-
-	constructor(
-		scope: Scope,
-		public readonly expression: WindowFunctionExpr,
-		public readonly functionName: string,
-		public readonly isDistinct: boolean = false,
-		public readonly alias?: string,
-		estimatedCostOverride?: number
-	) {
-		super(scope, estimatedCostOverride);
-
-		this.outputTypeCache = new Cached(() => {
-			// Most window functions return numeric types
-			// row_number() specifically returns an integer
-			if (this.functionName === 'row_number') {
-				return { typeClass: 'scalar', logicalType: INTEGER_TYPE, nullable: false } satisfies ScalarType;
-			}
-			// Other window functions would have their own type inference
-			return { typeClass: 'scalar', logicalType: REAL_TYPE, nullable: false } satisfies ScalarType;
-		});
-	}
-
-	getType(): ScalarType {
-		return this.outputTypeCache.value;
-	}
-
-	getChildren(): readonly [] {
-		return [];
-	}
-
-	getRelations(): readonly [] {
-		return [];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 0) {
-			throw new Error(`WindowFunctionCallNode expects 0 children, got ${newChildren.length}`);
-		}
-		return this; // No children, so no change
-	}
-
-	override toString(): string {
-		const distinctStr = this.isDistinct ? 'DISTINCT ' : '';
-		const aliasStr = this.alias ? ` AS ${this.alias}` : '';
-		return `${this.functionName}(${distinctStr})${aliasStr}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			function: this.functionName,
-			isDistinct: this.isDistinct,
-			alias: this.alias,
-			resultType: formatScalarType(this.getType())
-		};
-	}
-}

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

@@ -1,199 +0,0 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type Attribute, type RelationalPlanNode, type UnaryRelationalNode, type ScalarPlanNode } from './plan-node.js';
-import type { WindowFunctionCallNode } from './window-function.js';
-import type { RelationType } from '../../common/datatype.js';
-import type { Scope } from '../scopes/scope.js';
-import { Cached } from '../../util/cached.js';
-import type * as AST from '../../parser/ast.js';
-
-export interface WindowSpec {
-	partitionBy: AST.Expression[];
-	orderBy: AST.OrderByClause[];
-	frame?: AST.WindowFrame;
-}
-
-/**
- * Represents a window operation that computes window functions over partitions of rows.
- * This node groups window functions that share the same window specification for efficiency.
- */
-export class WindowNode extends PlanNode implements UnaryRelationalNode {
-	override readonly nodeType = PlanNodeType.Window;
-
-	private outputTypeCache: Cached<RelationType>;
-	private attributesCache: Cached<Attribute[]>;
-
-	constructor(
-		scope: Scope,
-		public readonly source: RelationalPlanNode,
-		public readonly windowSpec: WindowSpec,
-		public readonly functions: WindowFunctionCallNode[],
-		public readonly partitionExpressions: ScalarPlanNode[],
-		public readonly orderByExpressions: ScalarPlanNode[],
-		public readonly functionArguments: (ScalarPlanNode | null)[],
-		estimatedCostOverride?: number,
-		/** Optional predefined attributes for preserving IDs during optimization */
-		public readonly predefinedAttributes?: Attribute[]
-	) {
-		super(scope, estimatedCostOverride);
-
-		this.outputTypeCache = new Cached(() => {
-			const sourceType = this.source.getType();
-
-			// Add window function columns to the source columns
-			const windowColumns = this.functions.map(func => ({
-				name: func.alias || func.functionName.toLowerCase(),
-				type: func.getType(),
-				generated: true
-			}));
-
-			return {
-				typeClass: 'relation',
-				isReadOnly: sourceType.isReadOnly,
-				isSet: sourceType.isSet, // Window functions preserve set/bag semantics
-				columns: [...sourceType.columns, ...windowColumns],
-				keys: sourceType.keys, // Window functions don't change key structure
-				rowConstraints: sourceType.rowConstraints,
-			} satisfies RelationType;
-		});
-
-		this.attributesCache = new Cached(() => {
-			// If predefined attributes are provided, use them (for optimization)
-			if (this.predefinedAttributes) {
-				return this.predefinedAttributes.slice(); // Return a copy
-			}
-
-			// Preserve source attributes and add window function attributes
-			const sourceAttrs = this.source.getAttributes();
-			const windowAttrs = this.functions.map((func) => ({
-				id: PlanNode.nextAttrId(),
-				name: func.alias || func.functionName.toLowerCase(),
-				type: func.getType(),
-				sourceRelation: `${this.nodeType}:${this.id}`
-			}));
-
-			return [...sourceAttrs, ...windowAttrs];
-		});
-	}
-
-	getType(): RelationType {
-		return this.outputTypeCache.value;
-	}
-
-	getAttributes(): Attribute[] {
-		return this.attributesCache.value;
-	}
-
-	getChildren(): readonly PlanNode[] {
-		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 = 1 + // relational source
-			this.partitionExpressions.length +
-			this.orderByExpressions.length +
-			this.functionArguments.filter(arg => arg !== null).length;
-
-		if (newChildren.length !== expectedLength) {
-			throw new Error(`WindowNode expects ${expectedLength} children, got ${newChildren.length}`);
-		}
-
-		// First child is the relational *source*.
-		const newSource = newChildren[0] as RelationalPlanNode;
-		let childIndex = 1;
-
-		// Remaining children are scalar expressions.
-		const newPartitionExpressions = newChildren.slice(childIndex, childIndex + this.partitionExpressions.length) as ScalarPlanNode[];
-		childIndex += this.partitionExpressions.length;
-
-		const newOrderByExpressions = newChildren.slice(childIndex, childIndex + this.orderByExpressions.length) as ScalarPlanNode[];
-		childIndex += this.orderByExpressions.length;
-
-		const newNonNullFunctionArgs = newChildren.slice(childIndex) as ScalarPlanNode[];
-
-		// Rebuild function arguments array preserving null positions
-		const newFunctionArguments: (ScalarPlanNode | null)[] = [];
-		let nonNullIndex = 0;
-		for (const arg of this.functionArguments) {
-			if (arg === null) {
-				newFunctionArguments.push(null);
-			} else {
-				newFunctionArguments.push(newNonNullFunctionArgs[nonNullIndex++]);
-			}
-		}
-
-		// 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 (!sourceChanged && !partitionChanged && !orderByChanged && !functionArgsChanged) {
-			return this;
-		}
-
-		// **CRITICAL**: Preserve original attribute IDs to maintain column reference stability
-		const originalAttributes = this.getAttributes();
-
-		return new WindowNode(
-			this.scope,
-			newSource,
-			this.windowSpec,
-			this.functions,
-			newPartitionExpressions,
-			newOrderByExpressions,
-			newFunctionArguments,
-			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
-		);
-	}
-
-	getRelations(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	get estimatedRows(): number | undefined {
-		return this.source.estimatedRows; // Window functions don't change row count
-	}
-
-	override toString(): string {
-		const partitionClause = this.windowSpec.partitionBy.length > 0
-			? `PARTITION BY ${this.windowSpec.partitionBy.map(_e => '...').join(', ')}`
-			: '';
-		const orderClause = this.windowSpec.orderBy.length > 0
-			? `ORDER BY ${this.windowSpec.orderBy.map(_o => '...').join(', ')}`
-			: '';
-		const clauses = [partitionClause, orderClause].filter(c => c).join(' ');
-		const funcNames = this.functions.map(f => f.functionName).join(', ');
-
-		return `WINDOW ${funcNames} OVER (${clauses})`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			windowSpec: {
-				partitionBy: this.windowSpec.partitionBy.length,
-				orderBy: this.windowSpec.orderBy.length,
-				frame: this.windowSpec.frame ? 'custom' : 'default'
-			},
-			functions: this.functions.map(f => ({
-				name: f.functionName,
-				alias: f.alias,
-				distinct: f.isDistinct
-			}))
-		};
-	}
-}