@quereus/quereus 0.1.0

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

@@ -0,0 +1,170 @@
+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 { 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 { ProjectNode } from '../nodes/project-node.js';
+import { MultiScope } from '../scopes/multi.js';
+import { RegisteredScope } from '../scopes/registered.js';
+import { ColumnReferenceNode } from '../nodes/reference.js';
+import { buildExpression } from './expression.js';
+
+/**
+ * Builds final projections for non-aggregate cases
+ */
+export function buildFinalProjections(
+	input: RelationalPlanNode,
+	projections: Projection[],
+	selectScope: any,
+	stmt: AST.SelectStmt,
+	selectContext: PlanningContext
+): {
+	output: RelationalPlanNode;
+	finalContext: PlanningContext;
+	preAggregateSort: boolean;
+} {
+	if (projections.length === 0) {
+		return { output: input, finalContext: selectContext, preAggregateSort: false };
+	}
+
+	// Check if ORDER BY should be applied before projection
+	const needsPreProjectionSort = shouldApplyOrderByBeforeProjection(stmt, projections);
+	let preAggregateSort = false;
+
+	let currentInput = input;
+
+	// Apply ORDER BY before projection if needed
+	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;
+	}
+
+	currentInput = new ProjectNode(selectScope, currentInput, projections);
+
+	// Create a new scope that maps column names to the ProjectNode's output attributes
+	const projectionOutputScope = createProjectionOutputScope(currentInput);
+
+	// Update selectContext to use BOTH the projection output scope AND the original scope
+	let finalContext = selectContext;
+	if (!needsPreProjectionSort) {
+		const combinedScope = new MultiScope([projectionOutputScope, selectScope]);
+		finalContext = { ...selectContext, scope: combinedScope };
+	}
+
+	return {
+		output: currentInput,
+		finalContext,
+		preAggregateSort
+	};
+}
+
+/**
+ * Applies DISTINCT modifier if present
+ */
+export function applyDistinct(
+	input: RelationalPlanNode,
+	stmt: AST.SelectStmt,
+	selectScope: any
+): 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
+): RelationalPlanNode {
+	if (stmt.orderBy && stmt.orderBy.length > 0 && !preAggregateSort) {
+		const sortKeys: SortKey[] = stmt.orderBy.map(orderByClause => {
+			const expression = buildExpression(selectContext, orderByClause.expr);
+			return {
+				expression,
+				direction: orderByClause.direction,
+				nulls: orderByClause.nulls
+			};
+		});
+
+		return new SortNode(selectContext.scope, input, sortKeys);
+	}
+	return input;
+}
+
+/**
+ * Applies LIMIT and OFFSET clauses
+ */
+export function applyLimitOffset(
+	input: RelationalPlanNode,
+	stmt: AST.SelectStmt,
+	selectContext: PlanningContext
+): RelationalPlanNode {
+	if (stmt.limit || stmt.offset) {
+		const literalNull = new LiteralNode(selectContext.scope, { type: 'literal', value: null });
+		const limitExpression = stmt.limit ? buildExpression(selectContext, stmt.limit) : literalNull;
+		const offsetExpression = stmt.offset ? buildExpression(selectContext, stmt.offset) : literalNull;
+		return new LimitOffsetNode(selectContext.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) ||
+				(proj.node instanceof ColumnReferenceNode && 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;
+}

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

@@ -0,0 +1,177 @@
+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 } from '../nodes/aggregate-function.js';
+import { WindowFunctionCallNode } from '../nodes/window-function.js';
+
+/**
+ * Checks if an expression contains aggregate functions
+ */
+export function isAggregateExpression(node: ScalarPlanNode): boolean {
+	if (node instanceof AggregateFunctionCallNode) {
+		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 (node instanceof WindowFunctionCallNode) {
+		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 },
+	input: any,
+	selectScope: any
+): Projection[] {
+	const projections: Projection[] = [];
+	const inputColumns = input.getType().columns;
+	const inputAttributes = input.getAttributes();
+
+	if (column.table) {
+		// Handle qualified SELECT table.*
+		const inputTableName = input.source?.tableSchema?.name;
+		const tableMatches = column.table.toLowerCase() === inputTableName?.toLowerCase();
+		if (!tableMatches) {
+			throw new QuereusError(
+				`Table '${column.table}' not found in FROM clause for qualified SELECT *`,
+				StatusCode.ERROR
+			);
+		}
+	}
+
+	// Add a projection for each column in the input relation
+	inputColumns.forEach((columnDef: any, index: number) => {
+		const columnExpr: AST.ColumnExpr = {
+			type: 'column',
+			name: columnDef.name,
+		};
+
+		const attr = inputAttributes[index];
+		const columnRef = new ColumnReferenceNode(
+			selectScope,
+			columnExpr,
+			columnDef.type,
+			attr.id,
+			index
+		);
+
+		projections.push({
+			node: columnRef,
+			alias: columnDef.name
+		});
+	});
+
+	return projections;
+}
+
+/**
+ * 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 (node instanceof WindowFunctionCallNode) {
+		windowFunctions.push({ func: node, 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

@@ -0,0 +1,248 @@
+import type { RelationalPlanNode, ScalarPlanNode } from '../nodes/plan-node.js';
+import type { PlanningContext } from '../planning-context.js';
+import type { Projection } from '../nodes/project-node.js';
+import { WindowNode, type WindowSpec } from '../nodes/window-node.js';
+import { WindowFunctionCallNode } from '../nodes/window-function.js';
+import { ArrayIndexNode } from '../nodes/array-index-node.js';
+import { ProjectNode } from '../nodes/project-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';
+
+/**
+ * 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
+		}
+
+		// Create new WindowFunctionCallNode instances with alias information
+		const windowFuncsWithAlias = functions.map(({ func, alias }) =>
+			new WindowFunctionCallNode(
+				func.scope,
+				func.expression,
+				func.functionName,
+				func.isDistinct,
+				alias
+			)
+		);
+
+		// Build expressions for window specification
+		const partitionExpressions = windowSpec.partitionBy.map(expr =>
+			buildExpression(selectContext, expr, false)
+		);
+
+		const orderByExpressions = windowSpec.orderBy.map(orderClause =>
+			buildExpression(selectContext, orderClause.expr, false)
+		);
+
+		const functionArguments = buildWindowFunctionArguments(windowFuncsWithAlias, selectContext);
+
+		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 (!(originalExpr instanceof WindowFunctionCallNode) ||
+			func.functionName.toLowerCase() !== originalExpr.functionName.toLowerCase()) {
+			return false;
+		}
+
+		// Also compare window specifications to distinguish between functions with same name
+		const originalWindow = originalExpr.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: any, funcWindow: any): 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;
+}