@quereus/quereus 0.7.3 → 0.7.5

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

@@ -1,113 +0,0 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { isRelationalNode, PlanNode, type Attribute, type RelationalPlanNode, type UnaryRelationalNode } 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 { INTEGER_TYPE } from '../../types/builtin-types.js';
-
-/**
- * Represents a sequencing operation that adds a row number column to convert bags to sets.
- * This ensures uniqueness for operations that require set semantics.
- * The added column is typically projected away after use and not visible to the user.
- */
-export class SequencingNode extends PlanNode implements UnaryRelationalNode {
-	override readonly nodeType = PlanNodeType.Sequencing;
-
-	private outputTypeCache: Cached<RelationType>;
-
-	constructor(
-		scope: Scope,
-		public readonly source: RelationalPlanNode,
-		public readonly sequenceColumnName: string = '__row_seq',
-		estimatedCostOverride?: number
-	) {
-		super(scope, estimatedCostOverride);
-
-		this.outputTypeCache = new Cached(() => {
-			const sourceType = this.source.getType();
-
-			// Add a sequence column to make this a set
-			const sequenceColumn = {
-				name: this.sequenceColumnName,
-				type: {
-					typeClass: 'scalar' as const,
-					logicalType: INTEGER_TYPE,
-					nullable: false,
-					isReadOnly: true
-				},
-				generated: true
-			};
-
-			// Create a unique key based on all columns including the sequence
-			// This guarantees the result is a set
-			const allColumnsKey = sourceType.columns.map((_, index) => ({ index }))
-				.concat([{ index: sourceType.columns.length }]); // Include sequence column
-
-			return {
-				typeClass: 'relation',
-				isReadOnly: sourceType.isReadOnly,
-				isSet: true, // This operation guarantees set semantics
-				columns: [...sourceType.columns, sequenceColumn],
-				keys: [allColumnsKey], // All columns including sequence form a unique key
-				rowConstraints: sourceType.rowConstraints,
-			} satisfies RelationType;
-		});
-	}
-
-	getType(): RelationType {
-		return this.outputTypeCache.value;
-	}
-
-	getAttributes(): readonly Attribute[] {
-		// Sort preserves the same attributes as its source
-		return this.source.getAttributes();
-	}
-
-	getChildren(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	getRelations(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 1) {
-			throw new Error(`SequencingNode expects 1 child, got ${newChildren.length}`);
-		}
-
-		const [newSource] = newChildren;
-
-		// Type check
-		if (!isRelationalNode(newSource)) {
-			throw new Error('SequencingNode: child must be a RelationalPlanNode');
-		}
-
-		// Return same instance if nothing changed
-		if (newSource === this.source) {
-			return this;
-		}
-
-		// Create new instance preserving attributes (sequencing preserves source attributes)
-		return new SequencingNode(
-			this.scope,
-			newSource as RelationalPlanNode,
-			this.sequenceColumnName
-		);
-	}
-
-	get estimatedRows(): number | undefined {
-		return this.source.estimatedRows; // Sequencing doesn't change row count
-	}
-
-	override toString(): string {
-		return `SEQUENCE ADD ${this.sequenceColumnName}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			sequenceColumn: this.sequenceColumnName,
-			purpose: 'Convert bag to set by adding unique row sequence'
-		};
-	}
-}

package/src/planner/nodes/set-operation-node.ts

@@ -1,87 +0,0 @@
-import { isRelationalNode, PlanNode } from './plan-node.js';
-import type { RelationalPlanNode, Attribute, BinaryRelationalNode } 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 { Cached } from '../../util/cached.js';
-import { quereusError, QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-
-export class SetOperationNode extends PlanNode implements BinaryRelationalNode {
-  readonly nodeType = PlanNodeType.SetOperation;
-  private attributesCache: Cached<readonly Attribute[]>;
-
-  constructor(
-    scope: Scope,
-    public readonly left: RelationalPlanNode,
-    public readonly right: RelationalPlanNode,
-    public readonly op: 'union' | 'unionAll' | 'intersect' | 'except'
-  ) {
-    super(scope, left.getTotalCost() + right.getTotalCost());
-    // Validate column counts
-    const leftCols = left.getType().columns;
-    const rightCols = right.getType().columns;
-    if (leftCols.length !== rightCols.length) {
-      throw new QuereusError(`SET operation column count mismatch: left has ${leftCols.length}, right has ${rightCols.length}`, StatusCode.ERROR);
-    }
-    // TODO: optionally check type compatibility (affinity)
-    this.attributesCache = new Cached(() => this.buildAttributes());
-  }
-
-  private buildAttributes(): readonly Attribute[] {
-    const leftAttrs = this.left.getAttributes();
-    // Preserve left child's attributes directly to avoid any mapping issues
-    // This ensures ORDER BY expressions can resolve to the same attribute IDs
-    return leftAttrs;
-  }
-
-  getAttributes(): readonly Attribute[] {
-    return this.attributesCache.value;
-  }
-
-  getType(): RelationType {
-    const leftType = this.left.getType();
-    return { ...leftType, isSet: true } as RelationType;
-  }
-
-  getChildren(): readonly PlanNode[] {
-    return [this.left, this.right];
-  }
-
-  getRelations(): readonly [RelationalPlanNode, RelationalPlanNode] {
-    return [this.left, this.right];
-  }
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== 2) {
-      quereusError(`SetOperationNode expects 2 children, got ${newChildren.length}`, StatusCode.INTERNAL);
-    }
-
-    const [newLeft, newRight] = newChildren;
-
-    // Type check
-    if (!isRelationalNode(newLeft)) {
-      quereusError('SetOperationNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
-    }
-    if (!isRelationalNode(newRight)) {
-      quereusError('SetOperationNode: second child must be a RelationalPlanNode', StatusCode.INTERNAL);
-    }
-
-    // Return same instance if nothing changed
-    if (newLeft === this.left && newRight === this.right) {
-      return this;
-    }
-
-    // Create new instance preserving attributes (set operation preserves left child's attributes)
-    return new SetOperationNode(
-      this.scope,
-      newLeft as RelationalPlanNode,
-      newRight as RelationalPlanNode,
-      this.op
-    );
-  }
-
-  override toString(): string {
-    return `${this.op.toUpperCase()}(${this.left.id}, ${this.right.id})`;
-  }
-}

package/src/planner/nodes/single-row.ts

@@ -1,85 +0,0 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type ZeroAryRelationalNode, type Attribute, PhysicalProperties, type ConstantNode } from './plan-node.js';
-import type { RelationType } from '../../common/datatype.js';
-import { EmptyScope } from '../scopes/empty.js';
-import type { Scope } from '../scopes/scope.js';
-import type { Row } from '../../common/types.js';
-
-/**
- * A dummy relational node that produces a single row with no columns.
- * Used as a source for SELECT statements without a FROM clause.
- */
-export class SingleRowNode extends PlanNode implements ZeroAryRelationalNode, ConstantNode {
-  override readonly nodeType = PlanNodeType.SingleRow;
-
-  private static readonly singleInstance = new SingleRowNode(EmptyScope.instance); // HACK: null scope for singleton
-
-  private readonly outputType: RelationType = {
-    typeClass: 'relation',
-    isReadOnly: true,
-    isSet: true, // Single row is always a set
-    columns: [],
-    keys: [[]], // Represents a relation that can have at most one row
-    rowConstraints: [],
-  };
-
-  private constructor(scope: Scope) { // Private constructor for singleton
-    super(scope, 0.01); // Low cost - no IO
-  }
-
-  public static get instance(): SingleRowNode {
-    return SingleRowNode.singleInstance;
-  }
-
-  getType(): RelationType {
-    return this.outputType;
-  }
-
-  getAttributes(): Attribute[] {
-    // Single row node has no columns, so no attributes
-    return [];
-  }
-
-  getChildren(): readonly [] {
-    return [];
-  }
-
-	getRelations(): readonly [] {
-		return [];
-	}
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== 0) {
-      throw new Error(`SingleRowNode expects 0 children, got ${newChildren.length}`);
-    }
-    return this; // No children, so no change
-  }
-
-  get estimatedRows(): number {
-    return 1;
-  }
-
-  override toString(): string {
-    return `dual`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    return {
-      description: 'Single row with no columns (dual table)',
-      numRows: 1,
-      numColumns: 0,
-    };
-  }
-
-	override computePhysical(): Partial<PhysicalProperties> {
-		return {
-			estimatedRows: 1,
-			uniqueKeys: [[]],
-			constant: true,
-		};
-	}
-
-	async *getValue(): AsyncIterable<Row> {
-		yield [];
-	}
-}

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

@@ -1,61 +0,0 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode } from './plan-node.js';
-import type { ScalarType } from '../../common/datatype.js';
-import type { Scope } from '../scopes/scope.js';
-import { INTEGER_TYPE } from '../../types/builtin-types.js';
-
-/**
- * A sink node that consumes an async iterable for side effects.
- * Returns the number of rows affected.
- */
-export class SinkNode extends PlanNode {
-	override readonly nodeType = PlanNodeType.Sink;
-
-	constructor(
-		scope: Scope,
-		public readonly source: RelationalPlanNode,
-		/** Describes the operation for information purposes */
-		public readonly operation: string,
-	) {
-		super(scope, source.getTotalCost() + 0.1); // Minimal cost for consuming
-	}
-
-	getType(): ScalarType {
-		// Return a single-column relation with the row count
-		return {
-			typeClass: 'scalar',
-			isReadOnly: true,
-			logicalType: INTEGER_TYPE,
-			nullable: false
-		};
-	}
-
-	getChildren(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 1) {
-			throw new Error(`SinkNode expects 1 child, got ${newChildren.length}`);
-		}
-		return new SinkNode(this.scope, newChildren[0] as RelationalPlanNode, this.operation);
-	}
-
-	getRelations(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	get estimatedRows(): number {
-		return 1;
-	}
-
-	override toString(): string {
-		return `SINK (${this.operation})`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			sourceType: this.source.nodeType
-		};
-	}
-}

package/src/planner/nodes/sort.ts

@@ -1,166 +0,0 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type UnaryRelationalNode, type PhysicalProperties, type Attribute, isRelationalNode } from './plan-node.js';
-import type { RelationType } from '../../common/datatype.js';
-import type { Scope } from '../scopes/scope.js';
-import { formatSortKey } from '../../util/plan-formatter.js';
-import { quereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { extractOrderingFromSortKeys } from '../framework/physical-utils.js';
-import { SortCapable } from '../framework/characteristics.js';
-
-/**
- * Represents a sort key for ordering results
- */
-export interface SortKey {
-	/** The expression to sort by */
-	expression: ScalarPlanNode;
-	/** Sort direction */
-	direction: 'asc' | 'desc';
-	/** How to handle nulls */
-	nulls?: 'first' | 'last';
-}
-
-/**
- * Represents a sort operation (ORDER BY clause).
- * It takes an input relation and sort keys,
- * and outputs rows sorted according to the keys.
- * This is a physical operation that materializes and sorts rows.
- */
-export class SortNode extends PlanNode implements UnaryRelationalNode, SortCapable {
-	override readonly nodeType = PlanNodeType.Sort;
-
-	constructor(
-		scope: Scope,
-		public readonly source: RelationalPlanNode,
-		public readonly sortKeys: readonly SortKey[],
-		estimatedCostOverride?: number
-	) {
-		// Cost: cost of source + cost of sorting (O(n log n) * cost of evaluating sort expressions)
-		// This is a simplified cost model - a more sophisticated one would consider the actual data size
-		const sourceRows = source.estimatedRows ?? 1000;
-		const sortCost = sourceRows * Math.log2(sourceRows + 1);
-		const keyCost = sortKeys.reduce((sum, key) => sum + key.expression.getTotalCost(), 0);
-
-		super(scope, estimatedCostOverride ?? (source.getTotalCost() + sortCost * keyCost));
-	}
-
-	getType(): RelationType {
-		// Sort preserves the type of the source relation
-		return this.source.getType();
-	}
-
-	getAttributes(): readonly Attribute[] {
-		// Sort preserves the same attributes as its source
-		return this.source.getAttributes();
-	}
-
-	getChildren(): readonly PlanNode[] {
-		// Return source first, then all sort key expressions
-		return [this.source, ...this.sortKeys.map(key => key.expression)];
-	}
-
-	getRelations(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	get estimatedRows(): number | undefined {
-		// Sort doesn't change the number of rows
-		return this.source.estimatedRows;
-	}
-
-	computePhysical(childrenPhysical: PhysicalProperties[]): Partial<PhysicalProperties> {
-		const sourcePhysical = childrenPhysical[0]; // Source is first relation
-		const sourceAttributes = this.source.getAttributes();
-
-		// Extract ordering from sort keys if they are trivial column references
-		const ordering = extractOrderingFromSortKeys(this.sortKeys, sourceAttributes);
-
-		return {
-			estimatedRows: this.estimatedRows,
-			ordering,
-			uniqueKeys: sourcePhysical?.uniqueKeys,
-		};
-	}
-
-	override toString(): string {
-		const keyDescriptions = this.sortKeys.map(key =>
-			formatSortKey(key.expression, key.direction, key.nulls)
-		).join(', ');
-		return `ORDER BY ${keyDescriptions}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			sortKeys: this.sortKeys.map(key => ({
-				expression: key.expression.toString(),
-				direction: key.direction,
-				nulls: key.nulls
-			}))
-		};
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 1 + this.sortKeys.length) {
-			quereusError(`SortNode expects ${1 + this.sortKeys.length} children, got ${newChildren.length}`, StatusCode.INTERNAL);
-		}
-
-		const [newSource, ...newSortExpressions] = newChildren;
-
-		// Type check
-		if (!isRelationalNode(newSource)) {
-			quereusError('SortNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
-		}
-
-		// Check if anything changed
-		const sourceChanged = newSource !== this.source;
-		const sortExpressionsChanged = newSortExpressions.some((expr, i) => expr !== this.sortKeys[i].expression);
-
-		if (!sourceChanged && !sortExpressionsChanged) {
-			return this;
-		}
-
-		// Build new sort keys array
-		const newSortKeys = newSortExpressions.map((expr, i) => ({
-			expression: expr as ScalarPlanNode,
-			direction: this.sortKeys[i].direction,
-			nulls: this.sortKeys[i].nulls
-		}));
-
-		// Create new instance preserving attributes (sort preserves source attributes)
-		return new SortNode(
-			this.scope,
-			newSource as RelationalPlanNode,
-			newSortKeys
-		);
-	}
-
-	// SortCapable interface implementation
-	getSortKeys(): readonly { expression: ScalarPlanNode; direction: 'asc' | 'desc' }[] {
-		return this.sortKeys.map(key => ({
-			expression: key.expression,
-			direction: key.direction
-		}));
-	}
-
-	withSortKeys(keys: readonly { expression: ScalarPlanNode; direction: 'asc' | 'desc' }[]): PlanNode {
-		// Convert to internal SortKey format with nulls handling
-		const newSortKeys = keys.map(key => ({
-			expression: key.expression,
-			direction: key.direction,
-			nulls: undefined as 'first' | 'last' | undefined
-		}));
-
-		// Check if anything changed
-		const changed = newSortKeys.length !== this.sortKeys.length ||
-			newSortKeys.some((key, i) =>
-				key.expression !== this.sortKeys[i].expression ||
-				key.direction !== this.sortKeys[i].direction
-			);
-
-		if (!changed) {
-			return this;
-		}
-
-		return new SortNode(this.scope, this.source, newSortKeys);
-	}
-}