@quereus/quereus 0.7.3 → 0.7.5

package/src/parser/utils.ts

@@ -1,10 +0,0 @@
-import { quereusError } from '../common/errors.js';
-import { SqlValue } from '../common/types.js';
-import type { LiteralExpr } from './ast.js';
-
-export function getSyncLiteral(literal: LiteralExpr): SqlValue {
-	if (literal.value instanceof Promise) {
-		quereusError('Literal value is a promise');
-	}
-	return literal.value;
-}

package/src/parser/visitor.ts

@@ -1,188 +0,0 @@
-import { createLogger } from '../common/logger.js';
-import type * as AST from './ast.js';
-
-const log = createLogger('parser:visitor'); // Create logger instance
-const warnLog = log.extend('warn');
-
-
-/**
- * Defines the callbacks for the AST visitor.
- * Functions can return false to stop traversal down that branch.
- */
-export interface AstVisitorCallbacks {
-	enterNode?: (node: AST.AstNode) => void | boolean;
-	exitNode?: (node: AST.AstNode) => void;
-	// Specific node type visitors (optional)
-	visitSelect?: (node: AST.SelectStmt) => void | boolean;
-	visitInsert?: (node: AST.InsertStmt) => void | boolean;
-	visitUpdate?: (node: AST.UpdateStmt) => void | boolean;
-	visitDelete?: (node: AST.DeleteStmt) => void | boolean;
-	visitValues?: (node: AST.ValuesStmt) => void | boolean;
-	visitTableSource?: (node: AST.TableSource) => void | boolean;
-	visitJoin?: (node: AST.JoinClause) => void | boolean;
-	visitFunctionSource?: (node: AST.FunctionSource) => void | boolean;
-	visitSubquerySource?: (node: AST.SubquerySource) => void | boolean;
-	visitBinaryExpr?: (node: AST.BinaryExpr) => void | boolean;
-	visitUnaryExpr?: (node: AST.UnaryExpr) => void | boolean;
-	visitCastExpr?: (node: AST.CastExpr) => void | boolean;
-	visitCollateExpr?: (node: AST.CollateExpr) => void | boolean;
-	visitFunctionExpr?: (node: AST.FunctionExpr) => void | boolean;
-	visitSubqueryExpr?: (node: AST.SubqueryExpr) => void | boolean;
-	visitWindowFunctionExpr?: (node: AST.WindowFunctionExpr) => void | boolean;
-	visitWindowDefinition?: (node: AST.WindowDefinition) => void | boolean;
-	visitLiteral?: (node: AST.LiteralExpr) => void;
-	visitIdentifier?: (node: AST.IdentifierExpr) => void;
-	visitColumn?: (node: AST.ColumnExpr) => void;
-	visitParameter?: (node: AST.ParameterExpr) => void;
-}
-/**
- * Performs a depth-first traversal of the AST.
- *
- * @param node The starting AST node.
- * @param callbacks An object containing visitor functions for different node types.
- */
-export function traverseAst(node: AST.AstNode | undefined, callbacks: AstVisitorCallbacks): void {
-	if (!node) return;
-
-	if (callbacks.enterNode) {
-		const result = callbacks.enterNode(node);
-		if (result !== false) return; // Stop if enterNode returns false
-	}
-
-	// Call specific visitor if defined
-	const specificVisitorKey = `visit${node.type.charAt(0).toUpperCase() + node.type.slice(1)}` as keyof AstVisitorCallbacks;
-	if (callbacks[specificVisitorKey]) {
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		const specificVisitor = callbacks[specificVisitorKey] as (n: any) => void | boolean;
-		const result = specificVisitor(node);
-		if (result !== false) return; // Stop if specific visitor returns false
-	}
-
-	// Recursively traverse children based on node type
-	switch (node.type) {
-		case 'select': {
-			const stmt = node as AST.SelectStmt;
-			(stmt.columns ?? []).forEach(c => c.type === 'column' && traverseAst(c.expr, callbacks));
-			(stmt.from ?? []).forEach(f => traverseAst(f, callbacks));
-			traverseAst(stmt.where, callbacks);
-			(stmt.groupBy ?? []).forEach(g => traverseAst(g, callbacks));
-			traverseAst(stmt.having, callbacks);
-			(stmt.orderBy ?? []).forEach(o => traverseAst(o.expr, callbacks));
-			traverseAst(stmt.limit, callbacks);
-			traverseAst(stmt.offset, callbacks);
-			traverseAst(stmt.union, callbacks);
-			break;
-		}
-		case 'insert': {
-			const stmt = node as AST.InsertStmt;
-			traverseAst(stmt.table, callbacks);
-			(stmt.values ?? []).forEach(row => row.forEach(v => traverseAst(v, callbacks)));
-			traverseAst(stmt.select, callbacks);
-			break;
-		}
-		case 'update': {
-			const stmt = node as AST.UpdateStmt;
-			traverseAst(stmt.table, callbacks);
-			stmt.assignments.forEach(a => traverseAst(a.value, callbacks));
-			traverseAst(stmt.where, callbacks);
-			break;
-		}
-		case 'delete': {
-			const stmt = node as AST.DeleteStmt;
-			traverseAst(stmt.table, callbacks);
-			traverseAst(stmt.where, callbacks);
-			break;
-		}
-		case 'values': {
-			const stmt = node as AST.ValuesStmt;
-			stmt.values.forEach(row => row.forEach(v => traverseAst(v, callbacks)));
-			break;
-		}
-		case 'table':
-			// Handled by specific visitor or enterNode
-			break;
-		case 'join': {
-			const join = node as AST.JoinClause;
-			traverseAst(join.left, callbacks);
-			traverseAst(join.right, callbacks);
-			traverseAst(join.condition, callbacks);
-			break;
-		}
-		case 'functionSource': {
-			const funcSource = node as AST.FunctionSource;
-			traverseAst(funcSource.name, callbacks);
-			funcSource.args.forEach(a => traverseAst(a, callbacks));
-			break;
-		}
-		case 'subquerySource': {
-			const subqSource = node as AST.SubquerySource;
-			traverseAst(subqSource.subquery, callbacks);
-			break;
-		}
-		case 'binary': {
-			const expr = node as AST.BinaryExpr;
-			traverseAst(expr.left, callbacks);
-			traverseAst(expr.right, callbacks);
-			break;
-		}
-		case 'unary':
-		case 'cast':
-		case 'collate': {
-			traverseAst((node as AST.UnaryExpr | AST.CastExpr | AST.CollateExpr).expr, callbacks);
-			break;
-		}
-		case 'function': {
-			const func = node as AST.FunctionExpr;
-			func.args.forEach(a => traverseAst(a, callbacks));
-			break;
-		}
-		case 'subquery': {
-			const subq = node as AST.SubqueryExpr;
-			traverseAst(subq.query, callbacks);
-			break;
-		}
-		case 'windowFunction': {
-			const winFunc = node as AST.WindowFunctionExpr;
-			traverseAst(winFunc.function, callbacks);
-			traverseAst(winFunc.window, callbacks);
-			break;
-		}
-		case 'windowDefinition': {
-			const winDef = node as AST.WindowDefinition;
-			(winDef.partitionBy ?? []).forEach(p => traverseAst(p, callbacks));
-			(winDef.orderBy ?? []).forEach(o => traverseAst(o.expr, callbacks));
-			// traverseAst(winDef.frame, callbacks); // TODO: Traverse frame bounds if needed
-			break;
-		}
-		// Leaf nodes (literal, identifier, column, parameter) are handled by specific visitors or enterNode
-		case 'literal':
-		case 'identifier':
-		case 'column':
-		case 'parameter':
-			break;
-		// DDL / Transaction statements - might need traversal depending on use case
-		// Currently not traversing into them
-		case 'createTable':
-		case 'createIndex':
-		case 'createView':
-		case 'alterTable':
-		case 'drop':
-		case 'begin':
-		case 'commit':
-		case 'rollback':
-		case 'savepoint':
-		case 'release':
-		case 'pragma':
-		case 'with': // Usually handled separately before main traversal
-		case 'commonTableExpr': // Usually handled separately
-			break;
-		// Default case for unhandled node types
-		default:
-			warnLog(`AST Visitor: Unhandled node type: ${node.type}`);
-			break;
-	}
-
-	if (callbacks.exitNode) {
-		callbacks.exitNode(node);
-	}
-}

package/src/planner/analysis/README.md

@@ -1,93 +0,0 @@
-# Constant Folding Implementation
-
-This directory contains the Phase 3 constant folding implementation for the Titan optimizer.
-
-## Overview
-
-The constant folding system implements the two-phase algorithm described in `docs/optimizer-const.md`:
-
-1. **Bottom-up classification**: Assign `ConstInfo` to every node during post-order DFS
-2. **Top-down propagation**: Walk relational tree carrying known constant attributes
-
-## Files
-
-### `const-pass.ts`
-Core constant folding analysis with:
-- `ConstInfo` types: `const`, `dep`, `non-const`
-- `classifyConstants()` - bottom-up classification using generic tree walking
-- `applyConstPropagation()` - top-down propagation and folding
-- Framework ready for runtime-based evaluation
-
-### `const-evaluator.ts`
-Runtime-based expression evaluation:
-- `createRuntimeExpressionEvaluator()` - uses existing runtime via mini-scheduler
-- Avoids duplicate expression interpreter by reusing `emitPlanNode()` + `Scheduler`
-- Minimal `RuntimeContext` for constant-only evaluation
-
-### `constraint-extractor.ts`
-Existing predicate analysis utilities (Phase 0 infrastructure).
-
-## Integration Points
-
-### Builder Level
-```typescript
-import { foldScalars } from '../util/fold-scalars.js';
-
-// In VALUES, default expressions, etc.
-const foldedExpr = foldScalars(originalExpression);
-```
-
-### Optimizer Rules
-Constant folding runs as early `rewrite` phase rules (priority 10) targeting nodes with expressions:
-- Project (projection expressions)
-- Filter (predicate expressions) 
-- Window, Aggregate, Sort, Values, Join
-
-### Key Design Principles
-
-✅ **Generic Tree Walking**: Uses `getChildren()`/`withChildren()` exclusively
-✅ **Minimal Node-Type Knowledge**: Only checks types for targeting, not folding logic
-✅ **Expression Boundary Triggering**: Only runs on relational nodes with expressions
-✅ **Functional Safety**: Only folds expressions marked as `functional` (pure + deterministic)
-✅ **Attribute ID Preservation**: Maintains column reference validity through transformations
-
-## Usage
-
-### Basic Builder Usage
-```typescript
-import { foldScalars } from '../util/fold-scalars.js';
-
-// Automatically fold constant expressions in builders
-const expr = buildExpression(ctx, ast);
-const folded = foldScalars(expr); // e.g., "1 + 2 * 3" → "7"
-```
-
-### Advanced Runtime-Based Usage
-```typescript
-import { classifyConstants, applyConstPropagation, createConstFoldingContext } from '../analysis/const-pass.js';
-import { createRuntimeExpressionEvaluator } from '../analysis/const-evaluator.js';
-
-// For complex expressions requiring runtime evaluation
-const evaluator = createRuntimeExpressionEvaluator(database);
-const ctx = createConstFoldingContext(evaluator);
-classifyConstants(planTree, ctx);
-const foldedTree = applyConstPropagation(relationalNode, ctx);
-```
-
-### Debug Tracing
-```bash
-# Enable constant folding debug output
-DEBUG=quereus:optimizer:folding* yarn test
-```
-
-## Current Status
-
-- ✅ Infrastructure complete with `functional` flag and generic tree walking
-- ✅ Synchronous folding for basic arithmetic/logical operations  
-- ✅ Optimizer rule integration using generic `getProducingExprs()` interface
-- ✅ `MaybePromise<SqlValue>` support for async subquery constant folding
-- ✅ Builder-level utility for immediate expression folding
-- 🔄 Runtime evaluation framework ready for complex expressions
-- 🔄 Advanced expression types (CASE, CAST, functions) need implementation
-
-The implementation provides immediate value through synchronous folding while supporting promise-based values for subquery constants, eliminating the "projection list" specificity through the generic `getProducingExprs()` interface. 

package/src/planner/analysis/binding-collector.ts

@@ -1,83 +0,0 @@
-import type { PlanNode, ScalarPlanNode } from '../nodes/plan-node.js';
-import { isRelationalNode } from '../nodes/plan-node.js';
-import { PlanNodeType } from '../nodes/plan-node-type.js';
-import type { TableReferenceNode, ColumnReferenceNode } from '../nodes/reference.js';
-
-function buildAttrIdSet(tableRef: TableReferenceNode): Set<number> {
-	const set = new Set<number>();
-	for (const attr of tableRef.getAttributes()) set.add(attr.id);
-	return set;
-}
-
-export function collectBindingsInExpr(expr: ScalarPlanNode, tableRef: TableReferenceNode): ScalarPlanNode[] {
-	const targetAttrIds = buildAttrIdSet(tableRef);
-	const result: ScalarPlanNode[] = [];
-
-	function walkScalar(node: ScalarPlanNode): void {
-		// Parameter bindings
-		if (node.nodeType === PlanNodeType.ParameterReference) {
-			result.push(node);
-			return;
-		}
-		// Correlated column refs (not produced by tableRef)
-		if (node.nodeType === PlanNodeType.ColumnReference) {
-			const col = node as unknown as ColumnReferenceNode;
-			if (!targetAttrIds.has(col.attributeId)) {
-				result.push(node);
-				return;
-			}
-		}
-		// Recurse into scalar children
-		for (const child of node.getChildren()) {
-			// child here should also be scalar nodes
-			walkScalar(child as unknown as ScalarPlanNode);
-		}
-	}
-
-	walkScalar(expr);
-	return dedupeById(result);
-}
-
-export function collectBindingsInPlan(plan: PlanNode, tableRef: TableReferenceNode): ScalarPlanNode[] {
-	const targetAttrIds = buildAttrIdSet(tableRef);
-	const result: ScalarPlanNode[] = [];
-
-	function walk(node: PlanNode): void {
-		if (!isRelationalNode(node)) {
-			// Scalar node
-			const scalar = node as unknown as ScalarPlanNode;
-			if (scalar.nodeType === PlanNodeType.ParameterReference) {
-				result.push(scalar);
-				return;
-			}
-			if (scalar.nodeType === PlanNodeType.ColumnReference) {
-				const col = scalar as unknown as ColumnReferenceNode;
-				if (!targetAttrIds.has(col.attributeId)) {
-					result.push(scalar);
-					return;
-				}
-			}
-		}
-		// Recurse into all children (relational and scalar)
-		for (const child of node.getChildren()) {
-			walk(child);
-		}
-	}
-
-	walk(plan);
-	return dedupeById(result);
-}
-
-function dedupeById(nodes: ScalarPlanNode[]): ScalarPlanNode[] {
-	const seen = new Set<string>();
-	const out: ScalarPlanNode[] = [];
-	for (const n of nodes) {
-		if (!seen.has(n.id)) {
-			seen.add(n.id);
-			out.push(n);
-		}
-	}
-	return out;
-}
-
-

package/src/planner/analysis/const-evaluator.ts

@@ -1,63 +0,0 @@
-/**
- * Runtime-based expression evaluator for constant folding
- *
- * This module provides evaluation of constant expressions using the existing runtime
- * through a mini-scheduler, avoiding the need for a separate expression interpreter.
- */
-
-import type { MaybePromise, OutputValue } from '../../common/types.js';
-import type { Database } from '../../core/database.js';
-import { emitPlanNode } from '../../runtime/emitters.js';
-import { EmissionContext } from '../../runtime/emission-context.js';
-import { Scheduler } from '../../runtime/scheduler.js';
-import type { RuntimeContext } from '../../runtime/types.js';
-import { createLogger } from '../../common/logger.js';
-import { PlanNode } from '../nodes/plan-node.js';
-
-const log = createLogger('optimizer:folding:eval');
-
-/**
- * Create an expression evaluator that uses the runtime to evaluate constant expressions
- */
-export function createRuntimeExpressionEvaluator(db: Database): (expr: PlanNode) => MaybePromise<OutputValue> {
-	return function evaluateExpression(expr: PlanNode): MaybePromise<OutputValue> {
-		log('Evaluating constant expression: %s', expr.nodeType);
-
-		try {
-			// Create temporary emission context
-			const emissionCtx = new EmissionContext(db);
-
-			// Emit the expression to an instruction
-			const instruction = emitPlanNode(expr, emissionCtx);
-
-			// Create a scheduler to execute the instruction
-			const scheduler = new Scheduler(instruction);
-
-			// Create minimal runtime context for evaluation
-			// No row context is needed since we only evaluate constant expressions
-			const runtimeCtx: RuntimeContext = {
-				db,
-				stmt: undefined,
-				params: {}, // No parameters needed for constants
-				context: new Map(), // No row context needed
-				tableContexts: new Map(), // No table contexts needed for constants
-				enableMetrics: false
-			};
-
-			// Execute and get the result
-			const result = scheduler.run(runtimeCtx);
-
-			// Ensure result is a valid OutputValue
-			if (result === undefined) {
-				throw new Error('Expression evaluation returned undefined');
-			}
-
-			log('Expression evaluated to: %s', result);
-			return result as MaybePromise<OutputValue>;
-
-		} catch (error) {
-			log('Failed to evaluate expression %s: %s', expr.nodeType, error);
-			throw new Error(`Expression evaluation failed: ${error}`);
-		}
-	};
-}