@quereus/quereus 0.1.0

package/src/func/builtins/schema.ts

@@ -0,0 +1,193 @@
+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";
+import type { Database } from "../../core/database.js";
+import type { FunctionSchema } from "../../schema/function.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', 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 }
+			],
+			keys: [],
+			rowConstraints: []
+		}
+	},
+	async function* (db: Database): AsyncIterable<Row> {
+		try {
+			const schemaManager = db.schemaManager;
+
+			const processSchemaInstance = function* (schemaInstance: any) {
+				// Process Tables
+				for (const tableSchema of schemaInstance.getAllTables()) {
+					let createSql: string | null = null;
+					try {
+						const columnsStr = tableSchema.columns.map((c: any) => `"${c.name}" ${c.affinity ?? SqlDataType.TEXT}`).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());
+
+		} 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', 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 }
+			],
+			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.affinity || SqlDataType.TEXT, // type
+					column.notNull ? 1 : 0,             // notnull
+					column.defaultValue?.toString() || null, // dflt_value
+					isPrimaryKey ? 1 : 0                // pk
+				];
+			}
+		} 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', 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 }
+			],
+			keys: [],
+			rowConstraints: []
+		}
+	},
+	async function* (db: Database): AsyncIterable<Row> {
+		try {
+			const schemaManager = db.schemaManager;
+
+			const processFunctions = function* (schemaInstance: any) {
+				for (const funcSchema of schemaInstance._getAllFunctions()) {
+					const isDeterministic = (funcSchema.flags & 0x800) !== 0; // FunctionFlags.DETERMINISTIC
+
+					yield [
+						funcSchema.name,                           // name
+						funcSchema.numArgs,                       // num_args
+						funcSchema.type,                          // 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());
+
+		} catch (error: any) {
+			// If function info fails, yield an error row
+			yield ['error', -1, 'error', 0, 0, `Failed to get function info: ${error.message}`];
+		}
+	}
+);

package/src/func/builtins/string.ts

@@ -0,0 +1,293 @@
+import { createAggregateFunction, createScalarFunction, createTableValuedFunction } from '../registration.js';
+import type { Row, SqlValue } from '../../common/types.js';
+import { createLogger } from '../../common/logger.js';
+import { simpleLike, simpleGlob } from '../../util/patterns.js';
+
+const log = createLogger('func:builtins:scalar');
+const warnLog = log.extend('warn');
+
+// --- length(X) ---
+export const lengthFunc = createScalarFunction(
+	{ name: 'length', numArgs: 1, deterministic: true },
+	(arg: SqlValue): SqlValue => {
+		if (arg === null) return null;
+		if (typeof arg === 'string') return arg.length;
+		if (arg instanceof Uint8Array) return arg.length;
+		return null; // Other types -> NULL
+	}
+);
+
+// --- 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);
+
+		if (isNaN(y) || (z !== undefined && isNaN(z))) return null;
+
+		// SQLite uses 1-based indexing, negative start counts from end
+		y = Math.trunc(y);
+		z = z === undefined ? undefined : Math.trunc(z);
+
+		const strLen = s.length;
+		let begin: number;
+
+		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;
+		}
+
+		return s.substring(begin, end);
+	}
+);
+
+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);
+
+		const strLen = s.length;
+		let begin: number;
+
+		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;
+		}
+
+		return s.substring(begin, end);
+	}
+);
+
+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;
+	}
+);
+
+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;
+	}
+);
+
+// --- trim(X, Y?) ---
+export const trimFunc = createScalarFunction(
+	{ name: 'trim', numArgs: -1, deterministic: true },
+	(strVal: SqlValue, charsVal?: SqlValue): SqlValue => {
+		if (strVal === null) return null;
+		const str = String(strVal);
+		if (charsVal === undefined || charsVal === null) {
+			return str.trim();
+		}
+		const chars = String(charsVal);
+		if (chars.length === 0) return str;
+
+		try {
+			const escapedChars = chars.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			const regex = new RegExp(`^[${escapedChars}]+|[${escapedChars}]+$`, 'g');
+			return str.replace(regex, '');
+		} catch (e) {
+			warnLog('Error creating trim regex for chars: %s, %O', chars, e);
+			return str.trim();
+		}
+	}
+);
+
+// --- ltrim(X, Y?) ---
+export const ltrimFunc = createScalarFunction(
+	{ name: 'ltrim', numArgs: -1, deterministic: true },
+	(strVal: SqlValue, charsVal?: SqlValue): SqlValue => {
+		if (strVal === null) return null;
+		const str = String(strVal);
+		if (charsVal === undefined || charsVal === null) {
+			return str.trimStart();
+		}
+		const chars = String(charsVal);
+		if (chars.length === 0) return str;
+
+		try {
+			const escapedChars = chars.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			const regex = new RegExp(`^[${escapedChars}]+`, 'g');
+			return str.replace(regex, '');
+		} catch (e) {
+			warnLog('Error creating ltrim regex for chars: %s, %O', chars, e);
+			return str.trimStart();
+		}
+	}
+);
+
+// --- rtrim(X, Y?) ---
+export const rtrimFunc = createScalarFunction(
+	{ name: 'rtrim', numArgs: -1, deterministic: true },
+	(strVal: SqlValue, charsVal?: SqlValue): SqlValue => {
+		if (strVal === null) return null;
+		const str = String(strVal);
+		if (charsVal === undefined || charsVal === null) {
+			return str.trimEnd();
+		}
+		const chars = String(charsVal);
+		if (chars.length === 0) return str;
+
+		try {
+			const escapedChars = chars.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			const regex = new RegExp(`[${escapedChars}]+$`, 'g');
+			return str.replace(regex, '');
+		} catch (e) {
+			warnLog('Error creating rtrim regex for chars: %s, %O', chars, e);
+			return str.trimEnd();
+		}
+	}
+);
+
+// --- replace(X, Y, Z) ---
+export const replaceFunc = createScalarFunction(
+	{ name: 'replace', numArgs: 3, deterministic: true },
+	(strVal: SqlValue, patternVal: SqlValue, replacementVal: SqlValue): SqlValue => {
+		if (strVal === null || patternVal === null || replacementVal === null) return null;
+
+		const str = String(strVal);
+		const pattern = String(patternVal);
+		const replacement = String(replacementVal);
+
+		if (pattern === '') return str;
+		return str.split(pattern).join(replacement);
+	}
+);
+
+// --- instr(X, Y) ---
+export const instrFunc = createScalarFunction(
+	{ name: 'instr', numArgs: 2, deterministic: true },
+	(strVal: SqlValue, subVal: SqlValue): SqlValue => {
+		if (strVal === null || subVal === null) return 0;
+
+		const str = String(strVal);
+		const sub = String(subVal);
+
+		if (sub.length === 0) return 0;
+		if (str.length === 0) return 0;
+
+		const index = str.indexOf(sub);
+		return index === -1 ? 0 : index + 1;
+	}
+);
+
+// String reverse function
+export const reverseFunc = createScalarFunction(
+	{ name: 'reverse', numArgs: 1, deterministic: true },
+	(str: SqlValue): SqlValue => {
+		if (typeof str !== 'string') return null;
+		return str.split('').reverse().join('');
+	}
+);
+
+// Left padding function
+export const lpadFunc = createScalarFunction(
+	{ name: 'lpad', numArgs: 3, deterministic: true },
+	(str: SqlValue, len: SqlValue, pad: SqlValue): SqlValue => {
+		if (typeof str !== 'string' || typeof len !== 'number' || typeof pad !== 'string') return null;
+
+		const strLen = str.length;
+		if (len <= strLen) return str;
+
+		const padStr = pad.repeat(len - strLen);
+		return padStr + str;
+	}
+);
+
+// Right padding function
+export const rpadFunc = createScalarFunction(
+	{ name: 'rpad', numArgs: 3, deterministic: true },
+	(str: SqlValue, len: SqlValue, pad: SqlValue): SqlValue => {
+		if (typeof str !== 'string' || typeof len !== 'number' || typeof pad !== 'string') return null;
+
+		const strLen = str.length;
+		if (len <= strLen) return str;
+
+		const padStr = pad.repeat(len - strLen);
+		return str + padStr;
+	}
+);
+
+// Split a string into rows (table-valued function)
+export const splitStringFunc = createTableValuedFunction(
+	{ name: 'split_string', numArgs: 2, deterministic: true },
+	async function* (str: SqlValue, delimiter: SqlValue): AsyncIterable<Row> {
+		if (typeof str !== 'string' || typeof delimiter !== 'string') return;
+
+		const parts = str.split(delimiter);
+		for (let i = 0; i < parts.length; i++) {
+			yield [parts[i], i]; // value, index
+		}
+	}
+);
+
+// String concatenation aggregate (like GROUP_CONCAT but simpler)
+export const stringConcatFunc = createAggregateFunction(
+	{ name: 'string_concat', numArgs: 1, initialValue: [] },
+	(acc: string[], value: SqlValue) => {
+		if (typeof value === 'string') {
+			acc.push(value);
+		}
+		return acc;
+	},
+	(acc: string[]) => acc.join(',')
+);
+
+// --- lower(X) ---
+export const lowerFunc = createScalarFunction(
+	{ name: 'lower', numArgs: 1, deterministic: true },
+	(arg: SqlValue): SqlValue => {
+		return typeof arg === 'string' ? arg.toLowerCase() : null;
+	}
+);
+
+// --- upper(X) ---
+export const upperFunc = createScalarFunction(
+	{ name: 'upper', numArgs: 1, deterministic: true },
+	(arg: SqlValue): SqlValue => {
+		return typeof arg === 'string' ? arg.toUpperCase() : null;
+	}
+);