@quereus/quereus 0.7.2 → 0.7.4

package/src/planner/framework/trace.ts

@@ -1,259 +0,0 @@
-/**
- * Trace framework for Titan optimizer rule execution
- * Provides debugging hooks and performance monitoring
- */
-
-import { createLogger } from '../../common/logger.js';
-import type { PlanNode } from '../nodes/plan-node.js';
-import type { RuleHandle } from './registry.js';
-import { isDebugEnabled, isFeatureEnabled } from '../../util/environment.js';
-
-const log = createLogger('optimizer:framework:trace');
-
-/**
- * Trace hooks for optimizer rule execution
- */
-export interface TraceHook {
-	/** Called when a rule starts execution */
-	onRuleStart?(handle: RuleHandle, node: PlanNode): void;
-
-	/** Called when a rule completes execution */
-	onRuleEnd?(handle: RuleHandle, before: PlanNode, after: PlanNode | null): void;
-
-	/** Called when optimizer starts processing a node */
-	onNodeStart?(node: PlanNode): void;
-
-	/** Called when optimizer finishes processing a node */
-	onNodeEnd?(before: PlanNode, after: PlanNode): void;
-
-	/** Called when optimization phase starts */
-	onPhaseStart?(phase: string): void;
-
-	/** Called when optimization phase ends */
-	onPhaseEnd?(phase: string): void;
-}
-
-/**
- * Default trace hook that logs to debug channels
- */
-export class DebugTraceHook implements TraceHook {
-	private readonly ruleLog = createLogger('optimizer:trace:rules');
-	private readonly nodeLog = createLogger('optimizer:trace:nodes');
-	private readonly phaseLog = createLogger('optimizer:trace:phases');
-
-	onRuleStart(handle: RuleHandle, node: PlanNode): void {
-		this.ruleLog('→ %s starting on %s#%s', handle.id, node.nodeType, node.id);
-	}
-
-	onRuleEnd(handle: RuleHandle, before: PlanNode, after: PlanNode | null): void {
-		if (after && after !== before) {
-			this.ruleLog('✓ %s transformed %s#%s → %s#%s',
-				handle.id, before.nodeType, before.id, after.nodeType, after.id);
-		} else {
-			this.ruleLog('– %s not applicable to %s#%s', handle.id, before.nodeType, before.id);
-		}
-	}
-
-	onNodeStart(node: PlanNode): void {
-		this.nodeLog('Processing node %s#%s', node.nodeType, node.id);
-	}
-
-	onNodeEnd(before: PlanNode, after: PlanNode): void {
-		if (before !== after) {
-			this.nodeLog('Node %s#%s → %s#%s',
-				before.nodeType, before.id, after.nodeType, after.id);
-		}
-	}
-
-	onPhaseStart(phase: string): void {
-		this.phaseLog('Starting phase: %s', phase);
-	}
-
-	onPhaseEnd(phase: string): void {
-		this.phaseLog('Completed phase: %s', phase);
-	}
-}
-
-/**
- * Performance monitoring trace hook
- */
-export class PerformanceTraceHook implements TraceHook {
-	private readonly perfLog = createLogger('optimizer:trace:performance');
-	private ruleStartTimes = new Map<string, number>();
-	private phaseStartTimes = new Map<string, number>();
-
-	onRuleStart(handle: RuleHandle, node: PlanNode): void {
-		const key = `${handle.id}:${node.id}`;
-		this.ruleStartTimes.set(key, performance.now());
-	}
-
-	onRuleEnd(handle: RuleHandle, before: PlanNode, _after: PlanNode | null): void {
-		const key = `${handle.id}:${before.id}`;
-		const startTime = this.ruleStartTimes.get(key);
-		if (startTime !== undefined) {
-			const duration = performance.now() - startTime;
-			this.perfLog('Rule %s took %.2fms on %s#%s',
-				handle.id, duration, before.nodeType, before.id);
-			this.ruleStartTimes.delete(key);
-		}
-	}
-
-	onPhaseStart(phase: string): void {
-		this.phaseStartTimes.set(phase, performance.now());
-	}
-
-	onPhaseEnd(phase: string): void {
-		const startTime = this.phaseStartTimes.get(phase);
-		if (startTime !== undefined) {
-			const duration = performance.now() - startTime;
-			this.perfLog('Phase %s took %.2fms', phase, duration);
-			this.phaseStartTimes.delete(phase);
-		}
-	}
-}
-
-/**
- * Composite trace hook that combines multiple hooks
- */
-export class CompositeTraceHook implements TraceHook {
-	constructor(private readonly hooks: TraceHook[]) {}
-
-	onRuleStart(handle: RuleHandle, node: PlanNode): void {
-		for (const hook of this.hooks) {
-			hook.onRuleStart?.(handle, node);
-		}
-	}
-
-	onRuleEnd(handle: RuleHandle, before: PlanNode, after: PlanNode | null): void {
-		for (const hook of this.hooks) {
-			hook.onRuleEnd?.(handle, before, after);
-		}
-	}
-
-	onNodeStart(node: PlanNode): void {
-		for (const hook of this.hooks) {
-			hook.onNodeStart?.(node);
-		}
-	}
-
-	onNodeEnd(before: PlanNode, after: PlanNode): void {
-		for (const hook of this.hooks) {
-			hook.onNodeEnd?.(before, after);
-		}
-	}
-
-	onPhaseStart(phase: string): void {
-		for (const hook of this.hooks) {
-			hook.onPhaseStart?.(phase);
-		}
-	}
-
-	onPhaseEnd(phase: string): void {
-		for (const hook of this.hooks) {
-			hook.onPhaseEnd?.(phase);
-		}
-	}
-}
-
-/**
- * Global trace hook registry
- */
-class TraceRegistry {
-	private currentHook: TraceHook | undefined;
-
-	setTraceHook(hook: TraceHook | undefined): void {
-		this.currentHook = hook;
-		if (hook) {
-			log('Trace hook activated');
-		} else {
-			log('Trace hook deactivated');
-		}
-	}
-
-	getCurrentHook(): TraceHook | undefined {
-		return this.currentHook;
-	}
-
-	/**
-	 * Set up default tracing based on environment variables
-	 */
-	setupDefaultTracing(): void {
-		const hooks: TraceHook[] = [];
-
-		// Enable debug tracing if debug logging is enabled
-		if (isDebugEnabled('optimizer')) {
-			hooks.push(new DebugTraceHook());
-		}
-
-		// Enable performance tracing if requested
-		if (isFeatureEnabled('QUEREUS_OPTIMIZER_PERF')) {
-			hooks.push(new PerformanceTraceHook());
-		}
-
-		if (hooks.length > 0) {
-			this.setTraceHook(new CompositeTraceHook(hooks));
-		}
-	}
-}
-
-/**
- * Global trace registry instance
- */
-const globalTraceRegistry = new TraceRegistry();
-
-/**
- * Set the global trace hook
- */
-export function setTraceHook(hook: TraceHook | undefined): void {
-	globalTraceRegistry.setTraceHook(hook);
-}
-
-/**
- * Get the current trace hook
- */
-export function getCurrentTraceHook(): TraceHook | undefined {
-	return globalTraceRegistry.getCurrentHook();
-}
-
-/**
- * Set up default tracing based on environment
- */
-export function setupDefaultTracing(): void {
-	globalTraceRegistry.setupDefaultTracing();
-}
-
-/**
- * Helper functions for calling trace hooks
- */
-export function traceRuleStart(handle: RuleHandle, node: PlanNode): void {
-	const hook = getCurrentTraceHook();
-	hook?.onRuleStart?.(handle, node);
-}
-
-export function traceRuleEnd(handle: RuleHandle, before: PlanNode, after: PlanNode | null): void {
-	const hook = getCurrentTraceHook();
-	hook?.onRuleEnd?.(handle, before, after);
-}
-
-export function traceNodeStart(node: PlanNode): void {
-	const hook = getCurrentTraceHook();
-	hook?.onNodeStart?.(node);
-}
-
-export function traceNodeEnd(before: PlanNode, after: PlanNode): void {
-	const hook = getCurrentTraceHook();
-	hook?.onNodeEnd?.(before, after);
-}
-
-export function tracePhaseStart(phase: string): void {
-	const hook = getCurrentTraceHook();
-	hook?.onPhaseStart?.(phase);
-}
-
-export function tracePhaseEnd(phase: string): void {
-	const hook = getCurrentTraceHook();
-	hook?.onPhaseEnd?.(phase);
-}
-
-// Initialize default tracing on module load
-setupDefaultTracing();

package/src/planner/nodes/add-constraint-node.ts

@@ -1,62 +0,0 @@
-import type { Scope } from '../scopes/scope.js';
-import { PhysicalProperties, PlanNode, type VoidNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type { TableReferenceNode } from './reference.js';
-import type { VoidType } from '../../common/datatype.js';
-import type * as AST from '../../parser/ast.js';
-
-/**
- * Represents adding a constraint to an existing table.
- * This is a DDL operation that modifies the table schema at runtime.
- */
-export class AddConstraintNode extends PlanNode implements VoidNode {
-  override readonly nodeType = PlanNodeType.AddConstraint;
-
-  constructor(
-    scope: Scope,
-    public readonly table: TableReferenceNode,
-    public readonly constraint: AST.TableConstraint,
-  ) {
-    super(scope);
-  }
-
-  getType(): VoidType {
-    return { typeClass: 'void' };
-  }
-
-  getRelations(): readonly [TableReferenceNode] {
-    return [this.table];
-  }
-
-  getChildren(): readonly PlanNode[] {
-    return [];
-  }
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== 0) {
-      throw new Error(`AddConstraintNode expects 0 children, got ${newChildren.length}`);
-    }
-    return this; // No children, so no change
-  }
-
-  override toString(): string {
-    const constraintType = this.constraint.type.toUpperCase();
-    const constraintName = this.constraint.name || 'unnamed';
-    return `ADD CONSTRAINT ${constraintName} ${constraintType}`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    return {
-      table: this.table.tableSchema.name,
-      schema: this.table.tableSchema.schemaName,
-      constraintType: this.constraint.type,
-      constraintName: this.constraint.name,
-      hasOperations: !!this.constraint.operations,
-      operations: this.constraint.operations,
-    };
-  }
-
-	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
-		return { readonly: false };
-	}
-}

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

@@ -1,155 +0,0 @@
-import type { ScalarType } from '../../common/datatype.js';
-import { PlanNode, type ScalarPlanNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type { Scope } from '../scopes/scope.js';
-import type { FunctionSchema } from '../../schema/function.js';
-import { isAggregateFunctionSchema } from '../../schema/function.js';
-import type * as AST from '../../parser/ast.js';
-import { formatExpressionList, formatScalarType } from '../../util/plan-formatter.js';
-import { NULL_TYPE } from '../../types/builtin-types.js';
-
-/**
- * Represents an aggregate function call within a SQL query.
- * This is specifically for aggregate functions (COUNT, SUM, AVG, etc.)
- */
-export class AggregateFunctionCallNode extends PlanNode implements ScalarPlanNode {
-	readonly nodeType = PlanNodeType.ScalarFunctionCall; // Using same type as scalar functions
-	private readonly _inferredType?: ScalarType;
-
-	constructor(
-		scope: Scope,
-		public readonly expression: AST.FunctionExpr,
-		public readonly functionName: string,
-		public readonly functionSchema: FunctionSchema,
-		public readonly args: ReadonlyArray<ScalarPlanNode>,
-		public readonly isDistinct: boolean = false,
-		public readonly orderBy?: ReadonlyArray<{ expression: ScalarPlanNode; direction: 'asc' | 'desc' }>,
-		public readonly filter?: ScalarPlanNode,
-		inferredType?: ScalarType
-	) {
-		super(scope);
-		this._inferredType = inferredType;
-	}
-
-	getType(): ScalarType {
-		// Use inferred type if available
-		if (this._inferredType) {
-			return this._inferredType;
-		}
-
-		// Get the return type from the function schema
-		if (isAggregateFunctionSchema(this.functionSchema)) {
-			return this.functionSchema.returnType;
-		}
-
-		// Fallback for non-aggregate functions (shouldn't happen)
-		return {
-			typeClass: 'scalar',
-			logicalType: NULL_TYPE,
-			nullable: true, // Aggregates can return NULL
-			isReadOnly: true
-		};
-	}
-
-	getChildren(): readonly ScalarPlanNode[] {
-		const children: ScalarPlanNode[] = [...this.args];
-		if (this.filter) {
-			children.push(this.filter);
-		}
-		if (this.orderBy) {
-			children.push(...this.orderBy.map(item => item.expression));
-		}
-		return children;
-	}
-
-	getRelations(): readonly [] {
-		return [];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		const expectedLength = this.args.length + (this.filter ? 1 : 0) + (this.orderBy?.length || 0);
-		if (newChildren.length !== expectedLength) {
-			throw new Error(`AggregateFunctionCallNode expects ${expectedLength} children, got ${newChildren.length}`);
-		}
-
-		// Type check
-		for (const child of newChildren) {
-			if (!('expression' in child)) {
-				throw new Error('AggregateFunctionCallNode: all children must be ScalarPlanNodes');
-			}
-		}
-
-		// Split children back into their respective arrays
-		let childIndex = 0;
-		const newArgs = newChildren.slice(childIndex, childIndex + this.args.length) as ScalarPlanNode[];
-		childIndex += this.args.length;
-
-		let newFilter: ScalarPlanNode | undefined = undefined;
-		if (this.filter) {
-			newFilter = newChildren[childIndex] as ScalarPlanNode;
-			childIndex++;
-		}
-
-		let newOrderBy: ReadonlyArray<{ expression: ScalarPlanNode; direction: 'asc' | 'desc' }> | undefined = undefined;
-		if (this.orderBy?.length) {
-			const newOrderByExpressions = newChildren.slice(childIndex) as ScalarPlanNode[];
-			newOrderBy = this.orderBy.map((item, i) => ({
-				expression: newOrderByExpressions[i],
-				direction: item.direction
-			}));
-		}
-
-		// Check if anything changed
-		const argsChanged = newArgs.some((arg, i) => arg !== this.args[i]);
-		const filterChanged = newFilter !== this.filter;
-		const orderByChanged = newOrderBy && this.orderBy &&
-			newOrderBy.some((item, i) => item.expression !== this.orderBy![i].expression);
-
-		if (!argsChanged && !filterChanged && !orderByChanged) {
-			return this;
-		}
-
-		// Create new instance
-		return new AggregateFunctionCallNode(
-			this.scope,
-			this.expression,
-			this.functionName,
-			this.functionSchema,
-			newArgs,
-			this.isDistinct,
-			newOrderBy,
-			newFilter,
-			this._inferredType
-		);
-	}
-
-	override toString(): string {
-		const distinctStr = this.isDistinct ? 'DISTINCT ' : '';
-		const argsStr = formatExpressionList(this.args);
-		const filterStr = this.filter ? ` FILTER (WHERE ${this.filter.toString()})` : '';
-		const orderByStr = this.orderBy?.length ? ` ORDER BY ${this.orderBy.map(item => `${item.expression.toString()} ${item.direction.toUpperCase()}`).join(', ')}` : '';
-		return `${this.functionName}(${distinctStr}${argsStr})${filterStr}${orderByStr}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		const props: Record<string, unknown> = {
-			function: this.functionName,
-			arguments: this.args.map(arg => arg.toString()),
-			resultType: formatScalarType(this.getType()),
-			isDistinct: this.isDistinct
-		};
-
-		if (this.filter) {
-			props.filter = this.filter.toString();
-		}
-
-		if (this.orderBy?.length) {
-			props.orderBy = this.orderBy.map(item => ({
-				expression: item.expression.toString(),
-				direction: item.direction
-			}));
-		}
-
-		return props;
-	}
-}