@quereus/quereus 0.7.2 → 0.7.4

package/src/planner/building/delete.ts

@@ -1,218 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { PlanningContext } from '../planning-context.js';
-import { DeleteNode } from '../nodes/delete-node.js';
-import { buildTableReference } from './table.js';
-import { buildExpression } from './expression.js';
-import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type Attribute, type RowDescriptor } from '../nodes/plan-node.js';
-import { FilterNode } from '../nodes/filter.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.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 { 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,
-  stmt: AST.DeleteStmt,
-): PlanNode {
-  const tableRetrieve = buildTableReference({ type: 'table', table: stmt.table }, ctx);
-  const tableReference = tableRetrieve.tableRef; // Extract the actual TableReferenceNode
-
-  // Process mutation context assignments if present
-  const mutationContextValues = new Map<string, ScalarPlanNode>();
-  const contextAttributes: Attribute[] = [];
-
-  if (stmt.contextValues && tableReference.tableSchema.mutationContext) {
-    // Create context attributes
-    tableReference.tableSchema.mutationContext.forEach((contextVar) => {
-      contextAttributes.push({
-        id: PlanNode.nextAttrId(),
-        name: contextVar.name,
-        type: {
-          typeClass: 'scalar' as const,
-          logicalType: contextVar.logicalType,
-          nullable: !contextVar.notNull,
-          isReadOnly: true
-        },
-        sourceRelation: `context.${tableReference.tableSchema.name}`
-      });
-    });
-
-    // Build context value expressions (evaluated in the base scope, before table scope)
-    stmt.contextValues.forEach((assignment) => {
-      const valueExpr = buildExpression(ctx, assignment.value) as ScalarPlanNode;
-      mutationContextValues.set(assignment.name, valueExpr);
-    });
-  }
-
-  // Plan the source of rows to delete. This is typically the table itself, potentially filtered.
-  let sourceNode: RelationalPlanNode = tableRetrieve; // Use the RetrieveNode as source
-
-  // Create a new scope with the table columns registered for column resolution
-  const tableScope = new RegisteredScope(ctx.scope);
-  const sourceAttributes = sourceNode.getAttributes();
-  sourceNode.getType().columns.forEach((c, i) => {
-    const attr = sourceAttributes[i];
-    tableScope.registerSymbol(c.name.toLowerCase(), (exp, s) =>
-      new ColumnReferenceNode(s, exp as AST.ColumnExpr, c.type, attr.id, i));
-  });
-
-  // Create a new planning context with the updated scope for WHERE clause resolution
-  const deleteCtx = { ...ctx, scope: tableScope };
-
-  if (stmt.where) {
-    const filterExpression = buildExpression(deleteCtx, stmt.where);
-    sourceNode = new FilterNode(deleteCtx.scope, sourceNode, filterExpression);
-  }
-
-  // Create OLD/NEW attributes for DELETE (OLD = actual values being deleted, NEW = all NULL)
-  const oldAttributes = tableReference.tableSchema.columns.map((col: any) => ({
-    id: PlanNode.nextAttrId(),
-    name: col.name,
-    type: {
-      typeClass: 'scalar' as const,
-      logicalType: col.logicalType,
-      nullable: !col.notNull,
-      isReadOnly: false
-    },
-    sourceRelation: `OLD.${tableReference.tableSchema.name}`
-  }));
-
-  const newAttributes = tableReference.tableSchema.columns.map((col: any) => ({
-    id: PlanNode.nextAttrId(),
-    name: col.name,
-    type: {
-      typeClass: 'scalar' as const,
-      logicalType: col.logicalType,
-      nullable: true, // NEW values are always NULL for DELETE
-      isReadOnly: false
-    },
-    sourceRelation: `NEW.${tableReference.tableSchema.name}`
-  }));
-
-  const { oldRowDescriptor, newRowDescriptor, flatRowDescriptor } = buildOldNewRowDescriptors(oldAttributes, newAttributes);
-
-  // Build context descriptor if we have context attributes
-  const contextDescriptor: RowDescriptor = contextAttributes.length > 0 ? [] : undefined as any;
-  if (contextDescriptor) {
-    contextAttributes.forEach((attr, index) => {
-      contextDescriptor[attr.id] = index;
-    });
-  }
-
-  // Build constraint checks at plan time
-  const constraintChecks = buildConstraintChecks(
-    deleteCtx,
-    tableReference.tableSchema,
-    RowOpFlag.DELETE,
-    oldAttributes,
-    newAttributes,
-    flatRowDescriptor,
-    contextAttributes
-  );
-
-  // Always inject ConstraintCheckNode for DELETE operations
-  const constraintCheckNode = new ConstraintCheckNode(
-    deleteCtx.scope,
-    sourceNode,
-    tableReference,
-    RowOpFlag.DELETE,
-    oldRowDescriptor,
-    newRowDescriptor,
-    flatRowDescriptor,
-    constraintChecks,
-    mutationContextValues.size > 0 ? mutationContextValues : undefined,
-    contextAttributes.length > 0 ? contextAttributes : undefined,
-    contextDescriptor
-  );
-
-  const deleteNode = new DeleteNode(
-    deleteCtx.scope,
-    tableReference,
-    constraintCheckNode,
-    oldRowDescriptor,
-    flatRowDescriptor,
-    mutationContextValues.size > 0 ? mutationContextValues : undefined,
-    contextAttributes.length > 0 ? contextAttributes : undefined,
-    contextDescriptor
-  );
-
-  // Add DML executor node to perform the actual database delete operations
-  const dmlExecutorNode = new DmlExecutorNode(
-    deleteCtx.scope,
-    deleteNode,
-    tableReference,
-    'delete',
-    undefined, // onConflict not used for DELETE
-    mutationContextValues.size > 0 ? mutationContextValues : undefined,
-    contextAttributes.length > 0 ? contextAttributes : undefined,
-    contextDescriptor
-  );
-
-  const resultNode: RelationalPlanNode = dmlExecutorNode;
-
-  if (stmt.returning && stmt.returning.length > 0) {
-    // Create returning scope with OLD/NEW attribute access
-    const returningScope = new RegisteredScope(deleteCtx.scope);
-
-    // Register OLD.* symbols (actual values being deleted)
-    oldAttributes.forEach((attr: any, columnIndex: any) => {
-      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 (always NULL for DELETE) and unqualified column names (default to OLD for DELETE)
-    newAttributes.forEach((attr: any, columnIndex: any) => {
-      const tableColumn = tableReference.tableSchema.columns[columnIndex];
-
-      // NEW.column (always NULL for DELETE)
-      returningScope.registerSymbol(`new.${tableColumn.name.toLowerCase()}`, (exp, s) =>
-        new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, columnIndex)
-      );
-
-      // Unqualified column (defaults to OLD for DELETE)
-      const oldAttr = oldAttributes[columnIndex];
-      returningScope.registerSymbol(tableColumn.name.toLowerCase(), (exp, s) =>
-        new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldAttr.type, oldAttr.id, columnIndex)
-      );
-
-      // Table-qualified form (table.column -> OLD for DELETE)
-      const tblQualified = `${tableReference.tableSchema.name.toLowerCase()}.${tableColumn.name.toLowerCase()}`;
-      returningScope.registerSymbol(tblQualified, (exp, s) =>
-        new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldAttr.type, oldAttr.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 OLD.id, normalize to lowercase
-        alias = rc.expr.table
-					? `${rc.expr.table.toLowerCase()}.${rc.expr.name.toLowerCase()}`
-					: rc.expr.name.toLowerCase();
-      }
-
-      return {
-        node: buildExpression({ ...deleteCtx, scope: returningScope }, rc.expr) as ScalarPlanNode,
-        alias: alias
-      };
-    });
-
-    return new ReturningNode(deleteCtx.scope, dmlExecutorNode, returningProjections);
-  }
-
-	return new SinkNode(deleteCtx.scope, resultNode, 'delete');
-}

package/src/planner/building/drop-assertion.ts

@@ -1,11 +0,0 @@
-import type { PlanningContext } from '../planning-context.js';
-import type * as AST from '../../parser/ast.js';
-import { DropAssertionNode } from '../nodes/drop-assertion-node.js';
-
-export function buildDropAssertionStmt(ctx: PlanningContext, stmt: AST.DropStmt): DropAssertionNode {
-	if (stmt.objectType !== 'assertion') {
-		throw new Error('Expected DROP ASSERTION statement');
-	}
-
-	return new DropAssertionNode(ctx.scope, stmt.name.name, stmt.ifExists);
-}

package/src/planner/building/drop-table.ts

@@ -1,13 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { PlanningContext } from '../planning-context.js';
-import { DropTableNode } from '../nodes/drop-table-node.js';
-
-export function buildDropTableStmt(
-  ctx: PlanningContext,
-  stmt: AST.DropStmt,
-): DropTableNode {
-  return new DropTableNode(
-    ctx.scope,
-    stmt,
-  );
-}

package/src/planner/building/drop-view.ts

@@ -1,19 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { PlanningContext } from '../planning-context.js';
-import { DropViewNode } from '../nodes/drop-view-node.js';
-
-/**
- * Builds a plan node for DROP VIEW statements.
- */
-export function buildDropViewStmt(ctx: PlanningContext, stmt: AST.DropStmt): DropViewNode {
-	// Extract schema and view name
-	const schemaName = stmt.name.schema || 'main';
-	const viewName = stmt.name.name;
-
-	return new DropViewNode(
-		ctx.scope,
-		viewName,
-		schemaName,
-		stmt.ifExists
-	);
-}

package/src/planner/building/expression.ts

@@ -1,205 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { PlanningContext } from '../planning-context.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';
-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';
-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':
-      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
-       // 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);
-       }
-       // 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,
-           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);
-         }
-         // 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,
-         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:
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      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

@@ -1,129 +0,0 @@
-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, isScalarFunctionSchema } from '../../schema/function.js';
-import { buildExpression } from "./expression.js";
-import { ScalarFunctionCallNode } from "../nodes/function.js";
-import { resolveFunctionSchema } from "./schema-resolution.js";
-import { CapabilityDetectors } from '../framework/characteristics.js';
-import type { ScalarType } from "../../common/datatype.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 (CapabilityDetectors.isAggregateFunction(agg.expression)) {
-				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.expression?.type === 'column') {
-							if (exprArg.name.toLowerCase() !== aggArg.expression.name.toLowerCase()) {
-								argsMatch = false;
-								break;
-							}
-						} else if (exprArg.type === 'literal' && aggArg.expression?.type === 'literal') {
-							if (exprArg.value !== aggArg.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
-
-		// Perform type inference if available
-		let inferredType: ScalarType | undefined;
-		if (functionSchema.inferReturnType) {
-			const argTypes = args.map(arg => arg.getType().logicalType);
-
-			// Validate argument types if validator is provided
-			if (functionSchema.validateArgTypes && !functionSchema.validateArgTypes(argTypes)) {
-				throw new QuereusError(
-					`Invalid argument types for aggregate function ${expr.name}`,
-					StatusCode.MISMATCH,
-					undefined,
-					expr.loc?.start.line,
-					expr.loc?.start.column
-				);
-			}
-
-			inferredType = functionSchema.inferReturnType(argTypes);
-		}
-
-		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
-			inferredType
-		);
-	} else {
-		// Regular scalar function
-		const args = expr.args.map(arg => buildExpression(ctx, arg, allowAggregates));
-
-		// Perform type inference if available
-		let inferredType: ScalarType | undefined;
-		if (isScalarFunctionSchema(functionSchema) && functionSchema.inferReturnType) {
-			const argTypes = args.map(arg => arg.getType().logicalType);
-
-			// Validate argument types if validator is provided
-			if (functionSchema.validateArgTypes && !functionSchema.validateArgTypes(argTypes)) {
-				throw new QuereusError(
-					`Invalid argument types for function ${expr.name}`,
-					StatusCode.MISMATCH,
-					undefined,
-					expr.loc?.start.line,
-					expr.loc?.start.column
-				);
-			}
-
-			inferredType = functionSchema.inferReturnType(argTypes);
-		}
-
-		return new ScalarFunctionCallNode(ctx.scope, expr, functionSchema, args, inferredType);
-	}
-}