@quereus/quereus 0.1.0 → 0.2.1

package/src/planner/building/constraint-builder.ts

@@ -0,0 +1,114 @@
+import type { PlanningContext } from '../planning-context.js';
+import type { TableSchema, RowConstraintSchema } from '../../schema/table.js';
+import type { RowOpFlag } from '../../schema/table.js';
+import type { Attribute, RowDescriptor } from '../nodes/plan-node.js';
+import type { ConstraintCheck } from '../nodes/constraint-check-node.js';
+import { RegisteredScope } from '../scopes/registered.js';
+import { buildExpression } from './expression.js';
+import { ColumnReferenceNode } from '../nodes/reference.js';
+import type { ScalarPlanNode } from '../nodes/plan-node.js';
+import * as AST from '../../parser/ast.js';
+
+/**
+ * Determines if a constraint should be checked for the given operation
+ */
+function shouldCheckConstraint(constraint: RowConstraintSchema, operation: RowOpFlag): boolean {
+  // Check if the current operation is in the constraint's operations bitmask
+  return (constraint.operations & operation) !== 0;
+}
+
+/**
+ * Builds constraint check expressions at plan time.
+ * This allows the optimizer to see and optimize constraint expressions.
+ */
+export function buildConstraintChecks(
+  ctx: PlanningContext,
+  tableSchema: TableSchema,
+  operation: RowOpFlag,
+  oldAttributes: Attribute[],
+  newAttributes: Attribute[],
+  _flatRowDescriptor: RowDescriptor
+): ConstraintCheck[] {
+  // Build attribute ID mappings for column registration
+  const newAttrIdByCol: Record<string, number> = {};
+  const oldAttrIdByCol: Record<string, number> = {};
+
+  newAttributes.forEach((attr, columnIndex) => {
+    if (columnIndex < tableSchema.columns.length) {
+      const column = tableSchema.columns[columnIndex];
+      newAttrIdByCol[column.name.toLowerCase()] = attr.id;
+    }
+  });
+
+  oldAttributes.forEach((attr, columnIndex) => {
+    if (columnIndex < tableSchema.columns.length) {
+      const column = tableSchema.columns[columnIndex];
+      oldAttrIdByCol[column.name.toLowerCase()] = attr.id;
+    }
+  });
+
+  // Filter constraints by operation
+  const applicableConstraints = tableSchema.checkConstraints
+    .filter(constraint => shouldCheckConstraint(constraint, operation));
+
+  // Build expression nodes for each constraint
+  return applicableConstraints.map(constraint => {
+    // Create scope with OLD/NEW column access for constraint evaluation
+    const constraintScope = new RegisteredScope(ctx.scope);
+
+    // Register column symbols (similar to current emitConstraintCheck logic)
+    tableSchema.columns.forEach((tableColumn, tableColIndex) => {
+      const colNameLower = tableColumn.name.toLowerCase();
+
+      // Register NEW.col and unqualified col (defaults to NEW for INSERT/UPDATE, OLD for DELETE)
+      const newAttrId = newAttrIdByCol[colNameLower];
+      if (newAttrId !== undefined) {
+        const newColumnType = {
+          typeClass: 'scalar' as const,
+          affinity: tableColumn.affinity,
+          nullable: !tableColumn.notNull,
+          isReadOnly: false
+        };
+
+        // NEW.column
+        constraintScope.registerSymbol(`new.${colNameLower}`, (exp, s) =>
+          new ColumnReferenceNode(s, exp as AST.ColumnExpr, newColumnType, newAttrId, tableColIndex));
+
+        // For INSERT/UPDATE, unqualified column defaults to NEW
+        if (operation === 1 || operation === 2) { // INSERT or UPDATE
+          constraintScope.registerSymbol(colNameLower, (exp, s) =>
+            new ColumnReferenceNode(s, exp as AST.ColumnExpr, newColumnType, newAttrId, tableColIndex));
+        }
+      }
+
+      // Register OLD.col
+      const oldAttrId = oldAttrIdByCol[colNameLower];
+      if (oldAttrId !== undefined) {
+        const oldColumnType = {
+          typeClass: 'scalar' as const,
+          affinity: tableColumn.affinity,
+          nullable: true, // OLD values can be NULL (especially for INSERT)
+          isReadOnly: false
+        };
+
+        // OLD.column
+        constraintScope.registerSymbol(`old.${colNameLower}`, (exp, s) =>
+          new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldColumnType, oldAttrId, tableColIndex));
+
+        // For DELETE, unqualified column defaults to OLD
+        if (operation === 4) { // DELETE
+          constraintScope.registerSymbol(colNameLower, (exp, s) =>
+            new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldColumnType, oldAttrId, tableColIndex));
+        }
+      }
+    });
+
+    // Build the constraint expression using the specialized scope
+    const expression = buildExpression(
+      { ...ctx, scope: constraintScope },
+      constraint.expr
+    ) as ScalarPlanNode;
+
+    return { constraint, expression };
+  });
+}

package/src/planner/building/delete.ts

@@ -1,7 +1,7 @@
 import type * as AST from '../../parser/ast.js';
 import type { PlanningContext } from '../planning-context.js';
 import { DeleteNode } from '../nodes/delete-node.js';
-import { buildTableReference, buildTableScan } from './table.js';
+import { buildTableReference } from './table.js';
 import { buildExpression } from './expression.js';
 import { PlanNode, type RelationalPlanNode, type ScalarPlanNode } from '../nodes/plan-node.js';
 import { FilterNode } from '../nodes/filter.js';
@@ -11,10 +11,11 @@ import { RegisteredScope } from '../scopes/registered.js';
 import { ColumnReferenceNode } from '../nodes/reference.js';
 import { SinkNode } from '../nodes/sink-node.js';
 import { ConstraintCheckNode } from '../nodes/constraint-check-node.js';
-import { RowOp } from '../../schema/table.js';
+import { RowOpFlag } from '../../schema/table.js';
 import { ReturningNode } from '../nodes/returning-node.js';
 import { buildOldNewRowDescriptors } from '../../util/row-descriptor.js';
 import { DmlExecutorNode } from '../nodes/dml-executor-node.js';
+import { buildConstraintChecks } from './constraint-builder.js';
 
 export function buildDeleteStmt(
   ctx: PlanningContext,
@@ -23,7 +24,7 @@ export function buildDeleteStmt(
   const tableReference = buildTableReference({ type: 'table', table: stmt.table }, ctx);
 
   // Plan the source of rows to delete. This is typically the table itself, potentially filtered.
-  let sourceNode: RelationalPlanNode = buildTableScan({ type: 'table', table: stmt.table }, ctx);
+  let sourceNode: RelationalPlanNode = buildTableReference({ type: 'table', table: stmt.table }, ctx);
 
   // Create a new scope with the table columns registered for column resolution
   const tableScope = new RegisteredScope(ctx.scope);
@@ -69,14 +70,26 @@ export function buildDeleteStmt(
 
   const { oldRowDescriptor, newRowDescriptor, flatRowDescriptor } = buildOldNewRowDescriptors(oldAttributes, newAttributes);
 
+  // Build constraint checks at plan time
+  const constraintChecks = buildConstraintChecks(
+    deleteCtx,
+    tableReference.tableSchema,
+    RowOpFlag.DELETE,
+    oldAttributes,
+    newAttributes,
+    flatRowDescriptor
+  );
+
   // Always inject ConstraintCheckNode for DELETE operations
   const constraintCheckNode = new ConstraintCheckNode(
     deleteCtx.scope,
     sourceNode,
     tableReference,
-    RowOp.DELETE,
+    RowOpFlag.DELETE,
     oldRowDescriptor,
-    newRowDescriptor
+    newRowDescriptor,
+    flatRowDescriptor,
+    constraintChecks
   );
 
   const deleteNode = new DeleteNode(

package/src/planner/building/expression.ts

@@ -1,6 +1,6 @@
 import type * as AST from '../../parser/ast.js';
 import type { PlanningContext } from '../planning-context.js';
-import { LiteralNode, BinaryOpNode, UnaryOpNode, CaseExprNode, CastNode, CollateNode } from '../nodes/scalar.js';
+import { LiteralNode, BinaryOpNode, UnaryOpNode, CaseExprNode, CastNode, CollateNode, BetweenNode } from '../nodes/scalar.js';
 import { ScalarSubqueryNode, InNode, ExistsNode } from '../nodes/subquery.js';
 import { WindowFunctionCallNode } from '../nodes/window-function.js';
 import type { ScalarPlanNode, RelationalPlanNode } from '../nodes/plan-node.js';
@@ -12,7 +12,13 @@ import { Ambiguous } from '../scopes/scope.js';
 import { buildSelectStmt } from './select.js';
 import { resolveWindowFunction } from '../../schema/window-function.js';
 import { buildFunctionCall } from './function-call.js';
+import { createLogger } from '../../common/logger.js';
 
+const logger = createLogger('planner:expression');
+
+/**
+ * Builds an expression plan node from an AST expression.
+ */
 export function buildExpression(ctx: PlanningContext, expr: AST.Expression, allowAggregates: boolean = false): ScalarPlanNode {
   switch (expr.type) {
     case 'literal':
@@ -92,8 +98,16 @@ export function buildExpression(ctx: PlanningContext, expr: AST.Expression, allo
     case 'subquery': {
        // For scalar subqueries, create a context that allows correlation
        // The buildSelectStmt will create the proper scope chain with subquery tables taking precedence
-       const subqueryContext = { ...ctx };
-       const subqueryPlan = buildSelectStmt(subqueryContext, expr.query);
+       // CRITICAL: Share the cteReferenceCache to ensure consistent attribute IDs across contexts
+       logger(`Building scalar subquery - ctx.cteReferenceCache size: ${ctx.cteReferenceCache?.size ?? 'undefined'}`);
+       const subqueryContext = {
+         ...ctx,
+         cteReferenceCache: ctx.cteReferenceCache || new Map()
+       };
+       // Preserve input columns in scalar subqueries to ensure correlated predicates
+       // have access to all underlying attributes.
+       const subqueryPlan = buildSelectStmt(subqueryContext, expr.query, ctx.cteNodes, true);
+       logger(`Building scalar subquery with preserveInputColumns=true`);
        if (subqueryPlan.getType().typeClass !== 'relation') {
          throw new QuereusError('Subquery must produce a relation', StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
        }
@@ -138,8 +152,11 @@ export function buildExpression(ctx: PlanningContext, expr: AST.Expression, allo
 
        if (expr.subquery) {
          // IN subquery: expr IN (SELECT ...)
-         const inSubqueryContext = { ...ctx };
-         const inSubqueryPlan = buildSelectStmt(inSubqueryContext, expr.subquery);
+         const inSubqueryContext = {
+           ...ctx,
+           cteReferenceCache: ctx.cteReferenceCache || new Map()
+         };
+         const inSubqueryPlan = buildSelectStmt(inSubqueryContext, expr.subquery, ctx.cteNodes, true);
          if (inSubqueryPlan.getType().typeClass !== 'relation') {
            throw new QuereusError('IN subquery must produce a relation', StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
          }
@@ -162,14 +179,25 @@ export function buildExpression(ctx: PlanningContext, expr: AST.Expression, allo
 
     case 'exists': {
        // Build the EXISTS subquery
-       const existsSubqueryContext = { ...ctx };
-       const existsSubqueryPlan = buildSelectStmt(existsSubqueryContext, expr.subquery);
+       const existsSubqueryContext = {
+         ...ctx,
+         cteReferenceCache: ctx.cteReferenceCache || new Map()
+       };
+       const existsSubqueryPlan = buildSelectStmt(existsSubqueryContext, expr.subquery, ctx.cteNodes, true);
        if (existsSubqueryPlan.getType().typeClass !== 'relation') {
          throw new QuereusError('EXISTS subquery must produce a relation', StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
        }
        return new ExistsNode(ctx.scope, expr, existsSubqueryPlan as RelationalPlanNode);
 		}
 
+    case 'between': {
+       // Build the BETWEEN expression: expr BETWEEN lower AND upper
+       const exprNode = buildExpression(ctx, expr.expr, allowAggregates);
+       const lowerNode = buildExpression(ctx, expr.lower, allowAggregates);
+       const upperNode = buildExpression(ctx, expr.upper, allowAggregates);
+       return new BetweenNode(ctx.scope, expr, exprNode, lowerNode, upperNode);
+		}
+
 		default:
       throw new QuereusError(`Expression type '${(expr as any).type}' not yet supported in buildExpression.`, StatusCode.UNSUPPORTED, undefined, expr.loc?.start.line, expr.loc?.start.column);
   }

package/src/planner/building/insert.ts

@@ -16,11 +16,12 @@ import { RegisteredScope } from '../scopes/registered.js';
 import { ColumnReferenceNode } from '../nodes/reference.js';
 import { SinkNode } from '../nodes/sink-node.js';
 import { ConstraintCheckNode } from '../nodes/constraint-check-node.js';
-import { RowOp } from '../../schema/table.js';
+import { RowOpFlag } from '../../schema/table.js';
 import { ReturningNode } from '../nodes/returning-node.js';
 import { ProjectNode, type Projection } from '../nodes/project-node.js';
 import { buildOldNewRowDescriptors } from '../../util/row-descriptor.js';
 import { DmlExecutorNode } from '../nodes/dml-executor-node.js';
+import { buildConstraintChecks } from './constraint-builder.js';
 
 /**
  * Creates a uniform row expansion projection that maps any relational source
@@ -243,6 +244,16 @@ export function buildInsertStmt(
 
 	const { oldRowDescriptor, newRowDescriptor, flatRowDescriptor } = buildOldNewRowDescriptors(oldAttributes, newAttributes);
 
+	// Build constraint checks at plan time
+	const constraintChecks = buildConstraintChecks(
+		ctx,
+		tableReference.tableSchema,
+		RowOpFlag.INSERT,
+		oldAttributes,
+		newAttributes,
+		flatRowDescriptor
+	);
+
 	const insertNode = new InsertNode(
 		ctx.scope,
 		tableReference,
@@ -255,9 +266,11 @@ export function buildInsertStmt(
 		ctx.scope,
 		insertNode,
 		tableReference,
-		RowOp.INSERT,
+		RowOpFlag.INSERT,
 		oldRowDescriptor,
-		newRowDescriptor
+		newRowDescriptor,
+		flatRowDescriptor,
+		constraintChecks
 	);
 
 	// Add DML executor node to perform the actual database insert operations

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

@@ -27,17 +27,17 @@ export function buildAggregatePhase(
 	needsFinalProjection: boolean;
 	preAggregateSort: boolean;
 } {
+		const hasGroupBy = stmt.groupBy && stmt.groupBy.length > 0;
+
 	// If there is a HAVING clause but the SELECT contains **no aggregate functions**
-	// we can safely treat the HAVING predicate as a regular filter that runs *before*
-	// the aggregation (i.e. between the source and the AggregateNode). This avoids
-	// the "missing column context" problem where the predicate refers to columns
+	// AND **no GROUP BY**, we can safely treat the HAVING predicate as a regular filter
+	// that runs *before* the aggregation (i.e. between the source and the AggregateNode).
+	// This avoids the "missing column context" problem where the predicate refers to columns
 	// that are not available after the AggregateNode (only grouping columns and
 	// aggregate results are exposed). This behaviour is compatible with SQLite –
 	// GROUP BY with a primary-key guarantees one row per group so the semantics
 	// are unchanged.
-	const shouldPushHavingBelowAggregate = Boolean(stmt.having && !hasAggregates);
-
-	const hasGroupBy = stmt.groupBy && stmt.groupBy.length > 0;
+	const shouldPushHavingBelowAggregate = Boolean(stmt.having && !hasAggregates && !hasGroupBy);
 
 	if (!hasAggregates && !hasGroupBy) {
 		return { output: input, needsFinalProjection: false, preAggregateSort: false };
@@ -67,7 +67,7 @@ export function buildAggregatePhase(
 	const groupByExpressions = stmt.groupBy ?
 		stmt.groupBy.map(expr => buildExpression(selectContext, expr, false)) : [];
 
-	// Create AggregateNode
+		// Create AggregateNode
 	currentInput = new AggregateNode(selectContext.scope, currentInput, groupByExpressions, aggregates);
 
 	// Create aggregate output scope
@@ -166,6 +166,21 @@ function createAggregateOutputScope(
 			new ColumnReferenceNode(s, exp as AST.ColumnExpr, agg.expression.getType(), attr.id, columnIndex));
 	});
 
+			// Register source columns for HAVING clause access
+	// Start after GROUP BY and aggregate columns
+	const sourceColumnStartIndex = groupByExpressions.length + aggregates.length;
+	for (let i = sourceColumnStartIndex; i < aggregateAttributes.length; i++) {
+		const attr = aggregateAttributes[i];
+		// Only register if not already registered (avoid conflicts with GROUP BY columns)
+		const symbolName = attr.name.toLowerCase();
+		const existingSymbols = aggregateOutputScope.getSymbols();
+		const alreadyRegistered = existingSymbols.some(([key]) => key === symbolName);
+		if (!alreadyRegistered) {
+			aggregateOutputScope.registerSymbol(symbolName, (exp, s) =>
+				new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, i));
+		}
+	}
+
 	return aggregateOutputScope;
 }
 
@@ -182,10 +197,35 @@ function buildHavingFilter(
 ): RelationalPlanNode {
 	const aggregateAttributes = input.getAttributes();
 
-	// Build HAVING expression with the aggregate scope
+	// Create a hybrid scope that first tries the aggregate output scope,
+	// then falls back to the original source scope for column resolution
+	const hybridScope = new RegisteredScope();
+
+	// Copy all symbols from aggregate output scope
+	for (const [symbolKey, callback] of aggregateOutputScope.getSymbols()) {
+		hybridScope.registerSymbol(symbolKey, callback);
+	}
+
+	// For any source columns not already registered, register them with
+	// references to the source table
+	const sourceInput = input.getRelations()[0]; // The AggregateNode's source
+	const sourceAttributes = sourceInput.getAttributes();
+
+	sourceAttributes.forEach((sourceAttr, sourceIndex) => {
+		const symbolName = sourceAttr.name.toLowerCase();
+		const existingSymbols = hybridScope.getSymbols();
+		const alreadyRegistered = existingSymbols.some(([key]) => key === symbolName);
+
+		if (!alreadyRegistered) {
+			hybridScope.registerSymbol(symbolName, (exp, s) =>
+				new ColumnReferenceNode(s, exp as AST.ColumnExpr, sourceAttr.type, sourceAttr.id, sourceIndex));
+		}
+	});
+
+	// Build HAVING expression with the hybrid scope
 	const havingContext: PlanningContext = {
 		...selectContext,
-		scope: aggregateOutputScope,
+		scope: hybridScope,
 		aggregates: aggregates.map((agg, index) => {
 			const columnIndex = groupByExpressions.length + index;
 			const attr = aggregateAttributes[columnIndex];
@@ -200,7 +240,7 @@ function buildHavingFilter(
 
 	const havingExpression = buildExpression(havingContext, havingClause, true);
 
-	return new FilterNode(aggregateOutputScope, input, havingExpression);
+	return new FilterNode(hybridScope, input, havingExpression);
 }
 
 /**
@@ -234,9 +274,15 @@ export function buildFinalAggregateProjections(
 			const finalContext: PlanningContext = { ...selectContext, scope: aggregateOutputScope };
 			const scalarNode = buildExpression(finalContext, column.expr, true);
 
+			let attrId: number | undefined = undefined;
+			if (scalarNode instanceof ColumnReferenceNode) {
+				attrId = scalarNode.attributeId;
+			}
+
 			finalProjections.push({
 				node: scalarNode,
-				alias: column.alias || (column.expr.type === 'column' ? column.expr.name : undefined)
+				alias: column.alias || (column.expr.type === 'column' ? column.expr.name : undefined),
+				attributeId: attrId
 			});
 		}
 	}

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

@@ -27,8 +27,8 @@ export function buildWithContext(
 	contextWithCTEs: PlanningContext;
 	cteNodes: Map<string, CTEPlanNode>;
 } {
-	// Start with parent CTEs
-	const cteNodes: Map<string, CTEPlanNode> = new Map(parentCTEs);
+	// Start with parent CTEs - either from parameter or from context
+	const cteNodes: Map<string, CTEPlanNode> = new Map(parentCTEs.size > 0 ? parentCTEs : (ctx.cteNodes ?? new Map()));
 	let contextWithCTEs = ctx;
 
 	if (stmt.withClause) {
@@ -40,11 +40,11 @@ export function buildWithContext(
 
 		// Create a new scope that includes the CTEs
 		const cteScope = createCTEScope(cteNodes, ctx);
-		contextWithCTEs = { ...ctx, scope: cteScope };
-	} else if (parentCTEs.size > 0) {
+		contextWithCTEs = { ...ctx, scope: cteScope, cteNodes, cteReferenceCache: ctx.cteReferenceCache };
+	} else if (cteNodes.size > 0) {
 		// No WITH clause but we have parent CTEs, create scope for them
-		const cteScope = createCTEScope(parentCTEs, ctx);
-		contextWithCTEs = { ...ctx, scope: cteScope };
+		const cteScope = createCTEScope(cteNodes, ctx);
+		contextWithCTEs = { ...ctx, scope: cteScope, cteNodes, cteReferenceCache: ctx.cteReferenceCache };
 	}
 
 	return { contextWithCTEs, cteNodes };
@@ -52,6 +52,8 @@ export function buildWithContext(
 
 /**
  * Creates a scope that includes CTE references
+ * CRITICAL: Uses stable input attribute IDs only, ignoring any projection output scopes
+ * that might cause attribute ID collisions in correlated subqueries
  */
 function createCTEScope(
 	cteNodes: Map<string, CTEPlanNode>,
@@ -61,13 +63,21 @@ function createCTEScope(
 
 	// Register each CTE in the scope
 	for (const [cteName, cteNode] of cteNodes) {
+		// CRITICAL: Use only the stable input attributes from the CTE definition
+		// Do NOT use any projection output attributes that might have fresh IDs
 		const attributes = cteNode.getAttributes();
-		cteNode.getType().columns.forEach((col: any, i: number) => {
-			const attr = attributes[i];
-			// Register CTE columns with qualified names to avoid collisions
-			const qualifiedColumnName = `${cteName}.${col.name.toLowerCase()}`;
-			cteScope.registerSymbol(qualifiedColumnName, (exp, s) =>
-				new ColumnReferenceNode(s, exp as AST.ColumnExpr, col.type, attr.id, i));
+		const columnTypes = cteNode.getType().columns;
+
+		// Only register columns that are stable input attributes
+		// This prevents scope pollution from projection output attributes
+		columnTypes.forEach((col: any, i: number) => {
+			if (i < attributes.length) {
+				const attr = attributes[i];
+				// Register CTE columns with qualified names to avoid collisions
+				const qualifiedColumnName = `${cteName}.${col.name.toLowerCase()}`;
+				cteScope.registerSymbol(qualifiedColumnName, (exp, s) =>
+					new ColumnReferenceNode(s, exp as AST.ColumnExpr, col.type, attr.id, i));
+			}
 		});
 	}
 

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

@@ -20,23 +20,25 @@ export function buildFinalProjections(
 	projections: Projection[],
 	selectScope: any,
 	stmt: AST.SelectStmt,
-	selectContext: PlanningContext
+	selectContext: PlanningContext,
+	preserveInputColumns: boolean = true
 ): {
 	output: RelationalPlanNode;
 	finalContext: PlanningContext;
+	projectionScope?: RegisteredScope;
 	preAggregateSort: boolean;
 } {
 	if (projections.length === 0) {
 		return { output: input, finalContext: selectContext, preAggregateSort: false };
 	}
 
-	// Check if ORDER BY should be applied before projection
+	// 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
+	// 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);
@@ -50,21 +52,17 @@ export function buildFinalProjections(
 		preAggregateSort = true;
 	}
 
-	currentInput = new ProjectNode(selectScope, currentInput, projections);
+	// Create the ProjectNode only after all expressions are compiled against input scope
+	currentInput = new ProjectNode(selectScope, currentInput, projections, undefined, undefined, preserveInputColumns);
 
-	// Create a new scope that maps column names to the ProjectNode's output attributes
+	// 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);
 
-	// 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,
+		finalContext: selectContext, // Keep unchanged - no premature scope pollution
+		projectionScope: projectionOutputScope,
 		preAggregateSort
 	};
 }
@@ -90,11 +88,19 @@ export function applyOrderBy(
 	input: RelationalPlanNode,
 	stmt: AST.SelectStmt,
 	selectContext: PlanningContext,
-	preAggregateSort: boolean
+	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(selectContext, orderByClause.expr);
+			const expression = buildExpression(orderByContext, orderByClause.expr);
 			return {
 				expression,
 				direction: orderByClause.direction,
@@ -102,7 +108,7 @@ export function applyOrderBy(
 			};
 		});
 
-		return new SortNode(selectContext.scope, input, sortKeys);
+		return new SortNode(orderByContext.scope, input, sortKeys);
 	}
 	return input;
 }
@@ -113,13 +119,21 @@ export function applyOrderBy(
 export function applyLimitOffset(
 	input: RelationalPlanNode,
 	stmt: AST.SelectStmt,
-	selectContext: PlanningContext
+	selectContext: PlanningContext,
+	projectionScope?: RegisteredScope
 ): 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);
+		// 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;
 }