@quereus/quereus 0.5.1 → 0.6.0

package/src/func/builtins/string.ts

@@ -1,14 +1,27 @@
 import { createAggregateFunction, createScalarFunction, createTableValuedFunction } from '../registration.js';
-import type { Row, SqlValue } from '../../common/types.js';
+import type { Row, SqlValue, DeepReadonly } from '../../common/types.js';
 import { createLogger } from '../../common/logger.js';
 import { simpleLike, simpleGlob } from '../../util/patterns.js';
+import { INTEGER_TYPE, TEXT_TYPE } from '../../types/builtin-types.js';
+import type { LogicalType } from '../../types/logical-type.js';
 
 const log = createLogger('func:builtins:scalar');
 const warnLog = log.extend('warn');
 
 // --- length(X) ---
 export const lengthFunc = createScalarFunction(
-	{ name: 'length', numArgs: 1, deterministic: true },
+	{
+		name: 'length',
+		numArgs: 1,
+		deterministic: true,
+		// Type inference: length always returns INTEGER
+		inferReturnType: () => ({
+			typeClass: 'scalar',
+			logicalType: INTEGER_TYPE,
+			nullable: false,
+			isReadOnly: true
+		})
+	},
 	(arg: SqlValue): SqlValue => {
 		if (arg === null) return null;
 		if (typeof arg === 'string') return arg.length;
@@ -18,83 +31,62 @@ export const lengthFunc = createScalarFunction(
 );
 
 // --- substr(X, Y, Z?) --- Also SUBSTRING
-export const substrFunc = createScalarFunction(
-	{ name: 'substr', numArgs: -1, deterministic: true },
-	(str: SqlValue, start: SqlValue, len?: SqlValue): SqlValue => {
-		if (str === null || start === null) return null;
 
-		const s = String(str); // Coerce main arg to string
-		let y = Number(start);
-		let z = len === undefined ? undefined : Number(len);
+const substrImpl = (str: SqlValue, start: SqlValue, len?: SqlValue): SqlValue => {
+	if (str === null || start === null) return null;
 
-		if (isNaN(y) || (z !== undefined && isNaN(z))) return null;
+	const s = String(str); // Coerce main arg to string
+	let y = Number(start);
+	let z = len === undefined ? undefined : Number(len);
 
-		// SQLite uses 1-based indexing, negative start counts from end
-		y = Math.trunc(y);
-		z = z === undefined ? undefined : Math.trunc(z);
+	if (isNaN(y) || (z !== undefined && isNaN(z))) return null;
 
-		const strLen = s.length;
-		let begin: number;
+	// SQLite uses 1-based indexing, negative start counts from end
+	y = Math.trunc(y);
+	z = z === undefined ? undefined : Math.trunc(z);
 
-		if (y > 0) {
-			begin = y - 1;
-		} else if (y < 0) {
-			begin = strLen + y;
-		} else { // y == 0
-			begin = 0;
-		}
-		begin = Math.max(0, begin); // Clamp start index
-
-		let end: number;
-		if (z === undefined) {
-			end = strLen; // No length means to end of string
-		} else if (z >= 0) {
-			end = begin + z;
-		} else { // Negative length is not standard SQL, SQLite returns empty string
-			end = begin;
-		}
+	const strLen = s.length;
+	let begin: number;
 
-		return s.substring(begin, end);
+	if (y > 0) {
+		begin = y - 1;
+	} else if (y < 0) {
+		begin = strLen + y;
+	} else { // y == 0
+		begin = 0;
+	}
+	begin = Math.max(0, begin); // Clamp start index
+
+	let end: number;
+	if (z === undefined) {
+		end = strLen; // No length means to end of string
+	} else if (z >= 0) {
+		end = begin + z;
+	} else { // Negative length is not standard SQL, SQLite returns empty string
+		end = begin;
 	}
-);
-
-export const substringFunc = createScalarFunction(
-	{ name: 'substring', numArgs: -1, deterministic: true },
-	(str: SqlValue, start: SqlValue, len?: SqlValue): SqlValue => {
-		if (str === null || start === null) return null;
-
-		const s = String(str);
-		let y = Number(start);
-		let z = len === undefined ? undefined : Number(len);
-
-		if (isNaN(y) || (z !== undefined && isNaN(z))) return null;
 
-		y = Math.trunc(y);
-		z = z === undefined ? undefined : Math.trunc(z);
+	return s.substring(begin, end);
+};
 
-		const strLen = s.length;
-		let begin: number;
+const substrTypeInference = {
+	// Type inference: substr always returns TEXT
+	inferReturnType: (_argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ({
+		typeClass: 'scalar' as const,
+		logicalType: TEXT_TYPE,
+		nullable: false,
+		isReadOnly: true
+	})
+};
 
-		if (y > 0) {
-			begin = y - 1;
-		} else if (y < 0) {
-			begin = strLen + y;
-		} else {
-			begin = 0;
-		}
-		begin = Math.max(0, begin);
-
-		let end: number;
-		if (z === undefined) {
-			end = strLen;
-		} else if (z >= 0) {
-			end = begin + z;
-		} else {
-			end = begin;
-		}
+export const substrFunc = createScalarFunction(
+	{ name: 'substr', numArgs: -1, deterministic: true, ...substrTypeInference },
+	substrImpl
+);
 
-		return s.substring(begin, end);
-	}
+export const substringFunc = createScalarFunction(
+	{ name: 'substring', numArgs: -1, deterministic: true, ...substrTypeInference },
+	substrImpl
 );
 
 export const likeFunc = createScalarFunction(
@@ -113,9 +105,19 @@ export const globFunc = createScalarFunction(
 	}
 );
 
+// Common type inference for string functions that return TEXT
+const textReturnTypeInference = {
+	inferReturnType: (_argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ({
+		typeClass: 'scalar' as const,
+		logicalType: TEXT_TYPE,
+		nullable: false,
+		isReadOnly: true
+	})
+};
+
 // --- trim(X, Y?) ---
 export const trimFunc = createScalarFunction(
-	{ name: 'trim', numArgs: -1, deterministic: true },
+	{ name: 'trim', numArgs: -1, deterministic: true, ...textReturnTypeInference },
 	(strVal: SqlValue, charsVal?: SqlValue): SqlValue => {
 		if (strVal === null) return null;
 		const str = String(strVal);
@@ -138,7 +140,7 @@ export const trimFunc = createScalarFunction(
 
 // --- ltrim(X, Y?) ---
 export const ltrimFunc = createScalarFunction(
-	{ name: 'ltrim', numArgs: -1, deterministic: true },
+	{ name: 'ltrim', numArgs: -1, deterministic: true, ...textReturnTypeInference },
 	(strVal: SqlValue, charsVal?: SqlValue): SqlValue => {
 		if (strVal === null) return null;
 		const str = String(strVal);
@@ -161,7 +163,7 @@ export const ltrimFunc = createScalarFunction(
 
 // --- rtrim(X, Y?) ---
 export const rtrimFunc = createScalarFunction(
-	{ name: 'rtrim', numArgs: -1, deterministic: true },
+	{ name: 'rtrim', numArgs: -1, deterministic: true, ...textReturnTypeInference },
 	(strVal: SqlValue, charsVal?: SqlValue): SqlValue => {
 		if (strVal === null) return null;
 		const str = String(strVal);
@@ -184,7 +186,7 @@ export const rtrimFunc = createScalarFunction(
 
 // --- replace(X, Y, Z) ---
 export const replaceFunc = createScalarFunction(
-	{ name: 'replace', numArgs: 3, deterministic: true },
+	{ name: 'replace', numArgs: 3, deterministic: true, ...textReturnTypeInference },
 	(strVal: SqlValue, patternVal: SqlValue, replacementVal: SqlValue): SqlValue => {
 		if (strVal === null || patternVal === null || replacementVal === null) return null;
 
@@ -199,7 +201,18 @@ export const replaceFunc = createScalarFunction(
 
 // --- instr(X, Y) ---
 export const instrFunc = createScalarFunction(
-	{ name: 'instr', numArgs: 2, deterministic: true },
+	{
+		name: 'instr',
+		numArgs: 2,
+		deterministic: true,
+		// Type inference: instr returns INTEGER
+		inferReturnType: () => ({
+			typeClass: 'scalar',
+			logicalType: INTEGER_TYPE,
+			nullable: false,
+			isReadOnly: true
+		})
+	},
 	(strVal: SqlValue, subVal: SqlValue): SqlValue => {
 		if (strVal === null || subVal === null) return 0;
 
@@ -216,7 +229,7 @@ export const instrFunc = createScalarFunction(
 
 // String reverse function
 export const reverseFunc = createScalarFunction(
-	{ name: 'reverse', numArgs: 1, deterministic: true },
+	{ name: 'reverse', numArgs: 1, deterministic: true, ...textReturnTypeInference },
 	(str: SqlValue): SqlValue => {
 		if (typeof str !== 'string') return null;
 		return str.split('').reverse().join('');
@@ -225,7 +238,7 @@ export const reverseFunc = createScalarFunction(
 
 // Left padding function
 export const lpadFunc = createScalarFunction(
-	{ name: 'lpad', numArgs: 3, deterministic: true },
+	{ name: 'lpad', numArgs: 3, deterministic: true, ...textReturnTypeInference },
 	(str: SqlValue, len: SqlValue, pad: SqlValue): SqlValue => {
 		if (typeof str !== 'string' || typeof len !== 'number' || typeof pad !== 'string') return null;
 
@@ -239,7 +252,7 @@ export const lpadFunc = createScalarFunction(
 
 // Right padding function
 export const rpadFunc = createScalarFunction(
-	{ name: 'rpad', numArgs: 3, deterministic: true },
+	{ name: 'rpad', numArgs: 3, deterministic: true, ...textReturnTypeInference },
 	(str: SqlValue, len: SqlValue, pad: SqlValue): SqlValue => {
 		if (typeof str !== 'string' || typeof len !== 'number' || typeof pad !== 'string') return null;
 
@@ -278,7 +291,7 @@ export const stringConcatFunc = createAggregateFunction(
 
 // --- lower(X) ---
 export const lowerFunc = createScalarFunction(
-	{ name: 'lower', numArgs: 1, deterministic: true },
+	{ name: 'lower', numArgs: 1, deterministic: true, ...textReturnTypeInference },
 	(arg: SqlValue): SqlValue => {
 		return typeof arg === 'string' ? arg.toLowerCase() : null;
 	}
@@ -286,7 +299,7 @@ export const lowerFunc = createScalarFunction(
 
 // --- upper(X) ---
 export const upperFunc = createScalarFunction(
-	{ name: 'upper', numArgs: 1, deterministic: true },
+	{ name: 'upper', numArgs: 1, deterministic: true, ...textReturnTypeInference },
 	(arg: SqlValue): SqlValue => {
 		return typeof arg === 'string' ? arg.toUpperCase() : null;
 	}

package/src/func/builtins/timespan.ts

@@ -0,0 +1,179 @@
+import { Temporal } from 'temporal-polyfill';
+import { StatusCode, type SqlValue } from '../../common/types.js';
+import { createScalarFunction } from '../registration.js';
+import { QuereusError } from '../../common/errors.js';
+
+/**
+ * Helper to parse a value as a Temporal.Duration
+ */
+function parseDuration(value: SqlValue): Temporal.Duration | null {
+	if (value === null) return null;
+	if (typeof value !== 'string') return null;
+
+	try {
+		return Temporal.Duration.from(value);
+	} catch {
+		return null;
+	}
+}
+
+// --- Extraction Functions ---
+
+/**
+ * timespan_years() - Extract years component from timespan
+ */
+export const timespanYearsFunc = createScalarFunction(
+	{ name: 'timespan_years', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		return duration.years;
+	}
+);
+
+/**
+ * timespan_months() - Extract months component from timespan
+ */
+export const timespanMonthsFunc = createScalarFunction(
+	{ name: 'timespan_months', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		return duration.months;
+	}
+);
+
+/**
+ * timespan_weeks() - Extract weeks component from timespan
+ */
+export const timespanWeeksFunc = createScalarFunction(
+	{ name: 'timespan_weeks', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		return duration.weeks;
+	}
+);
+
+/**
+ * timespan_days() - Extract days component from timespan
+ */
+export const timespanDaysFunc = createScalarFunction(
+	{ name: 'timespan_days', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		return duration.days;
+	}
+);
+
+/**
+ * timespan_hours() - Extract hours component from timespan
+ */
+export const timespanHoursFunc = createScalarFunction(
+	{ name: 'timespan_hours', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		return duration.hours;
+	}
+);
+
+/**
+ * timespan_minutes() - Extract minutes component from timespan
+ */
+export const timespanMinutesFunc = createScalarFunction(
+	{ name: 'timespan_minutes', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		return duration.minutes;
+	}
+);
+
+/**
+ * timespan_seconds() - Extract seconds component from timespan
+ */
+export const timespanSecondsFunc = createScalarFunction(
+	{ name: 'timespan_seconds', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		return duration.seconds + duration.milliseconds / 1000 + duration.microseconds / 1000000 + duration.nanoseconds / 1000000000;
+	}
+);
+
+// --- Total Functions ---
+
+/**
+ * timespan_total_seconds() - Convert entire timespan to seconds
+ */
+export const timespanTotalSecondsFunc = createScalarFunction(
+	{ name: 'timespan_total_seconds', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		try {
+			// Use a reference date for calendar units (weeks, months, years)
+			const referenceDate = Temporal.PlainDate.from('2024-01-01');
+			return duration.total({ unit: 'seconds', relativeTo: referenceDate });
+		} catch {
+			return null;
+		}
+	}
+);
+
+/**
+ * timespan_total_minutes() - Convert entire timespan to minutes
+ */
+export const timespanTotalMinutesFunc = createScalarFunction(
+	{ name: 'timespan_total_minutes', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		try {
+			// Use a reference date for calendar units (weeks, months, years)
+			const referenceDate = Temporal.PlainDate.from('2024-01-01');
+			return duration.total({ unit: 'minutes', relativeTo: referenceDate });
+		} catch {
+			return null;
+		}
+	}
+);
+
+/**
+ * timespan_total_hours() - Convert entire timespan to hours
+ */
+export const timespanTotalHoursFunc = createScalarFunction(
+	{ name: 'timespan_total_hours', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		try {
+			// Use a reference date for calendar units (weeks, months, years)
+			const referenceDate = Temporal.PlainDate.from('2024-01-01');
+			return duration.total({ unit: 'hours', relativeTo: referenceDate });
+		} catch {
+			return null;
+		}
+	}
+);
+
+/**
+ * timespan_total_days() - Convert entire timespan to days
+ */
+export const timespanTotalDaysFunc = createScalarFunction(
+	{ name: 'timespan_total_days', numArgs: 1, deterministic: true },
+	(value: SqlValue): SqlValue => {
+		const duration = parseDuration(value);
+		if (!duration) return null;
+		try {
+			// Use a reference date for calendar units (weeks, months, years)
+			const referenceDate = Temporal.PlainDate.from('2024-01-01');
+			return duration.total({ unit: 'days', relativeTo: referenceDate });
+		} catch {
+			return null;
+		}
+	}
+);
+

package/src/func/registration.ts

@@ -1,8 +1,10 @@
 import type { AggregateFinalizer, AggregateReducer, IntegratedTableValuedFunc, ScalarFunc, TableValuedFunc, ScalarFunctionSchema,
 	TableValuedFunctionSchema, AggregateFunctionSchema } from '../schema/function.js';
 import { FunctionFlags } from '../common/constants.js';
-import { SqlDataType } from '../common/types.js';
 import type { ScalarType, RelationType } from '../common/datatype.js';
+import { REAL_TYPE } from '../types/builtin-types.js';
+import type { LogicalType } from '../types/logical-type.js';
+import type { DeepReadonly } from '../common/types.js';
 
 /**
  * Configuration options for scalar functions
@@ -18,6 +20,18 @@ interface ScalarFuncOptions {
 	deterministic?: boolean;
 	/** Return type information */
 	returnType?: ScalarType;
+	/**
+	 * Optional type inference function for polymorphic functions.
+	 * If provided, this function will be called at planning time to determine
+	 * the return type based on the actual argument types.
+	 */
+	inferReturnType?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ScalarType;
+	/**
+	 * Optional argument type validation function.
+	 * If provided, this function will be called at planning time to validate
+	 * that the argument types are acceptable for this function.
+	 */
+	validateArgTypes?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => boolean;
 }
 
 /**
@@ -56,6 +70,18 @@ interface AggregateFuncOptions {
 	initialValue?: AggValue;
 	/** Return type information */
 	returnType?: ScalarType;
+	/**
+	 * Optional type inference function for polymorphic aggregate functions.
+	 * If provided, this function will be called at planning time to determine
+	 * the return type based on the actual argument types.
+	 */
+	inferReturnType?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ScalarType;
+	/**
+	 * Optional argument type validation function.
+	 * If provided, this function will be called at planning time to validate
+	 * that the argument types are acceptable for this function.
+	 */
+	validateArgTypes?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => boolean;
 }
 
 /**
@@ -69,7 +95,7 @@ interface AggregateFuncOptions {
 export function createScalarFunction(options: ScalarFuncOptions, jsFunc: ScalarFunc): ScalarFunctionSchema {
 	const returnType: ScalarType = options.returnType ?? {
 		typeClass: 'scalar',
-		affinity: SqlDataType.NUMERIC,
+		logicalType: REAL_TYPE,
 		nullable: true,
 		isReadOnly: true
 	};
@@ -79,7 +105,9 @@ export function createScalarFunction(options: ScalarFuncOptions, jsFunc: ScalarF
 		numArgs: options.numArgs,
 		flags: options.flags ?? (FunctionFlags.UTF8 | (options.deterministic !== false ? FunctionFlags.DETERMINISTIC : 0)),
 		returnType,
-		implementation: jsFunc
+		implementation: jsFunc,
+		inferReturnType: options.inferReturnType,
+		validateArgTypes: options.validateArgTypes
 	};
 }
 
@@ -154,7 +182,7 @@ export function createAggregateFunction(
 ): AggregateFunctionSchema {
 	const returnType: ScalarType = options.returnType ?? {
 		typeClass: 'scalar',
-		affinity: SqlDataType.NUMERIC,
+		logicalType: REAL_TYPE,
 		nullable: true,
 		isReadOnly: true
 	};
@@ -166,6 +194,8 @@ export function createAggregateFunction(
 		returnType,
 		stepFunction: stepFunc,
 		finalizeFunction: finalizeFunc,
-		initialValue: options.initialValue
+		initialValue: options.initialValue,
+		inferReturnType: options.inferReturnType,
+		validateArgTypes: options.validateArgTypes
 	};
 }

package/src/index.ts

@@ -63,7 +63,8 @@ export {
 export {
 	DATE_TYPE,
 	TIME_TYPE,
-	DATETIME_TYPE
+	DATETIME_TYPE,
+	TIMESPAN_TYPE
 } from './types/temporal-types.js';
 export { JSON_TYPE } from './types/json-type.js';
 export {

package/src/parser/parser.ts

@@ -1512,8 +1512,8 @@ export class Parser {
 		}
 
 		// Function call (with optional window function support)
-		if (this.checkIdentifierLike(['key', 'action', 'set', 'default', 'check', 'unique', 'references', 'on', 'cascade', 'restrict', 'like']) && this.checkNext(1, TokenType.LPAREN)) {
-			const name = this.consumeIdentifier(['key', 'action', 'set', 'default', 'check', 'unique', 'references', 'on', 'cascade', 'restrict', 'like'], "Expected function name.");
+		if (this.checkIdentifierLike(['key', 'action', 'set', 'default', 'check', 'unique', 'references', 'on', 'cascade', 'restrict', 'like', 'replace']) && this.checkNext(1, TokenType.LPAREN)) {
+			const name = this.consumeIdentifier(['key', 'action', 'set', 'default', 'check', 'unique', 'references', 'on', 'cascade', 'restrict', 'like', 'replace'], "Expected function name.");
 
 			this.consume(TokenType.LPAREN, "Expected '(' after function name.");
 

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

@@ -83,7 +83,7 @@ export function buildConstraintChecks(
       if (newAttrId !== undefined) {
         const newColumnType = {
           typeClass: 'scalar' as const,
-          affinity: tableColumn.affinity,
+          logicalType: tableColumn.logicalType,
           nullable: !tableColumn.notNull,
           isReadOnly: false
         };
@@ -104,7 +104,7 @@ export function buildConstraintChecks(
       if (oldAttrId !== undefined) {
         const oldColumnType = {
           typeClass: 'scalar' as const,
-          affinity: tableColumn.affinity,
+          logicalType: tableColumn.logicalType,
           nullable: true, // OLD values can be NULL (especially for INSERT)
           isReadOnly: false
         };

package/src/planner/building/delete.ts

@@ -36,7 +36,7 @@ export function buildDeleteStmt(
         name: contextVar.name,
         type: {
           typeClass: 'scalar' as const,
-          affinity: contextVar.affinity,
+          logicalType: contextVar.logicalType,
           nullable: !contextVar.notNull,
           isReadOnly: true
         },
@@ -77,7 +77,7 @@ export function buildDeleteStmt(
     name: col.name,
     type: {
       typeClass: 'scalar' as const,
-      affinity: col.affinity,
+      logicalType: col.logicalType,
       nullable: !col.notNull,
       isReadOnly: false
     },
@@ -89,7 +89,7 @@ export function buildDeleteStmt(
     name: col.name,
     type: {
       typeClass: 'scalar' as const,
-      affinity: col.affinity,
+      logicalType: col.logicalType,
       nullable: true, // NEW values are always NULL for DELETE
       isReadOnly: false
     },

package/src/planner/building/function-call.ts

@@ -5,11 +5,12 @@ 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 { 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
@@ -70,6 +71,25 @@ export function buildFunctionCall(ctx: PlanningContext, expr: AST.FunctionExpr,
 		// 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,
@@ -78,11 +98,32 @@ export function buildFunctionCall(ctx: PlanningContext, expr: AST.FunctionExpr,
 			args,
 			expr.distinct ?? false, // Use the distinct field from the AST
 			undefined, // orderBy - TODO: parse from expr
-			undefined  // filter - 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));
-		return new ScalarFunctionCallNode(ctx.scope, expr, functionSchema, args);
+
+		// 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);
 	}
 }