@quereus/quereus 0.1.0

package/src/planner/building/expression.ts

@@ -0,0 +1,176 @@
+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 { ScalarSubqueryNode, InNode, ExistsNode } from '../nodes/subquery.js';
+import { WindowFunctionCallNode } from '../nodes/window-function.js';
+import type { ScalarPlanNode, RelationalPlanNode } from '../nodes/plan-node.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import type { RelationType } from '../../common/datatype.js';
+import { resolveColumn, resolveParameter } from '../resolve.js';
+import { Ambiguous } from '../scopes/scope.js';
+import { buildSelectStmt } from './select.js';
+import { resolveWindowFunction } from '../../schema/window-function.js';
+import { buildFunctionCall } from './function-call.js';
+
+export function buildExpression(ctx: PlanningContext, expr: AST.Expression, allowAggregates: boolean = false): ScalarPlanNode {
+  switch (expr.type) {
+    case 'literal':
+      return new LiteralNode(ctx.scope, expr);
+
+    case 'column': {
+      const colResolution = resolveColumn(ctx.scope, expr, ctx.db.schemaManager.getCurrentSchemaName());
+
+      if (!colResolution || colResolution === Ambiguous) {
+        throw new QuereusError(`Column not found: ${expr.name}`, StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+      }
+      return colResolution as ScalarPlanNode;
+		}
+
+		case 'parameter': {
+      const paramResolution = resolveParameter(ctx.scope, expr);
+      if (!paramResolution || paramResolution === Ambiguous) {
+        throw new QuereusError(`Parameter not found: ${expr.name ?? expr.index}`, StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+      }
+      return paramResolution as ScalarPlanNode;
+		}
+
+		case 'unary': {
+      // Optimization: fold unary minus over numeric literals into negative literals
+      if (expr.operator === '-' && expr.expr.type === 'literal') {
+        const literalExpr = expr.expr as AST.LiteralExpr;
+        if (typeof literalExpr.value === 'number' || typeof literalExpr.value === 'bigint') {
+          // Create a new literal expression with the negated value
+          const negatedLiteral: AST.LiteralExpr = {
+            type: 'literal',
+            value: typeof literalExpr.value === 'bigint' ? -literalExpr.value : -literalExpr.value,
+            lexeme: literalExpr.lexeme ? `-${literalExpr.lexeme}` : undefined,
+            loc: expr.loc // Use the location of the entire unary expression
+          };
+          return new LiteralNode(ctx.scope, negatedLiteral);
+        }
+      }
+
+      const operand = buildExpression(ctx, expr.expr, allowAggregates);
+      return new UnaryOpNode(ctx.scope, expr, operand);
+		}
+
+		case 'binary': {
+      const left = buildExpression(ctx, expr.left, allowAggregates);
+      const right = buildExpression(ctx, expr.right, allowAggregates);
+      return new BinaryOpNode(ctx.scope, expr, left, right);
+		}
+
+    case 'case': {
+      // Build base expression if present
+      const baseExpr = expr.baseExpr ? buildExpression(ctx, expr.baseExpr, allowAggregates) : undefined;
+
+      // Build WHEN/THEN clauses
+      const whenThenClauses = expr.whenThenClauses.map(clause => ({
+        when: buildExpression(ctx, clause.when, allowAggregates),
+        then: buildExpression(ctx, clause.then, allowAggregates)
+      }));
+
+      // Build ELSE expression if present
+      const elseExpr = expr.elseExpr ? buildExpression(ctx, expr.elseExpr, allowAggregates) : undefined;
+
+      return new CaseExprNode(ctx.scope, expr, baseExpr, whenThenClauses, elseExpr);
+		}
+
+    case 'cast': {
+      const castOperand = buildExpression(ctx, expr.expr, allowAggregates);
+      return new CastNode(ctx.scope, expr, castOperand);
+    }
+
+    case 'collate': {
+      const collateOperand = buildExpression(ctx, expr.expr, allowAggregates);
+      return new CollateNode(ctx.scope, expr, collateOperand);
+    }
+
+		case 'function': return buildFunctionCall(ctx, expr, allowAggregates);
+
+    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);
+       if (subqueryPlan.getType().typeClass !== 'relation') {
+         throw new QuereusError('Subquery must produce a relation', StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+       }
+       // Validate that scalar subquery returns exactly one column
+       const scalarSubqueryType = subqueryPlan.getType();
+       if (scalarSubqueryType.typeClass === 'relation' && (scalarSubqueryType as RelationType).columns.length !== 1) {
+         throw new QuereusError('Scalar subquery must return exactly one column', StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+       }
+       return new ScalarSubqueryNode(ctx.scope, expr, subqueryPlan as RelationalPlanNode);
+		}
+
+		case 'windowFunction': {
+       // Window functions are handled by creating a WindowFunctionCallNode
+       // First validate that this is a registered window function
+       const windowSchema = resolveWindowFunction(expr.function.name);
+       if (!windowSchema) {
+         throw new QuereusError(`Unknown window function: ${expr.function.name}`, StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+       }
+
+       // Validate argument count (special case for COUNT(*))
+       const isCountStar = expr.function.name.toLowerCase() === 'count' && expr.function.args.length === 0;
+       if (windowSchema.argCount !== 'variadic' && expr.function.args.length !== windowSchema.argCount && !isCountStar) {
+         throw new QuereusError(`Window function ${expr.function.name} expects ${windowSchema.argCount} arguments, got ${expr.function.args.length}`, StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+       }
+
+       // Validate ORDER BY requirement
+       if (windowSchema.requiresOrderBy && (!expr.window?.orderBy || expr.window.orderBy.length === 0)) {
+         throw new QuereusError(`Window function ${expr.function.name} requires ORDER BY clause`, StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+       }
+
+       return new WindowFunctionCallNode(
+         ctx.scope,
+         expr,
+         expr.function.name,
+         expr.function.distinct ?? false
+       );
+		}
+
+		case 'in': {
+       // Build the left expression
+       const leftExpr = buildExpression(ctx, expr.expr, allowAggregates);
+
+       if (expr.subquery) {
+         // IN subquery: expr IN (SELECT ...)
+         const inSubqueryContext = { ...ctx };
+         const inSubqueryPlan = buildSelectStmt(inSubqueryContext, expr.subquery);
+         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);
+         }
+         // Validate that subquery returns exactly one column
+         const subqueryType = inSubqueryPlan.getType();
+         if (subqueryType.typeClass === 'relation' && (subqueryType as RelationType).columns.length !== 1) {
+           throw new QuereusError('IN subquery must return exactly one column', StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+         }
+                   return new InNode(ctx.scope, expr, leftExpr, inSubqueryPlan as RelationalPlanNode);
+               } else if (expr.values) {
+          // IN value list: expr IN (value1, value2, ...)
+          const valueExprs = expr.values.map(val => buildExpression(ctx, val, allowAggregates));
+          // Create a special IN node for value lists
+          // Import the InNode from subquery module
+          return new InNode(ctx.scope, expr, leftExpr, undefined, valueExprs);
+       } else {
+         throw new QuereusError('IN expression must have either values or subquery', StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+       }
+		}
+
+    case 'exists': {
+       // Build the EXISTS subquery
+       const existsSubqueryContext = { ...ctx };
+       const existsSubqueryPlan = buildSelectStmt(existsSubqueryContext, expr.subquery);
+       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);
+		}
+
+		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/function-call.ts

@@ -0,0 +1,87 @@
+import { type PlanningContext } from "../planning-context.js";
+import { AggregateFunctionCallNode } from "../nodes/aggregate-function.js";
+import { ColumnReferenceNode } from "../nodes/reference.js";
+import { QuereusError } from "../../common/errors.js";
+import { StatusCode } from "../../common/types.js";
+import * as AST from "../../parser/ast.js";
+import { ScalarPlanNode } from "../nodes/plan-node.js";
+import { isAggregateFunctionSchema } from '../../schema/function.js';
+import { buildExpression } from "./expression.js";
+import { ScalarFunctionCallNode } from "../nodes/function.js";
+import { resolveFunctionSchema } from "./schema-resolution.js";
+
+export function buildFunctionCall(ctx: PlanningContext, expr: AST.FunctionExpr, allowAggregates: boolean): ScalarPlanNode {
+	// In HAVING context, check if this function matches an existing aggregate
+	if (ctx.aggregates && ctx.aggregates.length > 0) {
+		// Try to find a matching aggregate
+		for (const agg of ctx.aggregates) {
+			if (agg.expression instanceof AggregateFunctionCallNode) {
+				const aggFuncNode = agg.expression as AggregateFunctionCallNode;
+				// Check if function name matches and argument count matches
+				if (aggFuncNode.functionName.toLowerCase() === expr.name.toLowerCase() &&
+					aggFuncNode.args.length === expr.args.length) {
+					// Check if arguments match
+					let argsMatch = true;
+					for (let i = 0; i < expr.args.length; i++) {
+						const exprArg = expr.args[i];
+						const aggArg = aggFuncNode.args[i];
+						// Simple check: if both are column references, check names match
+						if (exprArg.type === 'column' && (aggArg as any).expression?.type === 'column') {
+							if (exprArg.name.toLowerCase() !== (aggArg as any).expression.name.toLowerCase()) {
+								argsMatch = false;
+								break;
+							}
+						} else if (exprArg.type === 'literal' && (aggArg as any).expression?.type === 'literal') {
+							if (exprArg.value !== (aggArg as any).expression.value) {
+								argsMatch = false;
+								break;
+							}
+						}
+						// For other cases, we'd need more sophisticated comparison
+					}
+
+					if (argsMatch) {
+						// Found matching aggregate - return a column reference to it
+						const columnExpr: AST.ColumnExpr = {
+							type: 'column',
+							name: agg.alias
+						};
+						return new ColumnReferenceNode(
+							ctx.scope,
+							columnExpr,
+							agg.expression.getType(),
+							agg.attributeId,
+							agg.columnIndex
+						);
+					}
+				}
+			}
+		}
+	}
+
+	// Resolve function schema at build time
+	const functionSchema = resolveFunctionSchema(ctx, expr.name, expr.args.length);
+	if (functionSchema && isAggregateFunctionSchema(functionSchema)) {
+		if (!allowAggregates) {
+			throw new QuereusError(`Aggregate function ${expr.name} not allowed in this context`, StatusCode.ERROR, undefined, expr.loc?.start.line, expr.loc?.start.column);
+		}
+
+		// Build arguments for aggregate function
+		const args = expr.args.map(arg => buildExpression(ctx, arg, false)); // Aggregates can't contain other aggregates
+
+		return new AggregateFunctionCallNode(
+			ctx.scope,
+			expr,
+			expr.name,
+			functionSchema,
+			args,
+			expr.distinct ?? false, // Use the distinct field from the AST
+			undefined, // orderBy - TODO: parse from expr
+			undefined  // filter - TODO: parse from expr
+		);
+	} else {
+		// Regular scalar function
+		const args = expr.args.map(arg => buildExpression(ctx, arg, allowAggregates));
+		return new ScalarFunctionCallNode(ctx.scope, expr, functionSchema, args);
+	}
+}

package/src/planner/building/insert.ts

@@ -0,0 +1,336 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import { InsertNode } from '../nodes/insert-node.js';
+import { buildTableReference } from './table.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import { buildSelectStmt } from './select.js';
+import { buildWithClause } from './with.js';
+import { ValuesNode } from '../nodes/values-node.js';
+import { PlanNode, type RelationalPlanNode, type ScalarPlanNode } from '../nodes/plan-node.js';
+import { buildExpression } from './expression.js';
+import { checkColumnsAssignable, columnSchemaToDef } from '../type-utils.js';
+import type { ColumnDef } from '../../common/datatype.js';
+import type { CTEPlanNode } from '../nodes/cte-node.js';
+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 { 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';
+
+/**
+ * Creates a uniform row expansion projection that maps any relational source
+ * to the target table's column structure, filling in defaults for omitted columns.
+ * This ensures INSERT works orthogonally with any relational source.
+ */
+function createRowExpansionProjection(
+	ctx: PlanningContext,
+	sourceNode: RelationalPlanNode,
+	targetColumns: ColumnDef[],
+	tableReference: any
+): RelationalPlanNode {
+	const tableSchema = tableReference.tableSchema;
+
+	// If we're inserting into all columns in table order, no expansion needed
+	if (targetColumns.length === tableSchema.columns.length) {
+		const allColumnsMatch = targetColumns.every((tc, i) =>
+			tc.name.toLowerCase() === tableSchema.columns[i].name.toLowerCase()
+		);
+		if (allColumnsMatch) {
+			return sourceNode; // Source already matches table structure
+		}
+	}
+
+	// Create projection expressions for each table column
+	const projections: Projection[] = [];
+	const sourceAttributes = sourceNode.getAttributes();
+
+	tableSchema.columns.forEach((tableColumn: any) => {
+		// Find if this table column is in the target columns
+		const targetColIndex = targetColumns.findIndex(tc =>
+			tc.name.toLowerCase() === tableColumn.name.toLowerCase()
+		);
+
+		if (targetColIndex >= 0) {
+			// This column is provided by the source - reference the source column
+			if (targetColIndex < sourceAttributes.length) {
+				const sourceAttr = sourceAttributes[targetColIndex];
+				// Create a column reference to the source attribute
+				const columnRef = new ColumnReferenceNode(
+					ctx.scope,
+					{ type: 'column', name: sourceAttr.name } as AST.ColumnExpr,
+					sourceAttr.type,
+					sourceAttr.id,
+					targetColIndex
+				);
+				projections.push({
+					node: columnRef,
+					alias: tableColumn.name
+				});
+			} else {
+				throw new QuereusError(
+					`Source has fewer columns than expected for INSERT target columns`,
+					StatusCode.ERROR
+				);
+			}
+		} else {
+			// This column is omitted - use default value or NULL
+			let defaultNode: ScalarPlanNode;
+			if (tableColumn.defaultValue !== undefined) {
+				// Use default value
+				if (typeof tableColumn.defaultValue === 'object' && tableColumn.defaultValue !== null && 'type' in tableColumn.defaultValue) {
+					// It's an AST.Expression - build it into a plan node
+					defaultNode = buildExpression(ctx, tableColumn.defaultValue as AST.Expression) as ScalarPlanNode;
+				} else {
+					// Literal default value
+					defaultNode = buildExpression(ctx, { type: 'literal', value: tableColumn.defaultValue }) as ScalarPlanNode;
+				}
+			} else {
+				// No default value - use NULL
+				defaultNode = buildExpression(ctx, { type: 'literal', value: null }) as ScalarPlanNode;
+			}
+			projections.push({
+				node: defaultNode,
+				alias: tableColumn.name
+			});
+		}
+	});
+
+	// Create projection node that expands source to table structure
+	return new ProjectNode(ctx.scope, sourceNode, projections);
+}
+
+/**
+ * Validates that RETURNING expressions use appropriate NEW/OLD qualifiers for the operation type
+ */
+function validateReturningExpression(expr: AST.Expression, operationType: 'INSERT' | 'UPDATE' | 'DELETE'): void {
+	function checkExpression(e: AST.Expression): void {
+		if (e.type === 'column') {
+			if (e.table?.toLowerCase() === 'old' && operationType === 'INSERT') {
+				throw new QuereusError(
+					'OLD qualifier cannot be used in INSERT RETURNING clause',
+					StatusCode.ERROR
+				);
+			}
+			if (e.table?.toLowerCase() === 'new' && operationType === 'DELETE') {
+				throw new QuereusError(
+					'NEW qualifier cannot be used in DELETE RETURNING clause',
+					StatusCode.ERROR
+				);
+			}
+		} else if (e.type === 'binary') {
+			checkExpression(e.left);
+			checkExpression(e.right);
+		} else if (e.type === 'unary') {
+			checkExpression(e.expr);
+		} else if (e.type === 'function') {
+			e.args.forEach(checkExpression);
+		} else if (e.type === 'case') {
+			if (e.baseExpr) checkExpression(e.baseExpr);
+			e.whenThenClauses.forEach(clause => {
+				checkExpression(clause.when);
+				checkExpression(clause.then);
+			});
+			if (e.elseExpr) checkExpression(e.elseExpr);
+		} else if (e.type === 'cast') {
+			checkExpression(e.expr);
+		} else if (e.type === 'collate') {
+			checkExpression(e.expr);
+		} else if (e.type === 'subquery') {
+			// Subqueries in RETURNING are complex - for now, we'll skip validation
+			// A full implementation would need to traverse the subquery's AST
+		} else if (e.type === 'in') {
+			checkExpression(e.expr);
+			if (e.values) {
+				e.values.forEach(checkExpression);
+			}
+		} else if (e.type === 'exists') {
+			// EXISTS subqueries are complex - skip validation for now
+		} else if (e.type === 'windowFunction') {
+			checkExpression(e.function);
+		}
+		// Other expression types (literal, parameter) don't need validation
+	}
+
+	checkExpression(expr);
+}
+
+export function buildInsertStmt(
+	ctx: PlanningContext,
+	stmt: AST.InsertStmt,
+): PlanNode {
+	const tableReference = buildTableReference({ type: 'table', table: stmt.table }, ctx);
+
+	let targetColumns: ColumnDef[] = [];
+	if (stmt.columns && stmt.columns.length > 0) {
+		// Explicit columns specified
+		targetColumns = stmt.columns.map((colName, index) => columnSchemaToDef(colName, tableReference.tableSchema.columns[index]));
+	} else {
+		// No explicit columns - default to all table columns in order
+		targetColumns = tableReference.tableSchema.columns.map(col => columnSchemaToDef(col.name, col));
+	}
+
+	let sourceNode: RelationalPlanNode;
+
+	if (stmt.values) {
+		// VALUES clause - build the VALUES node
+		const rows = stmt.values.map(rowExprs =>
+			rowExprs.map(expr => buildExpression(ctx, expr) as PlanNode as ScalarPlanNode)
+		);
+
+		// Check that there are the right number of columns in each row
+		rows.forEach(row => {
+			if (row.length !== targetColumns.length) {
+				throw new QuereusError(`Column count mismatch in VALUES clause. Expected ${targetColumns.length} columns, got ${row.length}.`, StatusCode.ERROR, undefined, stmt.loc?.start.line, stmt.loc?.start.column);
+			}
+		});
+
+		// Create VALUES node with target column names
+		const targetColumnNames = targetColumns.map(col => col.name);
+		sourceNode = new ValuesNode(ctx.scope, rows, targetColumnNames);
+
+	} else if (stmt.select) {
+		// SELECT clause - build the SELECT statement
+		let parentCtes: Map<string, CTEPlanNode> = new Map();
+		if (stmt.withClause) {
+			parentCtes = buildWithClause(ctx, stmt.withClause);
+		}
+		const selectPlan = buildSelectStmt(ctx, stmt.select, parentCtes);
+		if (selectPlan.getType().typeClass !== 'relation') {
+			throw new QuereusError('SELECT statement in INSERT did not produce a relational plan.', StatusCode.INTERNAL, undefined, stmt.loc?.start.line, stmt.loc?.start.column);
+		}
+		sourceNode = selectPlan as RelationalPlanNode;
+		checkColumnsAssignable(sourceNode.getType().columns, targetColumns, stmt);
+
+	} else {
+		throw new QuereusError('INSERT statement must have a VALUES clause or a SELECT query.', StatusCode.ERROR);
+	}
+
+	// ORTHOGONAL ROW EXPANSION: Apply uniform row expansion to map any source to table structure with defaults
+	const expandedSourceNode = createRowExpansionProjection(ctx, sourceNode, targetColumns, tableReference);
+
+	// Update targetColumns to reflect all table columns since we've expanded the source
+	const finalTargetColumns = tableReference.tableSchema.columns.map(col => columnSchemaToDef(col.name, col));
+
+	// Create OLD/NEW attributes for INSERT (OLD = all NULL, NEW = actual values)
+	const oldAttributes = tableReference.tableSchema.columns.map((col) => ({
+		id: PlanNode.nextAttrId(),
+		name: col.name,
+		type: {
+			typeClass: 'scalar' as const,
+			affinity: col.affinity,
+			nullable: true, // OLD values are always NULL for INSERT
+			isReadOnly: false
+		},
+		sourceRelation: `OLD.${tableReference.tableSchema.name}`
+	}));
+
+	const newAttributes = tableReference.tableSchema.columns.map((col) => ({
+		id: PlanNode.nextAttrId(),
+		name: col.name,
+		type: {
+			typeClass: 'scalar' as const,
+			affinity: col.affinity,
+			nullable: !col.notNull,
+			isReadOnly: false
+		},
+		sourceRelation: `NEW.${tableReference.tableSchema.name}`
+	}));
+
+	const { oldRowDescriptor, newRowDescriptor, flatRowDescriptor } = buildOldNewRowDescriptors(oldAttributes, newAttributes);
+
+	const insertNode = new InsertNode(
+		ctx.scope,
+		tableReference,
+		finalTargetColumns,
+		expandedSourceNode,
+		flatRowDescriptor
+	);
+
+	const constraintCheckNode = new ConstraintCheckNode(
+		ctx.scope,
+		insertNode,
+		tableReference,
+		RowOp.INSERT,
+		oldRowDescriptor,
+		newRowDescriptor
+	);
+
+	// Add DML executor node to perform the actual database insert operations
+	const dmlExecutorNode = new DmlExecutorNode(
+		ctx.scope,
+		constraintCheckNode,
+		tableReference,
+		'insert',
+		stmt.onConflict
+	);
+
+	const resultNode: RelationalPlanNode = dmlExecutorNode;
+
+	if (stmt.returning && stmt.returning.length > 0) {
+		// Create returning scope with OLD/NEW attribute access
+		const returningScope = new RegisteredScope(ctx.scope);
+
+		// Register OLD.* symbols (always NULL for INSERT)
+		oldAttributes.forEach((attr, columnIndex) => {
+			const tableColumn = tableReference.tableSchema.columns[columnIndex];
+			returningScope.registerSymbol(`old.${tableColumn.name.toLowerCase()}`, (exp, s) =>
+				new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, columnIndex)
+			);
+		});
+
+		// Register NEW.* symbols and unqualified column names (default to NEW)
+		newAttributes.forEach((attr, columnIndex) => {
+			const tableColumn = tableReference.tableSchema.columns[columnIndex];
+
+			// NEW.column
+			returningScope.registerSymbol(`new.${tableColumn.name.toLowerCase()}`, (exp, s) =>
+				new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, columnIndex)
+			);
+
+			// Unqualified column (defaults to NEW)
+			returningScope.registerSymbol(tableColumn.name.toLowerCase(), (exp, s) =>
+				new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, columnIndex)
+			);
+
+			// Table-qualified form (table.column -> NEW)
+			const tblQualified = `${tableReference.tableSchema.name.toLowerCase()}.${tableColumn.name.toLowerCase()}`;
+			returningScope.registerSymbol(tblQualified, (exp, s) =>
+				new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, columnIndex)
+			);
+		});
+
+		// Build RETURNING projections in the OLD/NEW context
+		const returningProjections = stmt.returning.map(rc => {
+			// TODO: Support RETURNING *
+			if (rc.type === 'all') throw new QuereusError('RETURNING * not yet supported', StatusCode.UNSUPPORTED);
+
+					// Infer alias from column name if not explicitly provided
+		let alias = rc.alias;
+		if (!alias && rc.expr.type === 'column') {
+			// For qualified column references like NEW.id, normalize to lowercase
+			if (rc.expr.table) {
+				alias = `${rc.expr.table.toLowerCase()}.${rc.expr.name.toLowerCase()}`;
+			} else {
+				alias = rc.expr.name.toLowerCase();
+			}
+		}
+
+			// Validate that OLD references are not used in INSERT RETURNING
+			validateReturningExpression(rc.expr, 'INSERT');
+
+			return {
+				node: buildExpression({ ...ctx, scope: returningScope }, rc.expr) as ScalarPlanNode,
+				alias: alias
+			};
+		});
+
+		return new ReturningNode(ctx.scope, dmlExecutorNode, returningProjections);
+	}
+
+	return new SinkNode(ctx.scope, resultNode, 'insert');
+}

package/src/planner/building/pragma.ts

@@ -0,0 +1,33 @@
+import type { PlanningContext } from '../planning-context.js';
+import * as AST from '../../parser/ast.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode, type SqlValue } from '../../common/types.js';
+import { PragmaPlanNode } from '../nodes/pragma.js';
+import { SinkNode } from '../nodes/sink-node.js';
+import { getSyncLiteral } from '../../parser/utils.js';
+import type { PlanNode } from '../nodes/plan-node.js';
+
+export function buildPragmaStmt(ctx: PlanningContext, stmt: AST.PragmaStmt): PlanNode {
+	const pragmaName = stmt.name.toLowerCase();
+
+	let value: SqlValue | undefined;
+	if (stmt.value) {
+		if (stmt.value.type === 'literal') {
+			value = getSyncLiteral(stmt.value);
+		} else if (stmt.value.type === 'identifier') {
+			value = stmt.value.name;
+		} else {
+			throw new QuereusError(`Unsupported PRAGMA value type: ${(stmt.value as any).type}`, StatusCode.ERROR);
+		}
+	}
+
+	const pragmaNode = new PragmaPlanNode(ctx.scope, pragmaName, stmt, value);
+
+	// If this is a setting operation (has a value), wrap with SinkNode to ensure execution
+	if (value !== undefined) {
+		return new SinkNode(ctx.scope, pragmaNode, 'pragma-set');
+	}
+
+	// Reading operation - return the PRAGMA node directly
+	return pragmaNode;
+}