@quereus/quereus 0.5.2 → 0.6.1

package/src/func/builtins/scalar.ts

@@ -1,10 +1,64 @@
-import type { SqlValue } from '../../common/types.js';
+import type { SqlValue, DeepReadonly } from '../../common/types.js';
 import { createScalarFunction } from '../registration.js';
 import { compareSqlValues, getSqlDataTypeName } from '../../util/comparison.js';
+import type { LogicalType } from '../../types/logical-type.js';
+import { ANY_TYPE, INTEGER_TYPE, REAL_TYPE } from '../../types/builtin-types.js';
+
+/**
+ * Find the common type among multiple logical types.
+ * This implements type promotion rules for polymorphic functions.
+ *
+ * Rules:
+ * 1. If all types are the same, return that type
+ * 2. If mixing INTEGER and REAL, return REAL (numeric promotion)
+ * 3. Otherwise, return the first type (conservative approach)
+ *
+ * @param types Array of logical types to find common type for
+ * @returns The common logical type
+ */
+function findCommonType(types: ReadonlyArray<DeepReadonly<LogicalType>>): DeepReadonly<LogicalType> {
+	if (types.length === 0) return ANY_TYPE;
+	if (types.length === 1) return types[0];
+
+	// Check if all types are the same
+	const firstType = types[0];
+	const allSame = types.every(t => t.name === firstType.name);
+	if (allSame) return firstType;
+
+	// Check for numeric type promotion (INTEGER + REAL -> REAL)
+	const allNumeric = types.every(t => t.isNumeric === true);
+	if (allNumeric) {
+		// If any type is REAL, return REAL
+		const hasReal = types.some(t => t.name === 'REAL');
+		if (hasReal) return REAL_TYPE;
+		// All INTEGER
+		return INTEGER_TYPE;
+	}
+
+	// For non-numeric types, return the first type (conservative)
+	// In a more sophisticated implementation, we could:
+	// - Find a common supertype
+	// - Return ANY_TYPE if types are incompatible
+	// - Throw an error for incompatible types
+	return firstType;
+}
 
 // --- abs(X) ---
 export const absFunc = createScalarFunction(
-	{ name: 'abs', numArgs: 1, deterministic: true },
+	{
+		name: 'abs',
+		numArgs: 1,
+		deterministic: true,
+		// Type inference: return the same type as the input for numeric types
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: argTypes[0],
+			nullable: false,
+			isReadOnly: true
+		}),
+		// Validate that the argument is numeric
+		validateArgTypes: (argTypes) => argTypes[0].isNumeric === true
+	},
 	(arg: SqlValue): SqlValue => {
 		if (arg === null) return null;
 		if (typeof arg === 'bigint') return arg < 0n ? -arg : arg;
@@ -16,7 +70,19 @@ export const absFunc = createScalarFunction(
 
 // --- round(X, Y?) ---
 export const roundFunc = createScalarFunction(
-	{ name: 'round', numArgs: -1, deterministic: true },
+	{
+		name: 'round',
+		numArgs: -1,
+		deterministic: true,
+		// Type inference: return the same type as the input for numeric types
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: argTypes[0],
+			nullable: false,
+			isReadOnly: true
+		}),
+		validateArgTypes: (argTypes) => argTypes[0].isNumeric === true
+	},
 	(numVal: SqlValue, placesVal?: SqlValue): SqlValue => {
 		if (numVal === null) return null;
 		const x = Number(numVal);
@@ -40,7 +106,18 @@ export const roundFunc = createScalarFunction(
 
 // --- coalesce(...) ---
 export const coalesceFunc = createScalarFunction(
-	{ name: 'coalesce', numArgs: -1, deterministic: true },
+	{
+		name: 'coalesce',
+		numArgs: -1,
+		deterministic: true,
+		// Type inference: find the common type among all arguments
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: findCommonType(argTypes),
+			nullable: true, // coalesce can return null if all args are null
+			isReadOnly: true
+		})
+	},
 	(...args: SqlValue[]): SqlValue => {
 		for (const arg of args) {
 			if (arg !== null) {
@@ -53,7 +130,18 @@ export const coalesceFunc = createScalarFunction(
 
 // --- nullif(X, Y) ---
 export const nullifFunc = createScalarFunction(
-	{ name: 'nullif', numArgs: 2, deterministic: true },
+	{
+		name: 'nullif',
+		numArgs: 2,
+		deterministic: true,
+		// Type inference: return the type of the first argument (nullable)
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: argTypes[0],
+			nullable: true, // nullif can always return null
+			isReadOnly: true
+		})
+	},
 	(argX: SqlValue, argY: SqlValue): SqlValue => {
 		const comparison = compareSqlValues(argX, argY);
 		return comparison === 0 ? null : argX;
@@ -96,7 +184,18 @@ export const randomblobFunc = createScalarFunction(
 
 // --- iif(X, Y, Z) ---
 export const iifFunc = createScalarFunction(
-	{ name: 'iif', numArgs: 3, deterministic: true },
+	{
+		name: 'iif',
+		numArgs: 3,
+		deterministic: true,
+		// Type inference: find the common type between the true and false values
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: findCommonType([argTypes[1], argTypes[2]]), // Common type of Y and Z
+			nullable: true, // Could return either Y or Z, so nullable if either is
+			isReadOnly: true
+		})
+	},
 	(condition: SqlValue, trueVal: SqlValue, falseVal: SqlValue): SqlValue => {
 		let isTrue: boolean;
 		if (condition === null) {
@@ -118,7 +217,19 @@ export const iifFunc = createScalarFunction(
 
 // --- sqrt(X) ---
 export const sqrtFunc = createScalarFunction(
-	{ name: 'sqrt', numArgs: 1, deterministic: true },
+	{
+		name: 'sqrt',
+		numArgs: 1,
+		deterministic: true,
+		// Type inference: sqrt always returns REAL (even for INTEGER input)
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: argTypes[0].name === 'INTEGER' ? argTypes[0] : argTypes[0], // Keep input type
+			nullable: false,
+			isReadOnly: true
+		}),
+		validateArgTypes: (argTypes) => argTypes[0].isNumeric === true
+	},
 	(arg: SqlValue): SqlValue => {
 		if (arg === null) return null;
 		const num = Number(arg);
@@ -149,7 +260,19 @@ export const powerFunc = createScalarFunction(
 
 // --- floor(X) ---
 export const floorFunc = createScalarFunction(
-	{ name: 'floor', numArgs: 1, deterministic: true },
+	{
+		name: 'floor',
+		numArgs: 1,
+		deterministic: true,
+		// Type inference: preserve input type
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: argTypes[0],
+			nullable: false,
+			isReadOnly: true
+		}),
+		validateArgTypes: (argTypes) => argTypes[0].isNumeric === true
+	},
 	(arg: SqlValue): SqlValue => {
 		if (arg === null) return null;
 		const num = Number(arg);
@@ -167,19 +290,41 @@ const ceil = (arg: SqlValue): SqlValue => {
 	return Math.ceil(num);
 };
 
+const ceilTypeInference = {
+	inferReturnType: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ({
+		typeClass: 'scalar' as const,
+		logicalType: argTypes[0],
+		nullable: false,
+		isReadOnly: true
+	}),
+	validateArgTypes: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => argTypes[0].isNumeric === true
+};
+
 export const ceilFunc = createScalarFunction(
-	{ name: 'ceil', numArgs: 1, deterministic: true },
+	{ name: 'ceil', numArgs: 1, deterministic: true, ...ceilTypeInference },
 	ceil
 );
 
 export const ceilingFunc = createScalarFunction(
-	{ name: 'ceiling', numArgs: 1, deterministic: true },
+	{ name: 'ceiling', numArgs: 1, deterministic: true, ...ceilTypeInference },
 	ceil
 );
 
 // Math clamp function
 export const clampFunc = createScalarFunction(
-	{ name: 'clamp', numArgs: 3, deterministic: true },
+	{
+		name: 'clamp',
+		numArgs: 3,
+		deterministic: true,
+		// Type inference: return the type of the first argument (value)
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: argTypes[0],
+			nullable: true,
+			isReadOnly: true
+		}),
+		validateArgTypes: (argTypes) => argTypes[0].isNumeric === true && argTypes[1].isNumeric === true && argTypes[2].isNumeric === true
+	},
 	(value: SqlValue, min: SqlValue, max: SqlValue): SqlValue => {
 		const v = Number(value);
 		const minVal = Number(min);
@@ -192,7 +337,18 @@ export const clampFunc = createScalarFunction(
 
 // Greatest-of function
 export const greatestFunc = createScalarFunction(
-	{ name: 'greatest', numArgs: -1, deterministic: true },
+	{
+		name: 'greatest',
+		numArgs: -1,
+		deterministic: true,
+		// Type inference: find the common type among all arguments
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: findCommonType(argTypes),
+			nullable: true,
+			isReadOnly: true
+		})
+	},
 	(...args: SqlValue[]): SqlValue => {
 		if (args.length === 0) return null;
 		return args.reduce((max, current) => {
@@ -206,7 +362,18 @@ export const greatestFunc = createScalarFunction(
 
 // Least-of function
 export const leastFunc = createScalarFunction(
-	{ name: 'least', numArgs: -1, deterministic: true },
+	{
+		name: 'least',
+		numArgs: -1,
+		deterministic: true,
+		// Type inference: find the common type among all arguments
+		inferReturnType: (argTypes) => ({
+			typeClass: 'scalar',
+			logicalType: findCommonType(argTypes),
+			nullable: true,
+			isReadOnly: true
+		})
+	},
 	(...args: SqlValue[]): SqlValue => {
 		if (args.length === 0) return null;
 		return args.reduce((min, current) => {
@@ -220,7 +387,31 @@ export const leastFunc = createScalarFunction(
 
 // Choose function
 export const chooseFunc = createScalarFunction(
-	{ name: 'choose', numArgs: -1, deterministic: true },
+	{
+		name: 'choose',
+		numArgs: -1,
+		deterministic: true,
+		// Type inference: find the common type among all value arguments (skip index at position 0)
+		inferReturnType: (argTypes) => {
+			if (argTypes.length < 2) {
+				// Need at least index and one value
+				return {
+					typeClass: 'scalar',
+					logicalType: argTypes[0] || ANY_TYPE,
+					nullable: true,
+					isReadOnly: true
+				};
+			}
+			// Find common type among all value arguments (skip the index at position 0)
+			const valueTypes = argTypes.slice(1);
+			return {
+				typeClass: 'scalar',
+				logicalType: findCommonType(valueTypes),
+				nullable: true,
+				isReadOnly: true
+			};
+		}
+	},
 	(...args: SqlValue[]): SqlValue => {
 		if (args.length === 0) return null;
 		const index = Number(args[0]);

package/src/func/builtins/schema.ts

@@ -1,6 +1,5 @@
 import type { Row } from "../../common/types.js";
 import type { SqlValue } from "../../common/types.js";
-import { SqlDataType } from "../../common/types.js";
 import { createIntegratedTableValuedFunction } from "../registration.js";
 import { QuereusError } from "../../common/errors.js";
 import { StatusCode } from "../../common/types.js";
@@ -8,6 +7,7 @@ import type { Database } from "../../core/database.js";
 import type { FunctionSchema } from "../../schema/function.js";
 import { isScalarFunctionSchema, isTableValuedFunctionSchema, isAggregateFunctionSchema, isWindowFunctionSchema } from "../../schema/function.js";
 import { Schema } from "../../schema/schema.js";
+import { INTEGER_TYPE, TEXT_TYPE } from "../../types/builtin-types.js";
 import { ColumnSchema } from "../../schema/column.js";
 
 /**
@@ -31,10 +31,10 @@ export const schemaFunc = createIntegratedTableValuedFunction(
 			isReadOnly: true,
 			isSet: false,
 			columns: [
-				{ name: 'type', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'name', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'tbl_name', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'sql', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: true, isReadOnly: true }, generated: true }
+				{ name: 'type', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'name', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'tbl_name', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'sql', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: true, isReadOnly: true }, generated: true }
 			],
 			keys: [],
 			rowConstraints: []
@@ -100,12 +100,12 @@ export const tableInfoFunc = createIntegratedTableValuedFunction(
 			isReadOnly: true,
 			isSet: false,
 			columns: [
-				{ name: 'cid', type: { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'name', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'type', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'notnull', type: { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'dflt_value', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: true, isReadOnly: true }, generated: true },
-				{ name: 'pk', type: { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false, isReadOnly: true }, generated: true }
+				{ name: 'cid', type: { typeClass: 'scalar', logicalType: INTEGER_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'name', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'type', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'notnull', type: { typeClass: 'scalar', logicalType: INTEGER_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'dflt_value', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: true, isReadOnly: true }, generated: true },
+				{ name: 'pk', type: { typeClass: 'scalar', logicalType: INTEGER_TYPE, nullable: false, isReadOnly: true }, generated: true }
 			],
 			keys: [],
 			rowConstraints: []
@@ -129,7 +129,7 @@ export const tableInfoFunc = createIntegratedTableValuedFunction(
 				yield [
 					i,                                    // cid
 					column.name,                         // name
-					column.affinity || SqlDataType.TEXT, // type
+					column.logicalType.name,             // type
 					column.notNull ? 1 : 0,             // notnull
 					column.defaultValue?.toString() || null, // dflt_value
 					isPrimaryKey ? 1 : 0                // pk
@@ -154,12 +154,12 @@ export const functionInfoFunc = createIntegratedTableValuedFunction(
 			isReadOnly: true,
 			isSet: false,
 			columns: [
-				{ name: 'name', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'num_args', type: { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'type', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'deterministic', type: { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'flags', type: { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false, isReadOnly: true }, generated: true },
-				{ name: 'signature', type: { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: false, isReadOnly: true }, generated: true }
+				{ name: 'name', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'num_args', type: { typeClass: 'scalar', logicalType: INTEGER_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'type', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'deterministic', type: { typeClass: 'scalar', logicalType: INTEGER_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'flags', type: { typeClass: 'scalar', logicalType: INTEGER_TYPE, nullable: false, isReadOnly: true }, generated: true },
+				{ name: 'signature', type: { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: false, isReadOnly: true }, generated: true }
 			],
 			keys: [],
 			rowConstraints: []

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,90 +31,69 @@ 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(
 	{ name: 'like', numArgs: 2, deterministic: true },
 	(pattern: SqlValue, text: SqlValue): SqlValue => {
 		if (text === null || pattern === null) return null;
-		return simpleLike(String(pattern), String(text)) ? 1 : 0;
+		return simpleLike(String(pattern), String(text));
 	}
 );
 
@@ -109,13 +101,23 @@ export const globFunc = createScalarFunction(
 	{ name: 'glob', numArgs: 2, deterministic: true },
 	(pattern: SqlValue, text: SqlValue): SqlValue => {
 		if (text === null || pattern === null) return null;
-		return simpleGlob(String(pattern), String(text)) ? 1 : 0;
+		return simpleGlob(String(pattern), String(text));
 	}
 );
 
+// 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;
 	}