@quereus/quereus 0.1.0

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

@@ -0,0 +1,225 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode, type RelationalPlanNode, type UnaryRelationalNode, type ScalarPlanNode, type PhysicalProperties, type Attribute } from './plan-node.js';
+import type { RelationType } from '../../common/datatype.js';
+import type { Scope } from '../scopes/scope.js';
+import { Cached } from '../../util/cached.js';
+import { formatExpressionList } from '../../util/plan-formatter.js';
+import { quereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+
+/**
+ * Physical node representing a streaming aggregate operation.
+ * Requires input to be ordered by grouping columns.
+ */
+export class StreamAggregateNode extends PlanNode implements UnaryRelationalNode {
+  override readonly nodeType = PlanNodeType.StreamAggregate;
+
+  private attributesCache: Cached<Attribute[]>;
+
+  constructor(
+    scope: Scope,
+    public readonly source: RelationalPlanNode,
+    public readonly groupBy: readonly ScalarPlanNode[],
+    public readonly aggregates: readonly { expression: ScalarPlanNode; alias: string }[],
+    estimatedCostOverride?: number,
+    public readonly preserveAttributeIds?: readonly Attribute[]
+  ) {
+    // Streaming aggregation is cheaper than hash aggregation
+    // Cost is linear in the number of input rows
+    const sourceRows = source.estimatedRows ?? 1000;
+    const streamingCost = sourceRows * 0.1; // Lower cost multiplier for streaming
+
+    super(scope, estimatedCostOverride ?? (source.getTotalCost() + streamingCost));
+
+    this.attributesCache = new Cached(() => this.buildAttributes());
+  }
+
+  private buildAttributes(): Attribute[] {
+    // If we have preserved attribute IDs, use them
+    if (this.preserveAttributeIds) {
+      return this.preserveAttributeIds.slice(); // Return a copy
+    }
+
+    const attributes: Attribute[] = [];
+
+    // Group by columns come first
+    this.groupBy.forEach((expr, index) => {
+      const name = this.getGroupByColumnName(expr, index);
+      attributes.push({
+        id: PlanNode.nextAttrId(),
+        name,
+        type: expr.getType(),
+        sourceRelation: `${this.nodeType}:${this.id}`
+      });
+    });
+
+    // Then aggregate columns
+    this.aggregates.forEach((agg) => {
+      attributes.push({
+        id: PlanNode.nextAttrId(),
+        name: agg.alias,
+        type: agg.expression.getType(),
+        sourceRelation: `${this.nodeType}:${this.id}`
+      });
+    });
+
+    return attributes;
+  }
+
+  // Helper function to extract a meaningful name from a GROUP BY expression
+  private getGroupByColumnName(expr: ScalarPlanNode, index: number): string {
+    // If it's a column reference, use the column name
+    if (expr.nodeType === PlanNodeType.ColumnReference) {
+      const colRef = expr as any; // ColumnReferenceNode
+      return colRef.expression.name;
+    }
+    // Otherwise, use a generic name
+    return `group_${index}`;
+  }
+
+  getType(): RelationType {
+    // Same output type as logical aggregate
+    const columns = [
+      // Group by columns come first
+      ...this.groupBy.map((expr, index) => ({
+        name: this.getGroupByColumnName(expr, index),
+        type: expr.getType(),
+        generated: false
+      })),
+      // Then aggregate columns
+      ...this.aggregates.map(agg => ({
+        name: agg.alias,
+        type: agg.expression.getType(),
+        generated: true
+      }))
+    ];
+
+    return {
+      typeClass: 'relation',
+      columns,
+			// TODO: Infer keys based on DISTINCT and projection's effect on input keys
+      keys: [], // No keys for aggregate results
+      rowConstraints: [],
+      isReadOnly: true,
+      isSet: true // Aggregates produce sets (one row per unique group)
+    };
+  }
+
+  getAttributes(): Attribute[] {
+    return this.attributesCache.value;
+  }
+
+  getChildren(): readonly PlanNode[] {
+    return [this.source, ...this.groupBy, ...this.aggregates.map(agg => agg.expression)];
+  }
+
+  getRelations(): readonly [RelationalPlanNode] {
+    return [this.source];
+  }
+
+  get estimatedRows(): number | undefined {
+    const sourceRows = this.source.estimatedRows;
+    if (sourceRows === undefined) return undefined;
+
+    if (this.groupBy.length > 0) {
+      // For streaming aggregate, we assume groups are somewhat clustered
+      // so we estimate fewer groups than hash aggregate would
+      return Math.max(1, Math.floor(sourceRows / 10));
+    } else {
+      // No GROUP BY means single output row
+      return 1;
+    }
+  }
+
+  computePhysical(_childrenPhysical: PhysicalProperties[]): Partial<PhysicalProperties> {
+    return {
+      estimatedRows: this.estimatedRows,
+      // Stream aggregate preserves ordering on GROUP BY columns
+      ordering: this.groupBy.length > 0 ?
+        this.groupBy.map((_, idx) => ({ column: idx, desc: false })) :
+        undefined,
+      // Aggregation creates unique keys on GROUP BY columns
+      uniqueKeys: this.groupBy.length > 0 ?
+        [this.groupBy.map((_, idx) => idx)] :
+        [[]], // Single row if no GROUP BY
+    };
+  }
+
+  override toString(): string {
+    const parts: string[] = [];
+
+    if (this.groupBy.length > 0) {
+      parts.push(`GROUP BY ${formatExpressionList(this.groupBy)}`);
+    }
+
+    if (this.aggregates.length > 0) {
+      const aggregatesStr = this.aggregates.map(agg =>
+        `${agg.expression.toString()} AS ${agg.alias}`
+      ).join(', ');
+      parts.push(`STREAM AGG ${aggregatesStr}`);
+    }
+
+    return parts.join('  ');
+  }
+
+  override getLogicalAttributes(): Record<string, unknown> {
+    const props: Record<string, unknown> = {
+      implementation: 'streaming',
+      requiresOrdering: true
+    };
+
+    if (this.groupBy.length > 0) {
+      props.groupBy = this.groupBy.map(expr => expr.toString());
+    }
+
+    if (this.aggregates.length > 0) {
+      props.aggregates = this.aggregates.map(agg => ({
+        expression: agg.expression.toString(),
+        alias: agg.alias
+      }));
+    }
+
+    return props;
+  }
+
+  withChildren(newChildren: readonly PlanNode[]): PlanNode {
+    const expectedLength = 1 + this.groupBy.length + this.aggregates.length;
+    if (newChildren.length !== expectedLength) {
+      quereusError(`StreamAggregateNode expects ${expectedLength} children, got ${newChildren.length}`, StatusCode.INTERNAL);
+    }
+
+    const [newSource, ...restChildren] = newChildren;
+    const newGroupBy = restChildren.slice(0, this.groupBy.length);
+    const newAggregateExpressions = restChildren.slice(this.groupBy.length);
+
+    // Type check
+    if (!('getAttributes' in newSource) || typeof (newSource as any).getAttributes !== 'function') {
+      quereusError('StreamAggregateNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
+    }
+
+    // Check if anything changed
+    const sourceChanged = newSource !== this.source;
+    const groupByChanged = newGroupBy.some((expr, i) => expr !== this.groupBy[i]);
+    const aggregatesChanged = newAggregateExpressions.some((expr, i) => expr !== this.aggregates[i].expression);
+
+    if (!sourceChanged && !groupByChanged && !aggregatesChanged) {
+      return this;
+    }
+
+    // Build new aggregates array
+    const newAggregates = newAggregateExpressions.map((expr, i) => ({
+      expression: expr as ScalarPlanNode,
+      alias: this.aggregates[i].alias
+    }));
+
+    // Create new instance preserving attribute IDs if they were preserved originally
+    return new StreamAggregateNode(
+      this.scope,
+      newSource as RelationalPlanNode,
+      newGroupBy as ScalarPlanNode[],
+      newAggregates,
+      undefined, // Let it recalculate cost
+      this.preserveAttributeIds // Preserve the original attribute IDs
+    );
+  }
+}

package/src/planner/nodes/subquery.ts

@@ -0,0 +1,207 @@
+import { PlanNode, type ScalarPlanNode } from "./plan-node.js";
+import type { ScalarType } from "../../common/datatype.js";
+import type { RelationalPlanNode } from "./plan-node.js";
+import { type CompareFn, SqlDataType } from "../../common/types.js";
+import { PlanNodeType } from "./plan-node-type.js";
+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";
+
+export class ScalarSubqueryNode extends PlanNode implements ScalarPlanNode {
+	override readonly nodeType = PlanNodeType.ScalarSubquery;
+
+	constructor(
+		readonly scope: Scope,
+		readonly expression: Expression, // The original SubqueryExpr AST node
+		readonly subquery: RelationalPlanNode,
+	) {
+		super(scope);
+	}
+
+	getType(): ScalarType {
+		// Scalar subqueries produce a single value, type depends on the subquery's first column
+		const subqueryType = this.subquery.getType();
+		if (subqueryType.typeClass === 'relation' && subqueryType.columns.length > 0) {
+			const firstColumn = subqueryType.columns[0];
+			return firstColumn.type;
+		}
+		// Fallback to nullable BLOB if we can't determine type
+		return {
+			typeClass: 'scalar',
+			affinity: SqlDataType.BLOB,
+			nullable: true,
+			isReadOnly: true,
+			datatype: SqlDataType.BLOB,
+		};
+	}
+
+	getChildren(): readonly [] {
+		return [];
+	}
+
+	getRelations(): readonly [RelationalPlanNode] {
+		return [this.subquery];
+	}
+
+	withChildren(newChildren: readonly PlanNode[]): PlanNode {
+		if (newChildren.length !== 0) {
+			throw new Error(`ScalarSubqueryNode expects 0 children, got ${newChildren.length}`);
+		}
+		return this; // No children in getChildren(), subquery is accessed via getRelations()
+	}
+
+	override toString(): string {
+		return `(subquery)`;
+	}
+
+	override getLogicalAttributes(): Record<string, unknown> {
+		return {
+			subqueryType: 'scalar',
+			resultType: formatScalarType(this.getType()),
+		};
+	}
+}
+
+export class InNode extends PlanNode implements ScalarPlanNode {
+	override readonly nodeType = PlanNodeType.In;
+
+	public readonly comparator: CompareFn;
+
+	constructor(
+		readonly scope: Scope,
+		readonly expression: Expression, // The original InExpr AST node
+		readonly condition: ScalarPlanNode,
+		readonly source?: RelationalPlanNode,  // For IN subquery
+		readonly values?: ScalarPlanNode[],    // For IN value list
+	) {
+		super(scope);
+		this.comparator = (a, b) => compareSqlValues(a, b);
+	}
+
+	getType(): ScalarType {
+		return {
+			typeClass: 'scalar',
+			affinity: SqlDataType.INTEGER,
+			nullable: false,
+			isReadOnly: true,
+			datatype: SqlDataType.INTEGER,
+		}
+	}
+
+	getChildren(): readonly ScalarPlanNode[] {
+		if (this.values) {
+			return [this.condition, ...this.values];
+		}
+		return [this.condition];
+	}
+
+	getRelations(): readonly RelationalPlanNode[] {
+		if (this.source) {
+			return [this.source];
+		}
+		return [];
+	}
+
+	withChildren(newChildren: readonly PlanNode[]): PlanNode {
+		const expectedLength = this.values ? 1 + this.values.length : 1;
+		if (newChildren.length !== expectedLength) {
+			throw new Error(`InNode expects ${expectedLength} children, got ${newChildren.length}`);
+		}
+
+		const [newCondition, ...newValues] = newChildren;
+
+		// Type check
+		if (!('expression' in newCondition)) {
+			throw new Error('InNode: condition must be a ScalarPlanNode');
+		}
+
+		for (const value of newValues) {
+			if (!('expression' in value)) {
+				throw new Error('InNode: values must be ScalarPlanNodes');
+			}
+		}
+
+		// Check if anything changed
+		const conditionChanged = newCondition !== this.condition;
+		const valuesChanged = this.values && newValues.some((val, i) => val !== this.values![i]);
+
+		if (!conditionChanged && !valuesChanged) {
+			return this;
+		}
+
+		// Create new instance
+		return new InNode(
+			this.scope,
+			this.expression,
+			newCondition as ScalarPlanNode,
+			this.source, // Source doesn't change via withChildren
+			this.values ? newValues as ScalarPlanNode[] : undefined
+		);
+	}
+
+	override toString(): string {
+		if (this.source) {
+			return `${formatExpression(this.condition)} IN (subquery)`;
+		} else {
+			return `${formatExpression(this.condition)} IN (values)`;
+		}
+	}
+
+	override getLogicalAttributes(): Record<string, unknown> {
+		return {
+			condition: formatExpression(this.condition),
+			subqueryType: this.source ? 'subquery' : 'values',
+			valueCount: this.values?.length,
+			resultType: formatScalarType(this.getType())
+		};
+	}
+}
+
+export class ExistsNode extends PlanNode implements ScalarPlanNode {
+	override readonly nodeType = PlanNodeType.Exists;
+
+	constructor(
+		readonly scope: Scope,
+		readonly expression: Expression, // The original ExistsExpr AST node
+		readonly subquery: RelationalPlanNode,
+	) {
+		super(scope);
+	}
+
+	getType(): ScalarType {
+		return {
+			typeClass: 'scalar',
+			affinity: SqlDataType.INTEGER,
+			nullable: false,
+			isReadOnly: true,
+			datatype: SqlDataType.INTEGER,
+		};
+	}
+
+	getChildren(): readonly [] {
+		return [];
+	}
+
+	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}`);
+		}
+		return this; // No children in getChildren(), subquery is accessed via getRelations()
+	}
+
+	override toString(): string {
+		return `EXISTS (subquery)`;
+	}
+
+	override getLogicalAttributes(): Record<string, unknown> {
+		return {
+			subqueryType: 'exists',
+			resultType: formatScalarType(this.getType()),
+		};
+	}
+}

package/src/planner/nodes/table-function-call.ts

@@ -0,0 +1,127 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type Attribute } from './plan-node.js';
+import type { RelationType } from '../../common/datatype.js';
+import type { Scope } from '../scopes/scope.js';
+import type { FunctionSchema } from '../../schema/function.js';
+import { isTableValuedFunctionSchema } from '../../schema/function.js';
+import { Cached } from '../../util/cached.js';
+import { formatExpressionList } from '../../util/plan-formatter.js';
+
+/**
+ * Represents a table-valued function call in the FROM clause.
+ * This produces a relation from a function call like query_plan('SELECT ...').
+ */
+export class TableFunctionCallNode extends PlanNode implements RelationalPlanNode {
+  override readonly nodeType = PlanNodeType.TableFunctionCall;
+
+  private attributesCache: Cached<Attribute[]>;
+
+  constructor(
+    scope: Scope,
+    public readonly functionName: string,
+    public readonly functionSchema: FunctionSchema,
+    public readonly operands: readonly ScalarPlanNode[],
+    public readonly alias?: string,
+    estimatedCostOverride?: number
+  ) {
+    super(scope, estimatedCostOverride ?? 1); // Default cost for function calls
+
+    this.attributesCache = new Cached(() => {
+      // Create attributes from function schema return type
+      if (isTableValuedFunctionSchema(this.functionSchema)) {
+        return this.functionSchema.returnType.columns.map((col) => ({
+          id: PlanNode.nextAttrId(),
+          name: col.name,
+          type: col.type,
+          sourceRelation: `${this.functionName}()`
+        }));
+      }
+      return [];
+    });
+  }
+
+  getType(): RelationType {
+    // Return the function's defined return type
+    if (isTableValuedFunctionSchema(this.functionSchema)) {
+      return this.functionSchema.returnType;
+    }
+
+    // Fallback for non-table-valued functions (shouldn't happen)
+    return {
+      typeClass: 'relation',
+      isReadOnly: true,
+      isSet: false, // Table functions can return duplicate rows (bags)
+      columns: [],
+      keys: [], // Functions don't typically have inherent keys
+      rowConstraints: [],
+    };
+  }
+
+  getAttributes(): Attribute[] {
+    return this.attributesCache.value;
+  }
+
+  getChildren(): readonly ScalarPlanNode[] {
+    return this.operands;
+  }
+
+  getRelations(): readonly [] {
+    return [];
+  }
+
+  withChildren(newChildren: readonly PlanNode[]): PlanNode {
+    if (newChildren.length !== this.operands.length) {
+      throw new Error(`TableFunctionCallNode expects ${this.operands.length} children, got ${newChildren.length}`);
+    }
+
+    // Type check
+    for (const child of newChildren) {
+      if (!('expression' in child)) {
+        throw new Error('TableFunctionCallNode: 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 TableFunctionCallNode(
+      this.scope,
+      this.functionName,
+      this.functionSchema,
+      newChildren as ScalarPlanNode[],
+      this.alias
+    );
+  }
+
+  get estimatedRows(): number | undefined {
+    // Functions can return variable numbers of rows, so we'll use a default estimate
+    return 10; // Conservative estimate
+  }
+
+  override toString(): string {
+    const argsStr = formatExpressionList(this.operands);
+    const aliasStr = this.alias ? ` AS ${this.alias}` : '';
+    return `${this.functionName}(${argsStr})${aliasStr}`;
+  }
+
+  override getLogicalAttributes(): Record<string, unknown> {
+    const props: Record<string, unknown> = {
+      function: this.functionName,
+      arguments: this.operands.map(op => op.toString())
+    };
+
+    if (this.alias) {
+      props.alias = this.alias;
+    }
+
+    if (isTableValuedFunctionSchema(this.functionSchema)) {
+      props.columns = this.functionSchema.returnType.columns.map(col => col.name);
+    }
+
+    return props;
+  }
+}

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

@@ -0,0 +1,61 @@
+import { VoidNode } from './plan-node.js';
+import { PlanNodeType } from './plan-node-type.js';
+import type { Scope } from '../scopes/scope.js';
+import * as AST from '../../parser/ast.js';
+import { expressionToString } from '../../util/ast-stringify.js';
+
+export interface TransactionNode extends VoidNode {
+	nodeType: PlanNodeType.Transaction;
+	operation: 'begin' | 'commit' | 'rollback' | 'savepoint' | 'release';
+	mode?: 'deferred' | 'immediate' | 'exclusive'; // For BEGIN
+	savepoint?: string; // For ROLLBACK TO, SAVEPOINT, RELEASE
+	statementAst: AST.BeginStmt | AST.CommitStmt | AST.RollbackStmt | AST.SavepointStmt | AST.ReleaseStmt;
+}
+
+export class TransactionPlanNode extends VoidNode implements TransactionNode {
+	override readonly nodeType = PlanNodeType.Transaction;
+
+	constructor(
+		scope: Scope,
+		public readonly operation: 'begin' | 'commit' | 'rollback' | 'savepoint' | 'release',
+		public readonly statementAst: AST.BeginStmt | AST.CommitStmt | AST.RollbackStmt | AST.SavepointStmt | AST.ReleaseStmt,
+		public readonly mode?: 'deferred' | 'immediate' | 'exclusive',
+		public readonly savepoint?: string
+	) {
+		super(scope, 1); // Transaction operations have low cost
+	}
+
+	override toString(): string {
+		switch (this.operation) {
+			case 'begin':
+				return this.mode ? `BEGIN ${this.mode.toUpperCase()}` : 'BEGIN';
+			case 'commit':
+				return 'COMMIT';
+			case 'rollback':
+				return this.savepoint ? `ROLLBACK TO ${this.savepoint}` : 'ROLLBACK';
+			case 'savepoint':
+				return `SAVEPOINT ${this.savepoint}`;
+			case 'release':
+				return `RELEASE ${this.savepoint}`;
+			default:
+				return `TRANSACTION ${this.operation}`;
+		}
+	}
+
+	override getLogicalAttributes(): Record<string, unknown> {
+		const props: Record<string, unknown> = {
+			operation: this.operation,
+			statement: expressionToString(this.statementAst as any)
+		};
+
+		if (this.mode) {
+			props.mode = this.mode;
+		}
+
+		if (this.savepoint) {
+			props.savepoint = this.savepoint;
+		}
+
+		return props;
+	}
+}