@quereus/quereus 0.7.2 → 0.7.4

package/src/planner/rules/retrieve/rule-grow-retrieve.ts

@@ -1,337 +0,0 @@
-/**
- * Rule: Grow Retrieve
- *
- * Structural sliding rule that maximizes the query segment each virtual table module can execute.
- * This is a bottom-up transformation that slides RetrieveNode boundaries upward to encompass
- * as much of the query pipeline as each module can handle.
- *
- * Applied When:
- * - Node is a unary relational operation (Filter, Project, Sort, LimitOffset)
- * - Child is a RetrieveNode
- * - Virtual table module supports executing the expanded pipeline
- *
- * Benefits:
- * - Maximizes push-down opportunities for query-based modules
- * - Provides fallback support for index-style modules via constraint extraction
- * - Establishes optimal module execution boundaries before cost-based optimization
- */
-
-import { createLogger } from '../../../common/logger.js';
-import { isRelationalNode, type PlanNode, type RelationalPlanNode } from '../../nodes/plan-node.js';
-import type { OptContext } from '../../framework/context.js';
-import { RetrieveNode } from '../../nodes/retrieve-node.js';
-import { FilterNode } from '../../nodes/filter.js';
-import type { TableReferenceNode } from '../../nodes/reference.js';
-import { PlanNodeType } from '../../nodes/plan-node-type.js';
-import type { SupportAssessment } from '../../../vtab/module.js';
-import type { BestAccessPlanRequest, BestAccessPlanResult, PredicateConstraint } from '../../../vtab/best-access-plan.js';
-import { extractConstraints, createTableInfoFromNode, type TableInfo } from '../../analysis/constraint-extractor.js';
-import { normalizePredicate } from '../../analysis/predicate-normalizer.js';
-import { seqScanCost } from '../../cost/index.js';
-import { SortNode } from '../../nodes/sort.js';
-import { extractOrderingFromSortKeys } from '../../framework/physical-utils.js';
-import { LimitOffsetNode } from '../../nodes/limit-offset.js';
-import { PlanNode as _PlanNode } from '../../nodes/plan-node.js';
-import { PlanNodeType as _PlanNodeType } from '../../nodes/plan-node-type.js';
-import { LiteralNode } from '../../nodes/scalar.js';
-import { collectBindingsInPlan } from '../../analysis/binding-collector.js';
-
-const log = createLogger('optimizer:rule:grow-retrieve');
-
-/**
- * Context data stored in RetrieveNode.moduleCtx for index-style fallback
- */
-interface IndexStyleContext {
-	kind: 'index-style';
-	accessPlan: BestAccessPlanResult;
-	residualPredicate?: PlanNode;
-	originalConstraints: PredicateConstraint[];
-}
-
-function isIndexStyleContext(ctx: unknown): ctx is IndexStyleContext {
-	return !!ctx && typeof ctx === 'object' && (ctx as any).kind === 'index-style';
-}
-
-export function ruleGrowRetrieve(node: PlanNode, context: OptContext): PlanNode | null {
-	// This rule runs in a TOP-DOWN pass, looking for any relational operation
-	// above a RetrieveNode that can be pushed into the module's execution boundary
-
-	// Must be a relational node to be growable
-	if (!isRelationalNode(node)) {
-		return null;
-	}
-
-	// Find the RetrieveNode child (if any)
-	const retrieveChild = findRetrieveChild(node);
-	if (!retrieveChild) {
-		return null;
-	}
-
-	const tableRef = retrieveChild.tableRef;
-
-	// Guard: ensure we have required properties
-	if (!tableRef?.tableSchema) {
-		log('RetrieveNode missing tableRef or tableSchema');
-		return null;
-	}
-
-	const tableSchema = tableRef.tableSchema;
-	const vtabModule = tableRef.vtabModule;
-
-	log('Evaluating growth for %s over table %s', node.nodeType, tableSchema.name);
-
-	// If no vtabModule, can't grow
-	if (!vtabModule) {
-		log('No vtabModule available for table %s', tableSchema.name);
-		return null;
-	}
-
-	// Create candidate pipeline by sliding the operation into the retrieve boundary
-	// This replaces the RetrieveNode child with its source in the parent operation
-	const candidatePipeline = replaceRetrieveWithSource(node, retrieveChild);
-
-	// Try module's supports() method first (if available)
-	let assessment: SupportAssessment | undefined;
-
-	if (vtabModule.supports && typeof vtabModule.supports === 'function') {
-		// Query-based module: let it decide if it can handle the pipeline
-		log('Testing module.supports() for %s pipeline', node.nodeType);
-		assessment = vtabModule.supports(candidatePipeline);
-
-		if (assessment) {
-			log('Module supports expanded pipeline (cost: %d)', assessment.cost);
-		} else {
-			log('Module declined expanded pipeline');
-		}
-	}
-
-	// If module doesn't have supports() or declined, try index-style fallback
-	// but ONLY for operations we know can be translated to index constraints
-	if (!assessment && vtabModule.getBestAccessPlan && typeof vtabModule.getBestAccessPlan === 'function') {
-		if (canTranslateToIndexConstraints(node)) {
-			log('Testing index-style fallback for %s', node.nodeType);
-			assessment = fallbackIndexSupports(node, candidatePipeline, context, tableRef);
-
-			if (assessment) {
-				log('Index-style fallback supports pipeline (cost: %d)', assessment.cost);
-			} else {
-				log('Index-style fallback declined pipeline');
-			}
-		} else {
-			log('Node type %s cannot be translated to index constraints', node.nodeType);
-		}
-	}
-
-	if (!assessment) {
-		// Module cannot handle the expanded pipeline
-		return null;
-	}
-
-	// Determine how to slide depending on assessment origin
-	let newPipeline: RelationalPlanNode;
-	let newBindings = [...(retrieveChild.bindings ?? []), ...collectBindingsInPlan(node, retrieveChild.tableRef)];
-
-	if (isIndexStyleContext(assessment.ctx)) {
-		// Index-style fallback: only place supported fragments under Retrieve; keep residuals above
-		newPipeline = candidatePipeline as RelationalPlanNode;
-		if (node instanceof FilterNode) {
-			const tableInfo: TableInfo = createTableInfoFromNode(retrieveChild.tableRef, tableSchema.name);
-			const extraction = extractConstraints(normalizePredicate(node.predicate), [tableInfo]);
-			const supported = extraction.supportedPredicateByTable?.get(tableInfo.relationKey);
-			if (supported) {
-				newPipeline = new FilterNode(
-					retrieveChild.source.scope,
-					(candidatePipeline as FilterNode).source,
-					supported
-				) as unknown as RelationalPlanNode;
-				newBindings = [...(retrieveChild.bindings ?? []), ...collectBindingsInPlan(newPipeline, retrieveChild.tableRef)];
-			}
-		}
-	} else {
-		// Query-based module with supports(): move the entire node into the module boundary
-		newPipeline = candidatePipeline as RelationalPlanNode;
-	}
-
-	const grownRetrieve = new RetrieveNode(
-		node.scope,
-		newPipeline,
-		retrieveChild.tableRef,
-		assessment.ctx,
-		newBindings
-	);
-
-	log('Grew retrieve pipeline for table %s: %s → %s',
-		tableSchema.name, retrieveChild.source.nodeType, candidatePipeline.nodeType);
-
-	return grownRetrieve;
-}
-
-/**
- * Find a RetrieveNode among the children of this node
- */
-function findRetrieveChild(node: PlanNode): RetrieveNode | undefined {
-	const children = node.getChildren();
-	for (const child of children) {
-		if (child instanceof RetrieveNode) {
-			return child;
-		}
-	}
-	return undefined;
-}
-
-/**
- * Replace the RetrieveNode child with its source in the parent operation
- */
-function replaceRetrieveWithSource(parent: PlanNode, retrieveNode: RetrieveNode): PlanNode {
-	const children = parent.getChildren();
-	const newChildren = children.map(child =>
-		child === retrieveNode ? retrieveNode.source : child
-	);
-	return parent.withChildren(newChildren);
-}
-
-/**
- * Check if this node type can be translated to index constraints
- * This is used for the fallback when modules don't implement supports()
- */
-function canTranslateToIndexConstraints(node: PlanNode): boolean {
-	switch (node.nodeType) {
-		case PlanNodeType.Filter:
-			// Filters can be translated to predicates
-			return true;
-		case PlanNodeType.Sort:
-			// Sort can be translated to ordering requirements
-			return true;
-		case PlanNodeType.LimitOffset:
-			// Limit can be passed to index access
-			return true;
-		default:
-			// Other operations (Project, Aggregate, etc.) can't be
-			// meaningfully translated to index constraints
-			return false;
-	}
-}
-
-/**
- * Fallback assessment for index-style modules using getBestAccessPlan
- * Translates various operations to index constraints
- */
-function fallbackIndexSupports(
-	node: PlanNode,
-	candidatePipeline: PlanNode,
-	context: OptContext,
-	tableRef: TableReferenceNode
-): SupportAssessment | undefined {
-
-	const vtabModule = tableRef.vtabModule;
-	const tableSchema = tableRef.tableSchema;
-
-	// Build BestAccessPlanRequest based on node type
-	const request: BestAccessPlanRequest = {
-		columns: tableSchema.columns.map((col, index) => ({
-			index,
-			name: col.name,
-			type: col.logicalType,
-			isPrimaryKey: col.primaryKey || false,
-			isUnique: col.primaryKey || false
-		})),
-		filters: [],
-		requiredOrdering: undefined,
-		limit: undefined,
-		estimatedRows: tableRef.estimatedRows ?? context.stats.tableRows(tableSchema) ?? 1000
-	};
-
-	// Extract information based on node type
-	let residualPredicate: PlanNode | undefined;
-
-	if (node instanceof FilterNode) {
-		// Extract constraints from filter predicate
-		const tableInfo: TableInfo = createTableInfoFromNode(tableRef, tableSchema.name);
-		const normalizedPredicate = normalizePredicate(node.predicate);
-		const extraction = extractConstraints(normalizedPredicate, [tableInfo]);
-
-		if (extraction.allConstraints.length === 0) {
-			log('No extractable constraints from filter predicate');
-			return undefined;
-		}
-
-		request.filters = extraction.allConstraints;
-		residualPredicate = extraction.residualPredicate;
-		log('Extracted %d constraints from Filter', extraction.allConstraints.length);
-
-	} else if (node.nodeType === PlanNodeType.Sort) {
-		// Extract ordering requirements from Sort node
-		const sort = node as unknown as SortNode;
-		const ordering = extractOrderingFromSortKeys(sort.getSortKeys(), sort.source.getAttributes());
-		if (!ordering) {
-			log('Sort node has non-trivial expressions; cannot translate to ordering spec');
-			return undefined;
-		}
-		request.requiredOrdering = ordering.map(o => ({ columnIndex: o.column, desc: o.desc }));
-		log('Extracted ordering requirement of length %d', request.requiredOrdering.length);
-
-	} else if (node.nodeType === PlanNodeType.LimitOffset) {
-		// Extract limit from LimitOffset node when constant
-		const lim = node as unknown as LimitOffsetNode;
-		if (lim.limit && lim.limit.nodeType === _PlanNodeType.Literal) {
-			const limitVal = (lim.limit as unknown as LiteralNode).expression.value;
-			if (typeof limitVal === 'number') {
-				request.limit = Math.max(0, Math.floor(limitVal));
-				log('Extracted limit value: %d', request.limit);
-			}
-		}
-		// We ignore OFFSET for now (modules can implement it internally if desired)
-		if (!request.limit) {
-			log('No usable constant LIMIT found');
-			return undefined;
-		}
-
-	} else {
-		log('Node type %s not supported by index-style fallback', node.nodeType);
-		return undefined;
-	}
-
-	log('Built access plan request: %d filters, ordering: %s, limit: %s',
-		request.filters.length,
-		request.requiredOrdering ? 'yes' : 'no',
-		request.limit ?? 'none');
-
-	// Get access plan from module
-	const accessPlan = vtabModule.getBestAccessPlan!(context.db, tableSchema, request);
-
-	// Check if the plan is beneficial
-	const handlesAnyFilter = request.filters.length > 0 &&
-		accessPlan.handledFilters.some(handled => handled);
-	const providesOrdering = request.requiredOrdering &&
-		accessPlan.providesOrdering;
-
-	// Calculate baseline cost
-	const estimatedRows = request.estimatedRows ?? 1000;
-	const seqCost = seqScanCost(estimatedRows);
-
-	// Accept the plan if it handles filters OR provides required ordering
-	if (!handlesAnyFilter && !providesOrdering) {
-		log('Access plan provides no benefit');
-		return undefined;
-	}
-
-	if (accessPlan.cost >= seqCost && !providesOrdering) {
-		log('Access plan cost (%d) not better than sequential scan (%d)', accessPlan.cost, seqCost);
-		return undefined;
-	}
-
-	log('Index-style fallback beneficial: cost %d vs %d seq scan', accessPlan.cost, seqCost);
-
-	// Store context for later use in ruleSelectAccessPath
-	const indexCtx: IndexStyleContext = {
-		kind: 'index-style',
-		accessPlan,
-		residualPredicate,
-		originalConstraints: [...request.filters] // Copy to satisfy mutable type
-	};
-
-	return {
-		cost: accessPlan.cost,
-		ctx: indexCtx
-	};
-}

package/src/planner/scopes/aliased.ts

@@ -1,50 +0,0 @@
-import type { PlanNode } from "../nodes/plan-node.js";
-import type { Scope } from "./scope.js";
-import { Ambiguous } from "./scope.js";
-import * as AST from "../../parser/ast.js";
-import { BaseScope } from "./base.js";
-
-/**
- * A Scope that aliases a parent scope.
- *
- * @param parent The parent scope, assumed to already be populated with symbols..
- */
-export class AliasedScope extends BaseScope {
-	private readonly _parentName: string;
-	private readonly _alias: string;
-
-	constructor(
-		public readonly parent: Scope,
-		parentName: string,
-		alias: string
-	) {
-		super();
-		this._parentName = parentName.toLowerCase();
-		this._alias = alias.toLowerCase();
-	}
-
-	resolveSymbol(symbolKey: string, expression: AST.Expression): PlanNode | typeof Ambiguous | undefined {
-		const parts = symbolKey.split('.');
-
-		// Handle schema-qualified symbols like "main.j.value"
-		if (parts.length === 3 && parts[1].toLowerCase() === this._alias) {
-			// Replace alias with parent name: "main.j.value" -> "main..value" -> "main.value" (if parent name is empty)
-			if (this._parentName === '') {
-				// For table-valued functions, remove the alias entirely: "main.j.value" -> "value"
-				return this.parent.resolveSymbol(parts[2], expression);
-			} else {
-				parts[1] = this._parentName;
-				return this.parent.resolveSymbol(parts.join('.'), expression);
-			}
-		}
-		// Handle qualified symbols like "j.value"
-		else if (parts.length === 2 && parts[0].toLowerCase() === this._alias) {
-			// For both cases (table-valued functions and regular tables),
-			// just use the column name since the parent scope knows what table it represents
-			return this.parent.resolveSymbol(parts[1], expression);
-		}
-
-		// For all other symbols (including unqualified columns), delegate to parent
-		return this.parent.resolveSymbol(symbolKey, expression);
-	}
-}

package/src/planner/scopes/base.ts

@@ -1,10 +0,0 @@
-import type { PlanNode } from '../nodes/plan-node.js';
-import * as AST from '../../parser/ast.js';
-import { type Scope, Ambiguous } from './scope.js';
-
-/**
- * Scope that tracks references.
- */
-export abstract class BaseScope implements Scope {
-	abstract resolveSymbol(symbolKey: string, expression: AST.Expression): PlanNode | typeof Ambiguous | undefined;
-}

package/src/planner/scopes/empty.ts

@@ -1,12 +0,0 @@
-import * as AST from '../../parser/ast.js';
-import type { PlanNode } from '../nodes/plan-node.js';
-import { type Scope, Ambiguous } from './scope.js';
-
-/** Scope that contains no symbols.  */
-export class EmptyScope implements Scope {
-	resolveSymbol(_symbolKey: string, _expression: AST.Expression): PlanNode | typeof Ambiguous | undefined {
-		return undefined;
-	}
-
-	static readonly instance = new EmptyScope();
-}

package/src/planner/scopes/global.ts

@@ -1,73 +0,0 @@
-import { BaseScope } from "./base.js";
-import type { SchemaManager } from "../../schema/manager.js";
-import type { PlanNode } from "../nodes/plan-node.js";
-import * as AST from "../../parser/ast.js";
-import { FunctionReferenceNode, TableReferenceNode } from "../nodes/reference.js";
-import { Ambiguous } from "./scope.js";
-import type { ScalarType } from "../../common/datatype.js";
-import { isScalarFunctionSchema } from "../../schema/function.js";
-import { REAL_TYPE } from "../../types/builtin-types.js";
-
-export class GlobalScope extends BaseScope {
-	constructor(public readonly manager: SchemaManager) {
-		super();
-	}
-
-	resolveSymbol(symbolKey: string, _expression: AST.Expression): PlanNode | typeof Ambiguous | undefined {
-		if (symbolKey.includes('/')) {// Function: [schema.]name/nArgs
-			const [name, nArgsStr] = symbolKey.split('/');
-			const nArgs = parseInt(nArgsStr);
-			const func = this.manager.findFunction(name, nArgs);
-			if (!func) {
-				return undefined;
-			}
-
-			// Get the proper scalar type from the function schema
-			const scalarType: ScalarType = isScalarFunctionSchema(func)
-				? func.returnType
-				: { typeClass: 'scalar', logicalType: REAL_TYPE, nullable: true, isReadOnly: true };
-
-			return new FunctionReferenceNode(this, func, scalarType);
-		}
-		// Table: [schema.]table
-		const [first, second] = symbolKey.split('.');
-		const schema = second ? first : undefined;
-		const table = second ? second : first;
-		const tableSchema = this.manager.findTable(table, schema);
-		if (!tableSchema) {
-			return undefined;
-		}
-		// Note: GlobalScope can't resolve vtab modules without a planning context
-		// This path is mainly used for constraint checking where we don't need full resolution
-		const vtabModule = this.manager.getModule(tableSchema.vtabModuleName);
-		if (!vtabModule) {
-			return undefined;
-		}
-		return new TableReferenceNode(this, tableSchema, vtabModule.module, vtabModule.auxData);
-	}
-
-	findUnqualifiedName(name: string): PlanNode | typeof Ambiguous | undefined {
-		// Functions have priority over tables.
-		// Check for zero-argument functions first
-		const func = this.manager.findFunction(name, 0);
-		if (func) {
-			// Get the proper scalar type from the function schema
-			const scalarType: ScalarType = isScalarFunctionSchema(func)
-				? func.returnType
-				: { typeClass: 'scalar', logicalType: REAL_TYPE, nullable: true, isReadOnly: true };
-
-			return new FunctionReferenceNode(this, func, scalarType);
-		}
-		// Table: [schema.]table
-		const table = this.manager.findTable(name);
-		if (table) {
-			// TODO: Create a proper ColumnScope to allow column references
-			const vtabModule = this.manager.getModule(table.vtabModuleName);
-			if (!vtabModule) {
-				return undefined;
-			}
-			return new TableReferenceNode(this, table, vtabModule.module, vtabModule.auxData);
-		}
-		return undefined;
-	}
-}

package/src/planner/scopes/multi.ts

@@ -1,40 +0,0 @@
-import { Ambiguous } from "./scope.js";
-import * as AST from "../../parser/ast.js";
-import { QuereusError } from "../../common/errors.js";
-import { StatusCode } from "../../common/types.js";
-import type { PlanNode } from "../nodes/plan-node.js";
-import type { Scope } from "./scope.js";
-import { BaseScope } from "./base.js";
-
-/**
- * A Scope that contains multiple other scopes.
- * Symbols are resolved in order, and the first match is used.
- * If a symbol is found in multiple scopes, an error is thrown.
- */
-export class MultiScope extends BaseScope {
-	constructor(
-		public readonly scopes: Scope[]
-	) {
-		super();
-	}
-
-	registerSymbol(_symbolKey: string, _getReference: (expression: AST.Expression, currentScope: Scope) => PlanNode): void {
-		throw new QuereusError('MultiScope does not support registering symbols.', StatusCode.ERROR);
-	}
-
-	resolveSymbol(symbolKey: string, expression: AST.Expression): PlanNode | typeof Ambiguous | undefined {
-		// In SQL, inner scopes shadow outer scopes for unqualified names
-		// Return the first match, don't treat multiple matches as ambiguous
-		for (const scope of this.scopes) {
-			const result = scope.resolveSymbol(symbolKey, expression);
-			if (result === Ambiguous) {
-				return Ambiguous;
-			}
-			if (result) {
-				return result;
-			}
-		}
-		return undefined;
-	}
-}
-

package/src/planner/scopes/param.ts

@@ -1,95 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import { ParameterReferenceNode } from '../nodes/reference.js'; // Corrected import
-import { BaseScope } from './base.js';
-import { Ambiguous, type Scope } from './scope.js';
-import type { ScalarType } from '../../common/datatype.js';
-import type { PlanNode } from '../nodes/plan-node.js';
-import { TEXT_TYPE } from '../../types/builtin-types.js';
-
-// Default type for parameters when not otherwise specified.
-const DEFAULT_PARAMETER_TYPE: ScalarType = {
-	typeClass: 'scalar',
-	logicalType: TEXT_TYPE,
-	nullable: true,
-};
-
-/**
- * A scope that resolves query parameters (e.g., :name, :1, ?).
- * It makes these parameters available via an accessor.
- */
-export class ParameterScope extends BaseScope {
-	private _nextAnonymousIndex: number = 1;
-	private readonly _parameters: Map<string | number, ParameterReferenceNode> = new Map();
-	private readonly _parameterTypes: ReadonlyMap<string | number, ScalarType>;
-
-	constructor(
-		public readonly parentScope: Scope,
-		parameterTypes?: ReadonlyMap<string | number, ScalarType>
-	) {
-		super();
-		this._parameterTypes = parameterTypes || new Map();
-	}
-
-	resolveSymbol(symbolKey: string, expression: AST.Expression): PlanNode | typeof Ambiguous | undefined {
-		let identifier: string | number;
-		let parameterNode: ParameterReferenceNode | undefined;
-
-		// The expression should be an AST.ParameterExpr when symbolKey indicates a parameter
-		const parameterExpression = expression as AST.ParameterExpr;
-		let resolvedType = DEFAULT_PARAMETER_TYPE;
-
-		if (symbolKey === '?') {
-			// Use the current _nextAnonymousIndex as the potential identifier for this '?'
-			const currentAnonymousId = this._nextAnonymousIndex;
-
-			// Check if this specific anonymous parameter (by its future index) has a declared type
-			if (this._parameterTypes.has(currentAnonymousId)) {
-				resolvedType = this._parameterTypes.get(currentAnonymousId)!;
-			}
-			// Note: We don't check _parameters here for '?' because each '?' AST node should resolve,
-			// potentially creating a new ParameterReferenceNode if it's a new '?' instance in the query,
-			// even if it gets the same numeric index as a previous one *if* they were different AST nodes.
-			// The _parameters map is more for caching resolved nodes per unique AST node or name.
-			// For '?', the ParameterReferenceNode constructor expects the numeric index.
-			// We use currentAnonymousId as the identifier and increment after creation.
-			identifier = currentAnonymousId;
-			parameterNode = new ParameterReferenceNode(this, parameterExpression, identifier, resolvedType);
-			this._parameters.set(identifier, parameterNode); // Cache it by its assigned numeric ID
-			this._nextAnonymousIndex++; // Increment for the *next* '?'
-		} else if (symbolKey.startsWith(':')) {
-			const nameOrIndex = symbolKey.substring(1);
-			const numIndex = parseInt(nameOrIndex, 10);
-			identifier = isNaN(numIndex) ? nameOrIndex : numIndex;
-
-			if (this._parameters.has(identifier)) {
-				parameterNode = this._parameters.get(identifier)!;
-				// If already exists, its type was set at creation
-			} else {
-				if (this._parameterTypes.has(identifier)) {
-					resolvedType = this._parameterTypes.get(identifier)!;
-				}
-				parameterNode = new ParameterReferenceNode(this, parameterExpression, identifier, resolvedType);
-				this._parameters.set(identifier, parameterNode);
-			}
-		} else {
-			// Not a parameter symbol, delegate to parent scope
-			return this.parentScope.resolveSymbol(symbolKey, expression);
-		}
-
-		return parameterNode;
-	}
-
-	/**
-	 * Returns all parameters resolved by this scope.
-	 */
-	getParameters(): ReadonlyMap<string | number, ParameterReferenceNode> {
-		return this._parameters;
-	}
-
-	/**
-	 * Gets the next available anonymous parameter index (1-based) for assigning to new ' ? ' params.
-	 */
-	// getNextAnonymousIndex(): number { // This method might be misleading as index is auto-assigned.
-	// 	return this._nextAnonymousIndex;
-	// }
-}

package/src/planner/scopes/registered.ts

@@ -1,67 +0,0 @@
-import { StatusCode } from '../../common/types.js';
-import { QuereusError } from '../../common/errors.js';
-import type { PlanNode } from '../nodes/plan-node.js';
-import * as AST from '../../parser/ast.js';
-import { type ReferenceCallback, type Scope, Ambiguous } from './scope.js';
-
-/**
- * The Scope object provides context for symbol resolution during query planning.
- * It encapsulates the logic for looking up columns, parameters, functions, and CTEs
- * based on the current position in the PlanNode tree.
- */
-export class RegisteredScope implements Scope {
-	/** Symbols that have been registered in this scope. */
-	private registeredSymbols: Map<string, ReferenceCallback> = new Map();
-
-	constructor(
-		/** The parent scope, if any. The root scope of a query has no parent. */
-		public readonly parent?: Scope,
-	) { }
-
-	/**
-	 * Registers a symbol (like a table alias, CTE name, or parameter) with a factory function
-	 * that can produce a ReferenceNode for it when encountered in an expression.
-	 *
-	 * @param symbolKey The unique string key for this symbol in the current scope.
-	 *  For tables/aliases: lower-case name.
-	 *  For qualified schema.table: "schema.table" (lower-case).
-	 *  For parameters: ":name" or ":index".
-	 * @param getReference A factory function that takes the matching symbol and the current Scope,
-	 *  and returns an appropriate ReferenceNode.
-	 */
-	registerSymbol(symbolKey: string, getReference: ReferenceCallback): void {
-		const lowerSymbolKey = symbolKey.toLowerCase();
-		if (this.registeredSymbols.has(lowerSymbolKey)) {
-			throw new QuereusError(`Symbol '${lowerSymbolKey}' already exists in the same scope.`, StatusCode.ERROR);
-		}
-		this.registeredSymbols.set(lowerSymbolKey, getReference);
-	}
-
-	subscribeFactory(symbolKey: string, factory: ReferenceCallback): void {
-		const lower = symbolKey.toLowerCase();
-		if (this.registeredSymbols.has(lower)) {
-			throw new QuereusError(`Symbol '${lower}' already exists in the same scope.`, StatusCode.ERROR);
-		}
-		this.registeredSymbols.set(lower, factory);
-	}
-
-	resolveSymbol(symbolKey: string, expression: AST.Expression): PlanNode | typeof Ambiguous | undefined {
-		const reference = this.registeredSymbols.get(symbolKey.toLowerCase());
-		if (reference) {
-			return reference(expression, this);
-		}
-		if (this.parent) {
-			return this.parent.resolveSymbol(symbolKey, expression);
-		}
-		return undefined;
-	}
-
-	/**
-	 * Returns all symbols that have been registered in this scope.
-	 *
-	 * @returns An array of all [symbolKey, ReferenceCallback].
-	 */
-	getSymbols(): readonly [string, ReferenceCallback][] {
-		return Array.from(this.registeredSymbols.entries());
-	}
-}