@quereus/quereus 0.7.3 → 0.7.5

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

@@ -1,293 +0,0 @@
-import { PlanNodeType } from './plan-node-type.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';
-import { formatExpressionList } from '../../util/plan-formatter.js';
-import { quereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import type { ColumnReferenceNode } from './reference.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 directly
-    // The optimizer rule now passes both aggregate AND source attributes
-    if (this.preserveAttributeIds) {
-      return this.preserveAttributeIds.slice();
-    }
-
-    // Fallback: build attributes from scratch (used when not created via optimizer)
-    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}`
-      });
-    });
-
-    // 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;
-  }
-
-  // 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 ColumnReferenceNode;
-      return colRef.expression.name;
-    }
-    // Otherwise, use a generic name
-    return `group_${index}`;
-  }
-
-  getType(): RelationType {
-    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
-      columns.push(...this.groupBy.map((expr, index) => ({
-        name: this.getGroupByColumnName(expr, index),
-        type: expr.getType(),
-        generated: false
-      })));
-
-      // Then aggregate columns
-      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',
-      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;
-  }
-
-  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)];
-  }
-
-  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
-      }));
-    }
-
-    // Expose logical unique keys: group-by columns (0..groupCount-1) or [[]] for global aggregate
-    const groupCount = this.groupBy.length;
-    (props as any).uniqueKeys = groupCount > 0 ? [Array.from({ length: groupCount }, (_, i) => i)] : [[]];
-    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 (!isRelationalNode(newSource)) {
-      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

@@ -1,268 +0,0 @@
-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 } 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";
-import { quereusError } from "../../common/errors.js";
-import { BLOB_TYPE, BOOLEAN_TYPE, INTEGER_TYPE } from "../../types/builtin-types.js";
-import { StatusCode } from "../../common/types.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',
-			logicalType: BLOB_TYPE,
-			nullable: true,
-			isReadOnly: true,
-		};
-	}
-
-	getChildren(): readonly PlanNode[] {
-		// Include the subquery so the optimizer can visit it
-		return [this.subquery];
-	}
-
-	getRelations(): readonly [RelationalPlanNode] {
-		return [this.subquery];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		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;
-		}
-
-		// Create new instance
-		return new ScalarSubqueryNode(
-			this.scope,
-			this.expression,
-			newSubquery as RelationalPlanNode
-		);
-	}
-
-	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',
-			logicalType: BOOLEAN_TYPE,
-			nullable: false,
-			isReadOnly: true,
-		}
-	}
-
-	getChildren(): readonly PlanNode[] {
-		// Include condition, values (if any), and source subquery (if any)
-		const children: PlanNode[] = [this.condition];
-		if (this.values) {
-			children.push(...this.values);
-		}
-		if (this.source) {
-			children.push(this.source);
-		}
-		return children;
-	}
-
-	getRelations(): readonly RelationalPlanNode[] {
-		if (this.source) {
-			return [this.source];
-		}
-		return [];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		const expectedLength = 1 + (this.values?.length ?? 0) + (this.source ? 1 : 0);
-		if (newChildren.length !== expectedLength) {
-			quereusError(`InNode expects ${expectedLength} children, got ${newChildren.length}`, StatusCode.INTERNAL);
-		}
-
-		let childIndex = 0;
-		const newCondition = newChildren[childIndex++];
-
-		// 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);
-			}
-		}
-
-		// 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 && newValues.some((val, i) => val !== this.values![i]);
-		const sourceChanged = newSource !== this.source;
-
-		if (!conditionChanged && !valuesChanged && !sourceChanged) {
-			return this;
-		}
-
-		// Create new instance
-		return new InNode(
-			this.scope,
-			this.expression,
-			newCondition as ScalarPlanNode,
-			newSource,
-			newValues
-		);
-	}
-
-	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',
-			logicalType: BOOLEAN_TYPE,
-			nullable: false,
-			isReadOnly: true,
-		};
-	}
-
-	getChildren(): readonly PlanNode[] {
-		// Include the subquery so the optimizer can visit it
-		return [this.subquery];
-	}
-
-	getRelations(): readonly RelationalPlanNode[] {
-		return [this.subquery];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		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;
-		}
-
-		// Create new instance
-		return new ExistsNode(
-			this.scope,
-			this.expression,
-			newSubquery as RelationalPlanNode
-		);
-	}
-
-	override toString(): string {
-		return `EXISTS (subquery)`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			subqueryType: 'exists',
-			resultType: formatScalarType(this.getType()),
-		};
-	}
-}