@quereus/quereus 0.7.3 → 0.7.5

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

@@ -1,102 +0,0 @@
-import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type Attribute, type RowDescriptor, type PhysicalProperties, isRelationalNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type { TableReferenceNode } from './reference.js';
-import type { RelationType } from '../../common/datatype.js';
-import { buildAttributesFromFlatDescriptor } from '../../util/row-descriptor.js';
-
-/**
- * Represents a DELETE statement in the logical query plan.
- */
-export class DeleteNode extends PlanNode implements RelationalPlanNode {
-  override readonly nodeType = PlanNodeType.Delete;
-
-  constructor(
-    scope: Scope,
-    public readonly table: TableReferenceNode,
-    public readonly source: RelationalPlanNode, // Typically a FilterNode wrapping a TableReferenceNode
-    public readonly oldRowDescriptor?: RowDescriptor, // For constraint checking
-    public readonly flatRowDescriptor?: RowDescriptor,
-    public readonly mutationContextValues?: Map<string, ScalarPlanNode>, // Mutation context value expressions
-    public readonly contextAttributes?: Attribute[], // Mutation context attributes
-    public readonly contextDescriptor?: RowDescriptor, // Mutation context row descriptor
-  ) {
-    super(scope);
-  }
-
-	getType(): RelationType {
-		return this.source.getType();
-	}
-
-  getAttributes(): readonly Attribute[] {
-    if (this.flatRowDescriptor && Object.keys(this.flatRowDescriptor).length > 0) {
-      return buildAttributesFromFlatDescriptor(this.flatRowDescriptor);
-    }
-    // Fallback to source attributes for backward compatibility
-    return this.source.getAttributes();
-  }
-
-  getRelations(): readonly [RelationalPlanNode, TableReferenceNode] {
-    // The source provides keys to be deleted, table is the target of deletions.
-    return [this.source, this.table];
-  }
-
-  getChildren(): readonly PlanNode[] {
-    // Return the source relation as a child so optimizer can traverse it
-    return [this.source];
-  }
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== 1) {
-      throw new Error(`DeleteNode expects 1 child (source), got ${newChildren.length}`);
-    }
-
-    const newSource = newChildren[0] as RelationalPlanNode;
-    if (!isRelationalNode(newSource)) {
-      throw new Error('DeleteNode: child must be a RelationalPlanNode');
-    }
-
-    if (newSource === this.source) {
-      return this;
-    }
-
-    return new DeleteNode(
-      this.scope,
-      this.table,
-      newSource,
-      this.oldRowDescriptor,
-      this.flatRowDescriptor,
-      this.mutationContextValues,
-      this.contextAttributes,
-      this.contextDescriptor
-    );
-  }
-
-  computePhysical(): Partial<PhysicalProperties> {
-    return {
-      readonly: false,  // DELETE has side effects
-      estimatedRows: this.source.estimatedRows
-    };
-  }
-
-  get estimatedRows(): number | undefined {
-    return this.source.estimatedRows;
-  }
-
-  override toString(): string {
-    return `DELETE FROM ${this.table.tableSchema.name}`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    const props: Record<string, unknown> = {
-      table: this.table.tableSchema.name,
-      schema: this.table.tableSchema.schemaName
-    };
-
-    if (this.flatRowDescriptor) {
-      props.hasFlatRowDescriptor = true;
-    }
-
-    return props;
-  }
-}

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

@@ -1,107 +0,0 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode, type UnaryRelationalNode, type Attribute, isRelationalNode, type PhysicalProperties } from './plan-node.js';
-import type { RelationType } from '../../common/datatype.js';
-import type { Scope } from '../scopes/scope.js';
-import { quereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-
-/**
- * Represents a DISTINCT operation that eliminates duplicate rows.
- * It takes an input relation and outputs unique rows.
- */
-export class DistinctNode extends PlanNode implements UnaryRelationalNode {
-  override readonly nodeType = PlanNodeType.Distinct;
-
-  constructor(
-    scope: Scope,
-    public readonly source: RelationalPlanNode,
-    estimatedCostOverride?: number
-  ) {
-    // Cost: cost of source + cost of deduplication (roughly O(n log n) for sorting approach)
-    const sourceCost = source.getTotalCost();
-    const sourceRows = source.estimatedRows ?? 1;
-    const deduplicationCost = sourceRows * Math.log2(Math.max(1, sourceRows));
-    super(scope, estimatedCostOverride ?? (sourceCost + deduplicationCost));
-  }
-
-  getType(): RelationType {
-    // DISTINCT always produces a set (no duplicates)
-    const sourceType = this.source.getType();
-    return {
-      ...sourceType,
-      isSet: true
-    };
-  }
-
-  getAttributes(): readonly Attribute[] {
-    // DISTINCT preserves the same attributes as its source
-    return this.source.getAttributes();
-  }
-
-  getChildren(): readonly [RelationalPlanNode] {
-    return [this.source];
-  }
-
-  getRelations(): readonly [RelationalPlanNode] {
-    return [this.source];
-  }
-
-  get estimatedRows(): number | undefined {
-    // DISTINCT reduces the number of rows by eliminating duplicates
-    // This is a rough estimate - in reality it depends on data distribution
-    const sourceRows = this.source.estimatedRows;
-    if (sourceRows === undefined) return undefined;
-    if (sourceRows <= 1) return sourceRows;
-
-    // Rough heuristic: assume some duplicates exist
-    // More sophisticated planners would use column statistics
-    return Math.max(1, Math.floor(sourceRows * 0.7));
-  }
-
-  override toString(): string {
-    return 'DISTINCT';
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    const colCount = this.source.getAttributes().length;
-    const allColsKey = [Array.from({ length: colCount }, (_, i) => i)];
-    return {
-      uniqueKeys: allColsKey
-    };
-  }
-
-  computePhysical(childrenPhysical: PhysicalProperties[]): Partial<PhysicalProperties> {
-    const sourcePhysical = childrenPhysical[0];
-    const colCount = this.source.getAttributes().length;
-    const allColsKey = [Array.from({ length: colCount }, (_, i) => i)];
-    return {
-      uniqueKeys: allColsKey,
-      estimatedRows: this.estimatedRows,
-      ordering: sourcePhysical?.ordering,
-    };
-  }
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== 1) {
-      quereusError(`DistinctNode expects 1 child, got ${newChildren.length}`, StatusCode.INTERNAL);
-    }
-
-    const [newSource] = newChildren;
-
-    // Type check
-    if (!isRelationalNode(newSource)) {
-      quereusError('DistinctNode: child must be a RelationalPlanNode', StatusCode.INTERNAL);
-    }
-
-    // Return same instance if nothing changed
-    if (newSource === this.source) {
-      return this;
-    }
-
-    // Create new instance preserving attributes (distinct preserves source attributes)
-    return new DistinctNode(
-      this.scope,
-      newSource as RelationalPlanNode
-    );
-  }
-}

package/src/planner/nodes/dml-executor-node.ts

@@ -1,104 +0,0 @@
-import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type RelationalPlanNode, type Attribute, type PhysicalProperties, type ScalarPlanNode, type RowDescriptor, isRelationalNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type { TableReferenceNode } from './reference.js';
-import type { RelationType } from '../../common/datatype.js';
-import type { ConflictResolution } from '../../common/constants.js';
-import { RowOp } from '../../common/types.js';
-
-/**
- * Executes actual database insert/update/delete operations after constraint validation.
- * This node performs the actual vtab.update operations and yields the affected rows.
- * All data transformations (defaults, conversions, etc.) happen before this node.
- */
-export class DmlExecutorNode extends PlanNode implements RelationalPlanNode {
-  override readonly nodeType = PlanNodeType.UpdateExecutor;
-
-  constructor(
-    scope: Scope,
-    public readonly source: RelationalPlanNode,
-    public readonly table: TableReferenceNode,
-    public readonly operation: RowOp,
-    public readonly onConflict?: ConflictResolution, // Used for INSERT operations
-    public readonly mutationContextValues?: Map<string, ScalarPlanNode>, // Mutation context value expressions
-    public readonly contextAttributes?: Attribute[], // Mutation context attributes
-    public readonly contextDescriptor?: RowDescriptor, // Mutation context row descriptor
-  ) {
-    super(scope);
-  }
-
-  getType(): RelationType {
-    return this.source.getType();
-  }
-
-  getAttributes(): readonly Attribute[] {
-    return this.source.getAttributes();
-  }
-
-  getRelations(): readonly [RelationalPlanNode, TableReferenceNode] {
-    return [this.source, this.table];
-  }
-
-  getChildren(): readonly PlanNode[] {
-    return [this.source];
-  }
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== 1) {
-      throw new Error(`UpdateExecutorNode expects 1 child, got ${newChildren.length}`);
-    }
-
-    const [newSource] = newChildren;
-
-    // Type check
-    if (!isRelationalNode(newSource)) {
-      throw new Error('UpdateExecutorNode: child must be a RelationalPlanNode');
-    }
-
-    // Return same instance if nothing changed
-    if (newSource === this.source) {
-      return this;
-    }
-
-    // Create new instance
-    return new DmlExecutorNode(
-      this.scope,
-      newSource as RelationalPlanNode,
-      this.table,
-      this.operation,
-      this.onConflict,
-      this.mutationContextValues,
-      this.contextAttributes,
-      this.contextDescriptor
-    );
-  }
-
-  get estimatedRows(): number | undefined {
-    return this.source.estimatedRows;
-  }
-
-  override toString(): string {
-    return `EXECUTE ${this.operation} ${this.table.tableSchema.name}`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    const props: Record<string, unknown> = {
-      operation: this.operation,
-      table: this.table.tableSchema.name,
-      schema: this.table.tableSchema.schemaName,
-    };
-
-    if (this.onConflict) {
-      props.onConflict = this.onConflict;
-    }
-
-    return props;
-  }
-
-  computePhysical(): Partial<PhysicalProperties> {
-    return {
-      readonly: false, // DML executor has side effects
-      idempotent: false, // DML operations are generally not idempotent
-    };
-  }
-}

package/src/planner/nodes/drop-assertion-node.ts

@@ -1,50 +0,0 @@
-import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type VoidNode, type PhysicalProperties } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type { VoidType } from '../../common/datatype.js';
-
-/**
- * Represents dropping a global integrity assertion.
- * This is a DDL operation that removes an assertion from the schema.
- */
-export class DropAssertionNode extends PlanNode implements VoidNode {
-  override readonly nodeType = PlanNodeType.DropAssertion;
-
-  constructor(
-    scope: Scope,
-    public readonly name: string,
-    public readonly ifExists: boolean,
-  ) {
-    super(scope);
-  }
-
-  getType(): VoidType {
-    return { typeClass: 'void' };
-  }
-
-  getChildren(): readonly PlanNode[] {
-    return [];
-  }
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== 0) {
-      throw new Error(`DropAssertionNode expects 0 children, got ${newChildren.length}`);
-    }
-    return this; // No children, so no change
-  }
-
-  override toString(): string {
-    return `DROP ASSERTION ${this.name}`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    return {
-      name: this.name,
-      ifExists: this.ifExists,
-    };
-  }
-
-  override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
-    return { readonly: false };
-  }
-}

package/src/planner/nodes/drop-table-node.ts

@@ -1,36 +0,0 @@
-import type { Scope } from '../scopes/scope.js';
-import { PhysicalProperties, VoidNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type * as AST from '../../parser/ast.js';
-import { expressionToString } from '../../util/ast-stringify.js';
-
-/**
- * Represents a DROP TABLE statement in the logical query plan.
- */
-export class DropTableNode extends VoidNode {
-  override readonly nodeType = PlanNodeType.DropTable;
-
-  constructor(
-    scope: Scope,
-    public readonly statementAst: AST.DropStmt,
-  ) {
-    super(scope);
-  }
-
-  override toString(): string {
-    return `DROP TABLE ${this.statementAst.name.name}`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    return {
-      table: this.statementAst.name.name,
-      schema: this.statementAst.name.schema,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      statement: expressionToString(this.statementAst as any)
-    };
-  }
-
-	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
-		return { readonly: false };
-	}
-}

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

@@ -1,37 +0,0 @@
-import { PhysicalProperties, VoidNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type { Scope } from '../scopes/scope.js';
-
-/**
- * Plan node for DROP VIEW statements.
- * Removes a view definition from the schema.
- */
-export class DropViewNode extends VoidNode {
-	readonly nodeType = PlanNodeType.DropView;
-
-	constructor(
-		scope: Scope,
-		public readonly viewName: string,
-		public readonly schemaName: string,
-		public readonly ifExists: boolean
-	) {
-		super(scope, 1); // Low cost for DDL operations
-	}
-
-	override toString(): string {
-		const ifExistsClause = this.ifExists ? 'IF EXISTS ' : '';
-		return `DROP VIEW ${ifExistsClause}${this.schemaName}.${this.viewName}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			viewName: this.viewName,
-			schemaName: this.schemaName,
-			ifExists: this.ifExists
-		};
-	}
-
-	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
-		return { readonly: false };
-	}
-}

package/src/planner/nodes/filter.ts

@@ -1,144 +0,0 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type UnaryRelationalNode, type Attribute, isRelationalNode, isScalarNode, type PhysicalProperties } from './plan-node.js';
-import type { RelationType } from '../../common/datatype.js';
-import type { Scope } from '../scopes/scope.js';
-import { formatExpression } from '../../util/plan-formatter.js';
-import { quereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { PredicateCapable, type PredicateSourceCapable } from '../framework/characteristics.js';
-import { createTableInfoFromNode, extractConstraints } from '../analysis/constraint-extractor.js';
-
-/**
- * Represents a filter operation (WHERE clause).
- * It takes an input relation and a predicate expression,
- * and outputs rows for which the predicate is true.
- */
-export class FilterNode extends PlanNode implements UnaryRelationalNode, PredicateCapable, PredicateSourceCapable {
-	override readonly nodeType = PlanNodeType.Filter;
-
-	constructor(
-		scope: Scope,
-		public readonly source: RelationalPlanNode,
-		public readonly predicate: ScalarPlanNode,
-		estimatedCostOverride?: number
-	) {
-		// Cost: cost of source + cost of evaluating predicate for each source row
-		super(scope, estimatedCostOverride ?? (source.getTotalCost() + (source.estimatedRows ?? 1) * predicate.getTotalCost()));
-	}
-
-	getType(): RelationType {
-		// Filter preserves the type of the source relation
-		return this.source.getType();
-	}
-
-	getAttributes(): readonly Attribute[] {
-		// Filter preserves the same attributes as its source
-		return this.source.getAttributes();
-	}
-
-	getChildren(): readonly [RelationalPlanNode, ScalarPlanNode] {
-		return [this.source, this.predicate];
-	}
-
-	getRelations(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	get estimatedRows(): number | undefined {
-		// This is a rough estimate. A more sophisticated planner would use selectivity estimates.
-		// For now, assume a selectivity of 0.5 if source has rows, otherwise 0.
-		// TODO: Use selectivity estimates
-		const sourceRows = this.source.estimatedRows;
-		if (sourceRows === undefined) return undefined;
-		return sourceRows > 0 ? Math.max(1, Math.floor(sourceRows * 0.5)) : 0;
-	}
-
-	computePhysical(childrenPhysical: PhysicalProperties[]): Partial<PhysicalProperties> {
-		const sourcePhysical = childrenPhysical[0];
-		const srcRows = sourcePhysical?.estimatedRows;
-		const est = this.estimatedRows;
-		let rows = (typeof srcRows === 'number' && typeof est === 'number')
-			? Math.min(srcRows, est)
-			: (srcRows ?? est);
-
-		// Attempt logical covered-key detection to infer at-most-one row
-		let uniqueKeys = sourcePhysical?.uniqueKeys;
-		const tableInfo = createTableInfoFromNode(this.source);
-		if (tableInfo.uniqueKeys && tableInfo.uniqueKeys.length > 0) {
-			const result = extractConstraints(this.predicate, [tableInfo]);
-			const covered = result.coveredKeysByTable?.get(tableInfo.relationKey) || [];
-			if (covered.length > 0) {
-				// Equality covers a unique key → at most one row
-				uniqueKeys = [[]];
-				rows = 1;
-			}
-		}
-
-		return {
-			estimatedRows: rows,
-			ordering: sourcePhysical?.ordering,
-			uniqueKeys,
-		};
-	}
-
-	override toString(): string {
-		return `WHERE ${formatExpression(this.predicate)}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			predicate: formatExpression(this.predicate)
-		};
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 2) {
-			quereusError(`FilterNode expects 2 children, got ${newChildren.length}`, StatusCode.INTERNAL);
-		}
-
-		const [newSource, newPredicate] = newChildren;
-
-		// Type check
-		if (!isRelationalNode(newSource)) {
-			quereusError('FilterNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
-		}
-		if (!isScalarNode(newPredicate)) {
-			quereusError('FilterNode: second child must be a ScalarPlanNode', StatusCode.INTERNAL);
-		}
-
-		// Return same instance if nothing changed
-		if (newSource === this.source && newPredicate === this.predicate) {
-			return this;
-		}
-
-		// Create new instance preserving attributes (filter preserves source attributes)
-		return new FilterNode(
-			this.scope,
-			newSource as RelationalPlanNode,
-			newPredicate as ScalarPlanNode
-		);
-	}
-
-	// PredicateCapable interface implementation
-	getPredicate(): ScalarPlanNode | null {
-		return this.predicate;
-	}
-
-	withPredicate(newPredicate: ScalarPlanNode | null): PlanNode {
-		if (newPredicate === null) {
-			// If predicate is null, return the source directly (no filter needed)
-			return this.source;
-		}
-
-		if (newPredicate === this.predicate) {
-			return this;
-		}
-
-		return new FilterNode(this.scope, this.source, newPredicate);
-	}
-
-  // PredicateSourceCapable interface implementation
-  getPredicates(): readonly ScalarPlanNode[] {
-    return [this.predicate];
-  }
-}

package/src/planner/nodes/function.ts

@@ -1,98 +0,0 @@
-import type { ScalarType } from '../../common/datatype.js';
-import type * as AST from '../../parser/ast.js';
-import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type NaryScalarNode, type ScalarPlanNode, type PhysicalProperties } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import { formatExpressionList, formatScalarType } from '../../util/plan-formatter.js';
-import type { FunctionSchema } from '../../schema/function.js';
-import { FunctionFlags } from '../../common/constants.js';
-
-export class ScalarFunctionCallNode extends PlanNode implements NaryScalarNode {
-	override readonly nodeType = PlanNodeType.ScalarFunctionCall;
-	private readonly _inferredType?: ScalarType;
-
-	constructor(
-		scope: Scope,
-		public readonly expression: AST.FunctionExpr,
-		public readonly functionSchema: FunctionSchema,
-		public readonly operands: ScalarPlanNode[],
-		inferredType?: ScalarType
-	) {
-		super(scope);
-		this._inferredType = inferredType;
-	}
-
-	getType(): ScalarType {
-		// Use inferred type if available, otherwise use schema's return type
-		return this._inferredType ?? (this.functionSchema.returnType as ScalarType);
-	}
-
-	getChildren(): readonly ScalarPlanNode[] {
-		return this.operands;
-	}
-
-	getRelations(): readonly [] {
-		return [];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== this.operands.length) {
-			throw new Error(`ScalarFunctionCallNode expects ${this.operands.length} children, got ${newChildren.length}`);
-		}
-
-		// Type check
-		for (const child of newChildren) {
-			if (!('expression' in child)) {
-				throw new Error('ScalarFunctionCallNode: 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 ScalarFunctionCallNode(
-			this.scope,
-			this.expression,
-			this.functionSchema,
-			newChildren as ScalarPlanNode[],
-			this._inferredType
-		);
-	}
-
-	override toString(): string {
-		return `${this.expression.name}(${formatExpressionList(this.operands)})`;
-	}
-
-	override computePhysical(_childrenPhysical: PhysicalProperties[]): Partial<PhysicalProperties> {
-		// Function calls derive properties from their arguments and the function itself
-		const result: Partial<PhysicalProperties> = {};
-
-		// Use function schema to determine deterministic and readonly properties
-		const functionIsDeterministic = (this.functionSchema.flags & FunctionFlags.DETERMINISTIC) !== 0;
-		const functionIsReadonly = (this.functionSchema.returnType as ScalarType).isReadOnly ?? true;
-
-		// Function is deterministic only if both function and all arguments are deterministic
-		if (!functionIsDeterministic) {
-			result.deterministic = false;
-		}
-
-		// Function is readonly only if both function and all arguments are readonly
-		if (!functionIsReadonly) {
-			result.readonly = false;
-		}
-
-		return result;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			function: this.expression.name,
-			arguments: this.operands.map(op => op.toString()),
-			resultType: formatScalarType(this.functionSchema.returnType as ScalarType)
-		};
-	}
-}