@quereus/quereus 0.7.3 → 0.7.5

package/src/planner/building/select-modifiers.ts

@@ -1,236 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { RelationalPlanNode } from '../nodes/plan-node.js';
-import type { PlanningContext } from '../planning-context.js';
-import type { Scope } from '../scopes/scope.js';
-import { ProjectNode, type Projection } from '../nodes/project-node.js';
-import { DistinctNode } from '../nodes/distinct-node.js';
-import { SortNode, type SortKey } from '../nodes/sort.js';
-import { LimitOffsetNode } from '../nodes/limit-offset.js';
-import { LiteralNode } from '../nodes/scalar.js';
-import { MultiScope } from '../scopes/multi.js';
-import { RegisteredScope } from '../scopes/registered.js';
-import { ColumnReferenceNode } from '../nodes/reference.js';
-import { buildExpression } from './expression.js';
-import { CapabilityDetectors } from '../framework/characteristics.js';
-
-/**
- * Creates final output projections and applies result column aliases
- */
-export function buildFinalProjections(
-	input: RelationalPlanNode,
-	projections: Projection[],
-	selectScope: Scope,
-	stmt: AST.SelectStmt,
-	selectContext: PlanningContext,
-	preserveInputColumns: boolean = true
-): {
-	output: RelationalPlanNode;
-	finalContext: PlanningContext;
-	projectionScope?: RegisteredScope;
-	preAggregateSort: boolean;
-} {
-	if (projections.length === 0) {
-		return { output: input, finalContext: selectContext, preAggregateSort: false };
-	}
-
-	// Skip ProjectNode entirely for identity projections (SELECT * equivalent)
-	// This avoids unnecessary per-row overhead when all columns pass through unchanged
-	if (isIdentityProjection(projections, input)) {
-		return { output: input, finalContext: selectContext, preAggregateSort: false };
-	}
-
-	// Check if ORDER BY should be applied before projection (using input scope only)
-	const needsPreProjectionSort = shouldApplyOrderByBeforeProjection(stmt, projections);
-	let preAggregateSort = false;
-
-	let currentInput = input;
-
-	// Apply ORDER BY before projection if needed (compile expressions against input scope)
-	if (needsPreProjectionSort && stmt.orderBy && stmt.orderBy.length > 0) {
-		const sortKeys: SortKey[] = stmt.orderBy.map(orderByClause => {
-			const expression = buildExpression(selectContext, orderByClause.expr);
-			return {
-				expression,
-				direction: orderByClause.direction,
-				nulls: orderByClause.nulls
-			};
-		});
-		currentInput = new SortNode(selectScope, currentInput, sortKeys);
-		preAggregateSort = true;
-	}
-
-	// Create the ProjectNode only after all expressions are compiled against input scope
-	currentInput = new ProjectNode(selectScope, currentInput, projections, undefined, undefined, preserveInputColumns);
-
-	// Create projection output scope but DON'T merge it into finalContext yet
-	// Let the caller decide when to make these output attributes visible
-	const projectionOutputScope = createProjectionOutputScope(currentInput);
-
-	return {
-		output: currentInput,
-		finalContext: selectContext, // Keep unchanged - no premature scope pollution
-		projectionScope: projectionOutputScope,
-		preAggregateSort
-	};
-}
-
-/**
- * Applies DISTINCT if specified
- */
-export function applyDistinct(
-	input: RelationalPlanNode,
-	stmt: AST.SelectStmt,
-	selectScope: Scope
-): RelationalPlanNode {
-	if (stmt.distinct) {
-		return new DistinctNode(selectScope, input);
-	}
-	return input;
-}
-
-/**
- * Applies ORDER BY clause if not already applied
- */
-export function applyOrderBy(
-	input: RelationalPlanNode,
-	stmt: AST.SelectStmt,
-	selectContext: PlanningContext,
-	preAggregateSort: boolean,
-	projectionScope?: RegisteredScope
-): RelationalPlanNode {
-	if (stmt.orderBy && stmt.orderBy.length > 0 && !preAggregateSort) {
-		// Merge projection scope if available so ORDER BY can reference output column aliases
-		let orderByContext = selectContext;
-		if (projectionScope) {
-			const combinedScope = new MultiScope([projectionScope, selectContext.scope]);
-			orderByContext = { ...selectContext, scope: combinedScope };
-		}
-
-		const sortKeys: SortKey[] = stmt.orderBy.map(orderByClause => {
-			const expression = buildExpression(orderByContext, orderByClause.expr);
-			return {
-				expression,
-				direction: orderByClause.direction,
-				nulls: orderByClause.nulls
-			};
-		});
-
-		return new SortNode(orderByContext.scope, input, sortKeys);
-	}
-	return input;
-}
-
-/**
- * Applies LIMIT and OFFSET clauses
- */
-export function applyLimitOffset(
-	input: RelationalPlanNode,
-	stmt: AST.SelectStmt,
-	selectContext: PlanningContext,
-	projectionScope?: RegisteredScope
-): RelationalPlanNode {
-	if (stmt.limit || stmt.offset) {
-		// Merge projection scope if available so LIMIT/OFFSET can reference output column aliases
-		let limitContext = selectContext;
-		if (projectionScope) {
-			const combinedScope = new MultiScope([projectionScope, selectContext.scope]);
-			limitContext = { ...selectContext, scope: combinedScope };
-		}
-
-		const literalNull = new LiteralNode(limitContext.scope, { type: 'literal', value: null });
-		const limitExpression = stmt.limit ? buildExpression(limitContext, stmt.limit) : literalNull;
-		const offsetExpression = stmt.offset ? buildExpression(limitContext, stmt.offset) : literalNull;
-		return new LimitOffsetNode(limitContext.scope, input, limitExpression, offsetExpression);
-	}
-	return input;
-}
-
-/**
- * Determines if ORDER BY should be applied before projection
- */
-function shouldApplyOrderByBeforeProjection(
-	stmt: AST.SelectStmt,
-	projections: Projection[]
-): boolean {
-	if (!stmt.orderBy || stmt.orderBy.length === 0) {
-		return false;
-	}
-
-	// Check if any ORDER BY column is not in the projection aliases
-	for (const orderByClause of stmt.orderBy) {
-		if (orderByClause.expr.type === 'column') {
-			const orderColumn = orderByClause.expr.name.toLowerCase();
-			// Check if this column is in the projection aliases
-			const isInProjection = projections.some(proj =>
-				(proj.alias?.toLowerCase() === orderColumn) ||
-				(CapabilityDetectors.isColumnReference(proj.node) && proj.node.expression.name.toLowerCase() === orderColumn)
-			);
-			if (!isInProjection) {
-				return true;
-			}
-		}
-	}
-
-	return false;
-}
-
-/**
- * Creates a scope for projection output columns
- */
-function createProjectionOutputScope(projectionNode: RelationalPlanNode): RegisteredScope {
-	const projectionOutputScope = new RegisteredScope();
-	const projectionAttributes = projectionNode.getAttributes();
-
-	projectionNode.getType().columns.forEach((col, index) => {
-		const attr = projectionAttributes[index];
-		projectionOutputScope.registerSymbol(col.name.toLowerCase(), (exp, s) =>
-			new ColumnReferenceNode(s, exp as AST.ColumnExpr, col.type, attr.id, index));
-	});
-
-	return projectionOutputScope;
-}
-
-/**
- * Detects if projections form an identity transformation over the source.
- * An identity projection is one where all projections are simple column references
- * that reference source attributes in order with no name changes.
- * This allows skipping the ProjectNode entirely for SELECT * queries.
- */
-function isIdentityProjection(projections: Projection[], source: RelationalPlanNode): boolean {
-	const sourceAttrs = source.getAttributes();
-
-	// Must have same number of projections as source attributes
-	if (projections.length !== sourceAttrs.length) {
-		return false;
-	}
-
-	for (let i = 0; i < projections.length; i++) {
-		const proj = projections[i];
-		const sourceAttr = sourceAttrs[i];
-
-		// Must be a column reference
-		if (!CapabilityDetectors.isColumnReference(proj.node)) {
-			return false;
-		}
-
-		const colRef = proj.node;
-
-		// Must reference the corresponding source attribute (preserves order)
-		if (colRef.attributeId !== sourceAttr.id) {
-			return false;
-		}
-
-		// Determine the effective output column name:
-		// - If there's an explicit alias, use it
-		// - Otherwise, use the column reference's name (from the SELECT expression)
-		const effectiveOutputName = proj.alias || colRef.expression.name;
-
-		// The effective output name must match the source attribute name
-		// If they differ, we need a ProjectNode to rename the column
-		if (effectiveOutputName.toLowerCase() !== sourceAttr.name.toLowerCase()) {
-			return false;
-		}
-	}
-
-	return true;
-}

package/src/planner/building/select-projections.ts

@@ -1,177 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import { type ScalarPlanNode } from '../nodes/plan-node.js';
-import type { PlanningContext } from '../planning-context.js';
-import type { Projection } from '../nodes/project-node.js';
-import { buildExpression } from './expression.js';
-import { ColumnReferenceNode } from '../nodes/reference.js';
-import { expressionToString } from '../../util/ast-stringify.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { AggregateFunctionCallNode as _AggregateFunctionCallNode } from '../nodes/aggregate-function.js';
-import { WindowFunctionCallNode } from '../nodes/window-function.js';
-import { type RelationalPlanNode } from '../nodes/plan-node.js';
-import type { Scope } from '../scopes/scope.js';
-import { CapabilityDetectors } from '../framework/characteristics.js';
-
-/**
- * Checks if an expression contains aggregate functions
- */
-export function isAggregateExpression(node: ScalarPlanNode): boolean {
-	if (CapabilityDetectors.isAggregateFunction(node)) {
-		return true;
-	}
-
-	// Recursively check children (only scalar children)
-	for (const child of node.getChildren()) {
-		// Check if child is a scalar node and recursively check it
-		if ('expression' in child && isAggregateExpression(child as ScalarPlanNode)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Checks if an expression contains window functions
- */
-export function isWindowExpression(node: ScalarPlanNode): boolean {
-	if (CapabilityDetectors.isWindowFunction(node)) {
-		return true;
-	}
-
-	// Recursively check children (only scalar children)
-	for (const child of node.getChildren()) {
-		// Check if child is a scalar node and recursively check it
-		if ('expression' in child && isWindowExpression(child as ScalarPlanNode)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Builds projections for SELECT * or table.*
- */
-export function buildStarProjections(
-	column: { type: 'all'; table?: string },
-	source: RelationalPlanNode,
-	selectScope: Scope
-): Projection[] {
-	const allAttributes = source.getAttributes();
-
-	// Filter by relation name if qualified (e.g., SELECT t1.*)
-	const matchingAttributes = column.table
-		? allAttributes.filter(attr =>
-			attr.relationName && attr.relationName.toLowerCase() === column.table!.toLowerCase()
-		)
-		: allAttributes;
-
-	if (column.table && matchingAttributes.length === 0) {
-		throw new QuereusError(
-			`Table '${column.table}' not found in FROM clause for qualified SELECT *`,
-			StatusCode.ERROR
-		);
-	}
-
-	// Convert to projections
-	return matchingAttributes.map((attr, index) => {
-		const columnExpr: AST.ColumnExpr = {
-			type: 'column',
-			name: attr.name,
-		};
-
-		const columnRef = new ColumnReferenceNode(
-			selectScope,
-			columnExpr,
-			attr.type,
-			attr.id,
-			index
-		);
-
-		return {
-			node: columnRef,
-			alias: attr.name
-		};
-	});
-}
-
-/**
- * Analyzes SELECT columns and categorizes them into different types
- */
-export function analyzeSelectColumns(
-	columns: AST.ResultColumn[],
-	selectContext: PlanningContext
-): {
-	projections: Projection[];
-	aggregates: { expression: ScalarPlanNode; alias: string }[];
-	windowFunctions: { func: WindowFunctionCallNode; alias?: string }[];
-	hasAggregates: boolean;
-	hasWindowFunctions: boolean;
-} {
-	const projections: Projection[] = [];
-	const aggregates: { expression: ScalarPlanNode; alias: string }[] = [];
-	const windowFunctions: { func: WindowFunctionCallNode; alias?: string }[] = [];
-	let hasAggregates = false;
-	let hasWindowFunctions = false;
-
-	for (const column of columns) {
-		if (column.type === 'all') {
-			// Handle SELECT * - will be processed separately
-			continue;
-		} else if (column.type === 'column') {
-			const scalarNode = buildExpression(selectContext, column.expr, true);
-
-			if (isWindowExpression(scalarNode)) {
-				hasWindowFunctions = true;
-				collectWindowFunctions(scalarNode, column.alias, windowFunctions);
-				projections.push({
-					node: scalarNode,
-					alias: column.alias
-				});
-			} else if (isAggregateExpression(scalarNode)) {
-				hasAggregates = true;
-				aggregates.push({
-					expression: scalarNode,
-					alias: column.alias || expressionToString(column.expr)
-				});
-			} else {
-				projections.push({
-					node: scalarNode,
-					alias: column.alias
-				});
-			}
-		}
-	}
-
-	return {
-		projections,
-		aggregates,
-		windowFunctions,
-		hasAggregates,
-		hasWindowFunctions
-	};
-}
-
-/**
- * Collects all window functions from an expression tree, along with their aliases
- */
-function collectWindowFunctions(
-	node: ScalarPlanNode,
-	alias?: string,
-	windowFunctions: { func: WindowFunctionCallNode; alias?: string }[] = []
-): { func: WindowFunctionCallNode; alias?: string }[] {
-	if (CapabilityDetectors.isWindowFunction(node)) {
-		windowFunctions.push({ func: node as WindowFunctionCallNode, alias });
-	}
-
-	// Recursively check children (only scalar children)
-	for (const child of node.getChildren()) {
-		if ('expression' in child) {
-			collectWindowFunctions(child as ScalarPlanNode, undefined, windowFunctions);
-		}
-	}
-
-	return windowFunctions;
-}

package/src/planner/building/select-window.ts

@@ -1,259 +0,0 @@
-import type { RelationalPlanNode, ScalarPlanNode } from '../nodes/plan-node.js';
-import type { PlanningContext } from '../planning-context.js';
-import { WindowNode, type WindowSpec } from '../nodes/window-node.js';
-import { WindowFunctionCallNode } from '../nodes/window-function.js';
-import { SequencingNode as _SequencingNode } from '../nodes/sequencing-node.js';
-import { ProjectNode, type Projection } from '../nodes/project-node.js';
-import { RegisteredScope as _RegisteredScope } from '../scopes/registered.js';
-import { ColumnReferenceNode as _ColumnReferenceNode } from '../nodes/reference.js';
-import { ArrayIndexNode } from '../nodes/array-index-node.js';
-import { LiteralNode } from '../nodes/scalar.js';
-import { buildExpression } from './expression.js';
-import { isWindowExpression } from './select-projections.js';
-import type * as AST from '../../parser/ast.js';
-import { CapabilityDetectors } from '../framework/characteristics.js';
-
-/**
- * Processes window functions and creates WindowNode(s) with proper projections
- */
-export function buildWindowPhase(
-	input: RelationalPlanNode,
-	windowFunctions: { func: WindowFunctionCallNode; alias?: string }[],
-	selectContext: PlanningContext,
-	stmt: AST.SelectStmt
-): RelationalPlanNode {
-	if (windowFunctions.length === 0) {
-		return input;
-	}
-
-	let currentInput = input;
-
-	// Group window functions by their window specification
-	const windowGroups = groupWindowFunctionsBySpec(windowFunctions);
-
-	// Create WindowNode for each unique window specification
-	for (const [_windowSpecKey, functions] of windowGroups) {
-		const firstFunc = functions[0];
-		const windowSpec: WindowSpec = {
-			partitionBy: firstFunc.func.expression.window?.partitionBy || [],
-			orderBy: firstFunc.func.expression.window?.orderBy || [],
-			frame: firstFunc.func.expression.window?.frame
-		};
-
-		// Special case: ROW_NUMBER() without PARTITION BY - use SequencingNode instead
-		if (shouldUseSequencingNode(functions, windowSpec)) {
-			// TODO: Replace with SequencingNode for optimal performance
-			// For now, proceed with WindowNode
-		}
-
-		// CRITICAL: Build window specification expressions using the INPUT scope
-		// This ensures expressions reference the correct input attribute IDs,
-		// not premature output attribute IDs that don't exist in the runtime context
-		const partitionExpressions = windowSpec.partitionBy.map(expr =>
-			buildExpression(selectContext, expr, false)
-		);
-
-		const orderByExpressions = windowSpec.orderBy.map(orderClause =>
-			buildExpression(selectContext, orderClause.expr, false)
-		);
-
-		// Create new WindowFunctionCallNode instances with alias information
-		const windowFuncsWithAlias = functions.map(({ func, alias }) =>
-			new WindowFunctionCallNode(
-				func.scope,
-				func.expression,
-				func.functionName,
-				func.isDistinct,
-				alias
-			)
-		);
-
-		const functionArguments = buildWindowFunctionArguments(windowFuncsWithAlias, selectContext);
-
-		// Now create the WindowNode with pre-compiled expressions
-		currentInput = new WindowNode(
-			selectContext.scope,
-			currentInput,
-			windowSpec,
-			windowFuncsWithAlias,
-			partitionExpressions,
-			orderByExpressions,
-			functionArguments
-		);
-	}
-
-	// Create projections that select only the requested columns using direct array indexing
-	const windowProjections = buildWindowProjections(stmt, currentInput, selectContext, windowFunctions);
-
-	if (windowProjections.length > 0) {
-		currentInput = new ProjectNode(selectContext.scope, currentInput, windowProjections);
-	}
-
-	return currentInput;
-}
-
-/**
- * Groups window functions by their window specification
- */
-function groupWindowFunctionsBySpec(
-	windowFunctions: { func: WindowFunctionCallNode; alias?: string }[]
-): Map<string, { func: WindowFunctionCallNode; alias?: string }[]> {
-	const windowGroups = new Map<string, { func: WindowFunctionCallNode; alias?: string }[]>();
-
-	for (const { func, alias } of windowFunctions) {
-		// Create a key based on the window specification
-		const windowSpecKey = JSON.stringify({
-			partitionBy: func.expression.window?.partitionBy || [],
-			orderBy: func.expression.window?.orderBy || [],
-			frame: func.expression.window?.frame
-		});
-
-		if (!windowGroups.has(windowSpecKey)) {
-			windowGroups.set(windowSpecKey, []);
-		}
-		windowGroups.get(windowSpecKey)!.push({ func, alias });
-	}
-
-	return windowGroups;
-}
-
-/**
- * Checks if a sequencing node should be used instead of a window node
- */
-function shouldUseSequencingNode(
-	functions: { func: WindowFunctionCallNode; alias?: string }[],
-	windowSpec: WindowSpec
-): boolean {
-	return functions.length === 1 &&
-		   functions[0].func.functionName.toLowerCase() === 'row_number' &&
-		   windowSpec.partitionBy.length === 0;
-}
-
-/**
- * Builds function argument expressions for window functions
- */
-function buildWindowFunctionArguments(
-	windowFuncsWithAlias: WindowFunctionCallNode[],
-	selectContext: PlanningContext
-): (ScalarPlanNode | null)[] {
-	return windowFuncsWithAlias.map(func => {
-		if (func.expression.function.args && func.expression.function.args.length > 0) {
-			const argExpr = func.expression.function.args[0];
-			return buildExpression(selectContext, argExpr, false);
-		}
-		// Special case for COUNT(*) - it has no args but still needs a placeholder
-		if (func.functionName.toLowerCase() === 'count' &&
-			func.expression.function.args.length === 0) {
-			// Create a literal 1 as the argument for COUNT(*) - it counts rows, not specific values
-			return new LiteralNode(selectContext.scope, { type: 'literal', value: 1 });
-		}
-		return null;
-	});
-}
-
-/**
- * Builds projections for window function output columns
- */
-function buildWindowProjections(
-	stmt: AST.SelectStmt,
-	windowNode: RelationalPlanNode,
-	selectContext: PlanningContext,
-	windowFunctions: { func: WindowFunctionCallNode; alias?: string }[]
-): Projection[] {
-	const windowProjections: Projection[] = [];
-	const windowType = windowNode.getType();
-	const sourceColumnCount = windowType.columns.length - windowFunctions.length;
-
-	for (const column of stmt.columns) {
-		if (column.type === 'column') {
-			if (isWindowExpression(buildExpression(selectContext, column.expr, true))) {
-				// For window functions, use ArrayIndexNode to access the value by direct index
-				const windowColumnIndex = findWindowFunctionIndex(
-					column,
-					selectContext,
-					windowFunctions,
-					sourceColumnCount
-				);
-
-				if (windowColumnIndex >= 0) {
-					const windowColumnType = windowType.columns[windowColumnIndex].type;
-
-					const arrayIndexNode = new ArrayIndexNode(
-						selectContext.scope,
-						windowColumnIndex,
-						windowColumnType
-					);
-
-					windowProjections.push({
-						node: arrayIndexNode,
-						alias: column.alias
-					});
-				}
-			} else {
-				// For regular columns, use the original expression built with proper column references
-				const scalarNode = buildExpression(selectContext, column.expr, true);
-
-				windowProjections.push({
-					node: scalarNode,
-					alias: column.alias
-				});
-			}
-		}
-	}
-
-	return windowProjections;
-}
-
-/**
- * Finds the index of a window function in the window output
- */
-function findWindowFunctionIndex(
-	column: AST.ResultColumnExpr,
-	selectContext: PlanningContext,
-	windowFunctions: { func: WindowFunctionCallNode; alias?: string }[],
-	sourceColumnCount: number
-): number {
-	const originalExpr = buildExpression(selectContext, column.expr, true);
-
-	const matchingWindowFuncIndex = windowFunctions.findIndex(({ func }) => {
-		// Match based on function name, parameters, and window specification
-		if (!CapabilityDetectors.isWindowFunction(originalExpr) ||
-			func.functionName.toLowerCase() !== originalExpr.functionName.toLowerCase()) {
-			return false;
-		}
-
-		// Cast to WindowFunctionCallNode to access expression property
-		const windowFunc = originalExpr as WindowFunctionCallNode;
-
-		// Also compare window specifications to distinguish between functions with same name
-		const originalWindow = windowFunc.expression.window;
-		const funcWindow = func.expression.window;
-
-		return compareWindowSpecs(originalWindow, funcWindow);
-	});
-
-	return matchingWindowFuncIndex >= 0 ? sourceColumnCount + matchingWindowFuncIndex : -1;
-}
-
-/**
- * Compares two window specifications for equality
- */
-function compareWindowSpecs(originalWindow?: AST.WindowDefinition, funcWindow?: AST.WindowDefinition): boolean {
-	// Compare partition expressions
-	const originalPartition = JSON.stringify(originalWindow?.partitionBy || []);
-	const funcPartition = JSON.stringify(funcWindow?.partitionBy || []);
-
-	// Compare order expressions
-	const originalOrder = JSON.stringify(originalWindow?.orderBy || []);
-	const funcOrder = JSON.stringify(funcWindow?.orderBy || []);
-
-	// Compare frame specifications
-	const originalFrame = JSON.stringify(originalWindow?.frame || null);
-	const funcFrame = JSON.stringify(funcWindow?.frame || null);
-
-	return originalPartition === funcPartition &&
-		   originalOrder === funcOrder &&
-		   originalFrame === funcFrame;
-}
-
-