@quereus/quereus 0.7.2 → 0.7.4

package/src/func/builtins/scalar.ts

@@ -1,423 +0,0 @@
-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,
-		// 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;
-		const num = Number(arg);
-		if (isNaN(num)) return null;
-		return Math.abs(num);
-	}
-);
-
-// --- round(X, Y?) ---
-export const roundFunc = createScalarFunction(
-	{
-		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);
-		if (isNaN(x)) return null;
-
-		let y = 0;
-		if (placesVal !== undefined && placesVal !== null) {
-			const numY = Number(placesVal);
-			if (isNaN(numY)) return null;
-			y = Math.trunc(numY);
-		}
-
-		try {
-			const factor = Math.pow(10, y);
-			return Math.round(x * factor) / factor;
-		} catch {
-			return null;
-		}
-	}
-);
-
-// --- coalesce(...) ---
-export const coalesceFunc = createScalarFunction(
-	{
-		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) {
-				return arg;
-			}
-		}
-		return null;
-	}
-);
-
-// --- nullif(X, Y) ---
-export const nullifFunc = createScalarFunction(
-	{
-		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;
-	}
-);
-
-// --- typeof(X) ---
-export const typeofFunc = createScalarFunction(
-	{ name: 'typeof', numArgs: 1, deterministic: true },
-	(arg: SqlValue): SqlValue => {
-		return getSqlDataTypeName(arg);
-	}
-);
-
-// --- random() ---
-export const randomFunc = createScalarFunction(
-	{ name: 'random', numArgs: 0, deterministic: false },
-	(): SqlValue => {
-		const randomInt = Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) + Number.MIN_SAFE_INTEGER;
-		return BigInt(randomInt);
-	}
-);
-
-// --- randomblob(N) ---
-export const randomblobFunc = createScalarFunction(
-	{ name: 'randomblob', numArgs: 1, deterministic: false },
-	(nVal: SqlValue): SqlValue => {
-		if (typeof nVal !== 'number' && typeof nVal !== 'bigint') return null;
-		const n = Number(nVal);
-		if (!Number.isInteger(n) || n <= 0) return new Uint8Array(0);
-		const byteLength = Math.min(n, 1024 * 1024); // Cap at 1MB
-
-		const buffer = new Uint8Array(byteLength);
-		for (let i = 0; i < byteLength; i++) {
-			buffer[i] = Math.floor(Math.random() * 256);
-		}
-		return buffer;
-	}
-);
-
-// --- iif(X, Y, Z) ---
-export const iifFunc = createScalarFunction(
-	{
-		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) {
-			isTrue = false;
-		} else if (typeof condition === 'number') {
-			isTrue = condition !== 0;
-		} else if (typeof condition === 'bigint') {
-			isTrue = condition !== 0n;
-		} else if (typeof condition === 'string') {
-			const num = Number(condition);
-			isTrue = !isNaN(num) && num !== 0;
-		} else {
-			isTrue = Boolean(condition);
-		}
-
-		return isTrue ? trueVal : falseVal;
-	}
-);
-
-// --- sqrt(X) ---
-export const sqrtFunc = createScalarFunction(
-	{
-		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);
-		if (isNaN(num) || num < 0) return null;
-		return Math.sqrt(num);
-	}
-);
-
-// --- pow(X, Y) / power(X, Y) ---
-
-const pow = (base: SqlValue, exponent: SqlValue): SqlValue => {
-	if (base === null || exponent === null) return null;
-	const numBase = Number(base);
-	const numExp = Number(exponent);
-	if (isNaN(numBase) || isNaN(numExp)) return null;
-	return Math.pow(numBase, numExp);
-};
-
-export const powFunc = createScalarFunction(
-	{ name: 'pow', numArgs: 2, deterministic: true },
-	pow
-);
-
-export const powerFunc = createScalarFunction(
-	{ name: 'power', numArgs: 2, deterministic: true },
-	pow
-);
-
-// --- floor(X) ---
-export const floorFunc = createScalarFunction(
-	{
-		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);
-		if (isNaN(num)) return null;
-		return Math.floor(num);
-	}
-);
-
-// --- ceil(X) / ceiling(X) ---
-
-const ceil = (arg: SqlValue): SqlValue => {
-	if (arg === null) return null;
-	const num = Number(arg);
-	if (isNaN(num)) return null;
-	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, ...ceilTypeInference },
-	ceil
-);
-
-export const ceilingFunc = createScalarFunction(
-	{ name: 'ceiling', numArgs: 1, deterministic: true, ...ceilTypeInference },
-	ceil
-);
-
-// Math clamp function
-export const clampFunc = createScalarFunction(
-	{
-		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);
-		const maxVal = Number(max);
-
-		if (isNaN(v) || isNaN(minVal) || isNaN(maxVal)) return null;
-		return Math.max(minVal, Math.min(maxVal, v));
-	}
-);
-
-// Greatest-of function
-export const greatestFunc = createScalarFunction(
-	{
-		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) => {
-			if (max === null || compareSqlValues(current, max) > 0) {
-				return current;
-			}
-			return max;
-		}, args[0]);
-	}
-);
-
-// Least-of function
-export const leastFunc = createScalarFunction(
-	{
-		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) => {
-			if (min === null || compareSqlValues(current, min) < 0) {
-				return current;
-			}
-			return min;
-		}, args[0]);
-	}
-);
-
-// Choose function
-export const chooseFunc = createScalarFunction(
-	{
-		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]);
-		if (isNaN(index) || index < 1 || index >= args.length) return null;
-		return args[index];
-	}
-);
-
-// Greatest-of function

package/src/func/builtins/schema.ts

@@ -1,213 +0,0 @@
-import type { Row } from "../../common/types.js";
-import type { SqlValue } from "../../common/types.js";
-import { createIntegratedTableValuedFunction } from "../registration.js";
-import { QuereusError } from "../../common/errors.js";
-import { StatusCode } from "../../common/types.js";
-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";
-
-/**
- * Generates a function signature string for display
- */
-function stringifyCreateFunction(func: FunctionSchema): string {
-	const argsString = func.numArgs === -1
-		? '...' // Indicate variable arguments
-		: Array(func.numArgs).fill('?').join(', ');
-	return `FUNCTION ${func.name}(${argsString})`;
-}
-
-// Schema introspection function (table-valued function)
-export const schemaFunc = createIntegratedTableValuedFunction(
-	{
-		name: 'schema',
-		numArgs: 0,
-		deterministic: false, // Schema can change
-		returnType: {
-			typeClass: 'relation',
-			isReadOnly: true,
-			isSet: false,
-			columns: [
-				{ 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: []
-		}
-	},
-	async function* (db: Database): AsyncIterable<Row> {
-		try {
-			const schemaManager = db.schemaManager;
-
-			const processSchemaInstance = function* (schemaInstance: Schema) {
-				// Process Tables
-				for (const tableSchema of schemaInstance.getAllTables()) {
-					let createSql: string | null = null;
-					try {
-						const columnsStr = tableSchema.columns.map((c: ColumnSchema) => `"${c.name}" ${c.logicalType.name}`).join(', ');
-						const argsStr = Object.entries(tableSchema.vtabArgs ?? {}).map(([key, value]) => `${key}=${value}`).join(', ');
-						createSql = `create table "${tableSchema.name}" (${columnsStr}) using ${tableSchema.vtabModuleName}(${argsStr})`;
-					} catch {
-						createSql = null;
-					}
-
-					yield [
-						tableSchema.isView ? 'view' : 'table',
-						tableSchema.name,
-						tableSchema.name,
-						createSql
-					] as Row;
-				}
-
-				// Process Functions
-				for (const funcSchema of schemaInstance._getAllFunctions()) {
-					yield [
-						'function',
-						funcSchema.name,
-						funcSchema.name,
-						stringifyCreateFunction(funcSchema)
-					] as Row;
-				}
-			};
-
-			// Process main schema
-			yield* processSchemaInstance(schemaManager.getMainSchema());
-
-			// Process temp schema
-			yield* processSchemaInstance(schemaManager.getTempSchema());
-
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		} catch (error: any) {
-			// If schema introspection fails, yield an error row
-			yield ['error', 'schema_error', 'schema_error', `Failed to introspect schema: ${error.message}`];
-		}
-	}
-);
-
-// Table information function (table-valued function)
-export const tableInfoFunc = createIntegratedTableValuedFunction(
-	{
-		name: 'table_info',
-		numArgs: 1,
-		deterministic: false, // Table structure can change
-		returnType: {
-			typeClass: 'relation',
-			isReadOnly: true,
-			isSet: false,
-			columns: [
-				{ 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: []
-		}
-	},
-	async function* (db: Database, tableName: SqlValue): AsyncIterable<Row> {
-		if (typeof tableName !== 'string') {
-			throw new QuereusError('table_info() requires a table name string argument', StatusCode.ERROR);
-		}
-
-		try {
-			const table = db._findTable(tableName);
-			if (!table) {
-				throw new QuereusError(`Table '${tableName}' not found`, StatusCode.ERROR);
-			}
-
-			for (let i = 0; i < table.columns.length; i++) {
-				const column = table.columns[i];
-				const isPrimaryKey = table.primaryKeyDefinition.some(pk => pk.index === i);
-
-				yield [
-					i,                                    // cid
-					column.name,                         // name
-					column.logicalType.name,             // type
-					column.notNull ? 1 : 0,             // notnull
-					column.defaultValue?.toString() || null, // dflt_value
-					isPrimaryKey ? 1 : 0                // pk
-				];
-			}
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		} catch (error: any) {
-			// If table info fails, yield an error row
-			yield [0, 'error', 'error', 1, `Failed to get table info: ${error.message}`, 0];
-		}
-	}
-);
-
-// Function information function (table-valued function)
-export const functionInfoFunc = createIntegratedTableValuedFunction(
-	{
-		name: 'function_info',
-		numArgs: 0,
-		deterministic: false, // Functions can change
-		returnType: {
-			typeClass: 'relation',
-			isReadOnly: true,
-			isSet: false,
-			columns: [
-				{ 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: []
-		}
-	},
-	async function* (db: Database): AsyncIterable<Row> {
-		try {
-			const schemaManager = db.schemaManager;
-
-			const processFunctions = function* (schemaInstance: Schema) {
-				for (const funcSchema of schemaInstance._getAllFunctions()) {
-					const isDeterministic = (funcSchema.flags & 0x800) !== 0; // FunctionFlags.DETERMINISTIC
-
-					// Determine function type based on schema type guards
-					let functionType: string;
-					if (isScalarFunctionSchema(funcSchema)) {
-						functionType = 'scalar';
-					} else if (isTableValuedFunctionSchema(funcSchema)) {
-						functionType = 'table';
-					} else if (isAggregateFunctionSchema(funcSchema)) {
-						functionType = 'aggregate';
-					} else if (isWindowFunctionSchema(funcSchema)) {
-						functionType = 'window';
-					} else {
-						functionType = 'unknown';
-					}
-
-					yield [
-						funcSchema.name,                           // name
-						funcSchema.numArgs,                       // num_args
-						functionType,                             // type
-						isDeterministic ? 1 : 0,                 // deterministic
-						funcSchema.flags,                         // flags
-						stringifyCreateFunction(funcSchema)       // signature
-					] as Row;
-				}
-			};
-
-			// Process main schema functions
-			yield* processFunctions(schemaManager.getMainSchema());
-
-			// Process temp schema functions
-			yield* processFunctions(schemaManager.getTempSchema());
-
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		} catch (error: any) {
-			// If function info fails, yield an error row
-			yield ['error', -1, 'error', 0, 0, `Failed to get function info: ${error.message}`];
-		}
-	}
-);