@quereus/quereus 0.5.2 → 0.6.1

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);
 	}
 }

package/src/planner/building/insert.ts

@@ -197,7 +197,7 @@ export function buildInsertStmt(
 				name: contextVar.name,
 				type: {
 					typeClass: 'scalar' as const,
-					affinity: contextVar.affinity,
+					logicalType: contextVar.logicalType,
 					nullable: !contextVar.notNull,
 					isReadOnly: true
 				},
@@ -287,7 +287,7 @@ export function buildInsertStmt(
 		name: col.name,
 		type: {
 			typeClass: 'scalar' as const,
-			affinity: col.affinity,
+			logicalType: col.logicalType,
 			nullable: true, // OLD values are always NULL for INSERT
 			isReadOnly: false
 		},
@@ -299,7 +299,7 @@ export function buildInsertStmt(
 		name: col.name,
 		type: {
 			typeClass: 'scalar' as const,
-			affinity: col.affinity,
+			logicalType: col.logicalType,
 			nullable: !col.notNull,
 			isReadOnly: false
 		},

package/src/planner/building/select.ts

@@ -18,6 +18,7 @@ import { InternalRecursiveCTERefNode as _InternalRecursiveCTERefNode } from '../
 import type { CTEScopeNode, CTEPlanNode } from '../nodes/cte-node.js';
 import { JoinNode } from '../nodes/join-node.js';
 import { ColumnReferenceNode } from '../nodes/reference.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 import { ValuesNode } from '../nodes/values-node.js';
 import { createLogger } from '../../common/logger.js';
 
@@ -440,7 +441,7 @@ export function buildFrom(fromClause: AST.FromClause, parentContext: PlanningCon
 		columnNames.forEach((colName, i) => {
 			if (i < subqueryAttributes.length) {
 				const attr = subqueryAttributes[i];
-				const columnType = fromTable.getType().columns[i]?.type || { typeClass: 'scalar', affinity: 'TEXT', nullable: true, isReadOnly: true };
+				const columnType = fromTable.getType().columns[i]?.type || { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: true, isReadOnly: true };
 				subqueryScope.registerSymbol(colName.toLowerCase(), (exp, s) =>
 					new ColumnReferenceNode(s, exp as AST.ColumnExpr, columnType, attr.id, i));
 			}
@@ -479,7 +480,7 @@ export function buildFrom(fromClause: AST.FromClause, parentContext: PlanningCon
 		columnNames.forEach((colName, i) => {
 			if (i < mutatingAttributes.length) {
 				const attr = mutatingAttributes[i];
-				const columnType = fromTable.getType().columns[i]?.type || { typeClass: 'scalar', affinity: 'TEXT', nullable: true, isReadOnly: false };
+				const columnType = fromTable.getType().columns[i]?.type || { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: true, isReadOnly: false };
 				mutatingScope.registerSymbol(colName.toLowerCase(), (exp, s) =>
 					new ColumnReferenceNode(s, exp as AST.ColumnExpr, columnType, attr.id, i));
 			}

package/src/planner/building/update.ts

@@ -36,7 +36,7 @@ export function buildUpdateStmt(
         name: contextVar.name,
         type: {
           typeClass: 'scalar' as const,
-          affinity: contextVar.affinity,
+          logicalType: contextVar.logicalType,
           nullable: !contextVar.notNull,
           isReadOnly: true
         },
@@ -86,7 +86,7 @@ export function buildUpdateStmt(
     name: col.name,
     type: {
       typeClass: 'scalar' as const,
-      affinity: col.affinity,
+      logicalType: col.logicalType,
       nullable: !col.notNull,
       isReadOnly: false
     },
@@ -98,7 +98,7 @@ export function buildUpdateStmt(
     name: col.name,
     type: {
       typeClass: 'scalar' as const,
-      affinity: col.affinity,
+      logicalType: col.logicalType,
       nullable: !col.notNull,
       isReadOnly: false
     },
@@ -151,7 +151,7 @@ export function buildUpdateStmt(
           exp as AST.ColumnExpr,
           {
             typeClass: 'scalar',
-            affinity: tableColumn.affinity,
+            logicalType: tableColumn.logicalType,
             nullable: !tableColumn.notNull,
             isReadOnly: false
           },
@@ -168,7 +168,7 @@ export function buildUpdateStmt(
           exp as AST.ColumnExpr,
           {
             typeClass: 'scalar',
-            affinity: tableColumn.affinity,
+            logicalType: tableColumn.logicalType,
             nullable: !tableColumn.notNull,
             isReadOnly: false
           },
@@ -184,7 +184,7 @@ export function buildUpdateStmt(
           exp as AST.ColumnExpr,
           {
             typeClass: 'scalar',
-            affinity: tableColumn.affinity,
+            logicalType: tableColumn.logicalType,
             nullable: !tableColumn.notNull,
             isReadOnly: false
           },
@@ -200,7 +200,7 @@ export function buildUpdateStmt(
           exp as AST.ColumnExpr,
           {
             typeClass: 'scalar',
-            affinity: tableColumn.affinity,
+            logicalType: tableColumn.logicalType,
             nullable: !tableColumn.notNull,
             isReadOnly: false
           },

package/src/planner/nodes/aggregate-function.ts

@@ -6,6 +6,7 @@ import type { FunctionSchema } from '../../schema/function.js';
 import { isAggregateFunctionSchema } from '../../schema/function.js';
 import type * as AST from '../../parser/ast.js';
 import { formatExpressionList, formatScalarType } from '../../util/plan-formatter.js';
+import { NULL_TYPE } from '../../types/builtin-types.js';
 
 /**
  * Represents an aggregate function call within a SQL query.
@@ -13,6 +14,7 @@ import { formatExpressionList, formatScalarType } from '../../util/plan-formatte
  */
 export class AggregateFunctionCallNode extends PlanNode implements ScalarPlanNode {
 	readonly nodeType = PlanNodeType.ScalarFunctionCall; // Using same type as scalar functions
+	private readonly _inferredType?: ScalarType;
 
 	constructor(
 		scope: Scope,
@@ -22,12 +24,19 @@ export class AggregateFunctionCallNode extends PlanNode implements ScalarPlanNod
 		public readonly args: ReadonlyArray<ScalarPlanNode>,
 		public readonly isDistinct: boolean = false,
 		public readonly orderBy?: ReadonlyArray<{ expression: ScalarPlanNode; direction: 'asc' | 'desc' }>,
-		public readonly filter?: ScalarPlanNode
+		public readonly filter?: ScalarPlanNode,
+		inferredType?: ScalarType
 	) {
 		super(scope);
+		this._inferredType = inferredType;
 	}
 
 	getType(): ScalarType {
+		// Use inferred type if available
+		if (this._inferredType) {
+			return this._inferredType;
+		}
+
 		// Get the return type from the function schema
 		if (isAggregateFunctionSchema(this.functionSchema)) {
 			return this.functionSchema.returnType;
@@ -36,7 +45,7 @@ export class AggregateFunctionCallNode extends PlanNode implements ScalarPlanNod
 		// Fallback for non-aggregate functions (shouldn't happen)
 		return {
 			typeClass: 'scalar',
-			affinity: 0,
+			logicalType: NULL_TYPE,
 			nullable: true, // Aggregates can return NULL
 			isReadOnly: true
 		};
@@ -109,7 +118,8 @@ export class AggregateFunctionCallNode extends PlanNode implements ScalarPlanNod
 			newArgs,
 			this.isDistinct,
 			newOrderBy,
-			newFilter
+			newFilter,
+			this._inferredType
 		);
 	}
 

package/src/planner/nodes/cte-node.ts

@@ -1,10 +1,10 @@
 import { PlanNode, type UnaryRelationalNode, type RelationalPlanNode, type Attribute, type TableDescriptor, isRelationalNode } from './plan-node.js';
 import type { RelationType, ScalarType } from '../../common/datatype.js';
-import { SqlDataType } from '../../common/types.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
 import { Cached } from '../../util/cached.js';
 import type { CTECapable } from '../framework/characteristics.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 
 /**
  * Narrow contract that any node must satisfy to be placed in the CTE lookup map
@@ -74,7 +74,7 @@ export class CTENode extends PlanNode implements CTEPlanNode, CTEScopeNode, CTEC
 			}
 			// Fallback: generic TEXT scalar if nothing else is available (should not normally happen)
 			if (!resolvedType) {
-				resolvedType = { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: true, isReadOnly: false } satisfies ScalarType;
+				resolvedType = { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: true, isReadOnly: false } satisfies ScalarType;
 			}
 			return {
 				id: srcAttr?.id ?? PlanNode.nextAttrId(),

package/src/planner/nodes/declarative-schema.ts

@@ -3,7 +3,7 @@ import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
 import type * as AST from '../../parser/ast.js';
 import { RelationType, type VoidType } from '../../common/datatype.js';
-import { SqlDataType } from '../../common/types.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 
 /**
  * DECLARE SCHEMA statement plan node
@@ -66,7 +66,7 @@ export class DiffSchemaNode extends PlanNode implements RelationalPlanNode {
 					name: 'ddl',
 					type: {
 						typeClass: 'scalar',
-						affinity: SqlDataType.TEXT,
+						logicalType: TEXT_TYPE,
 						nullable: false,
 						isReadOnly: true,
 					},
@@ -172,7 +172,7 @@ export class ExplainSchemaNode extends PlanNode implements RelationalPlanNode {
 					name: 'info',
 					type: {
 						typeClass: 'scalar',
-						affinity: SqlDataType.TEXT,
+						logicalType: TEXT_TYPE,
 						nullable: false,
 						isReadOnly: true,
 					},

package/src/planner/nodes/function.ts

@@ -9,18 +9,22 @@ import { FunctionFlags } from '../../common/constants.js';
 
 export class ScalarFunctionCallNode extends PlanNode implements NaryScalarNode {
 	override readonly nodeType = PlanNodeType.ScalarFunctionCall;
+	private readonly _inferredType?: ScalarType;
 
 	constructor(
 		scope: Scope,
 		public readonly expression: AST.FunctionExpr,
 		public readonly functionSchema: FunctionSchema,
-		public readonly operands: ScalarPlanNode[]
+		public readonly operands: ScalarPlanNode[],
+		inferredType?: ScalarType
 	) {
 		super(scope);
+		this._inferredType = inferredType;
 	}
 
 	getType(): ScalarType {
-		return this.functionSchema.returnType as ScalarType;
+		// Use inferred type if available, otherwise use schema's return type
+		return this._inferredType ?? (this.functionSchema.returnType as ScalarType);
 	}
 
 	getChildren(): readonly ScalarPlanNode[] {
@@ -54,7 +58,8 @@ export class ScalarFunctionCallNode extends PlanNode implements NaryScalarNode {
 			this.scope,
 			this.expression,
 			this.functionSchema,
-			newChildren as ScalarPlanNode[]
+			newChildren as ScalarPlanNode[],
+			this._inferredType
 		);
 	}
 

package/src/planner/nodes/insert-node.ts

@@ -50,7 +50,7 @@ export class InsertNode extends PlanNode implements RelationalPlanNode {
           name: col.name,
           type: {
             typeClass: 'scalar',
-            affinity: col.affinity,
+            logicalType: col.logicalType,
             nullable: isOld ? true : !col.notNull, // OLD values can be null, NEW follows column constraints
             isReadOnly: false
           },