@quereus/quereus 0.7.3 → 0.7.5

package/src/func/builtins/string.ts

@@ -1,306 +0,0 @@
-import { createAggregateFunction, createScalarFunction, createTableValuedFunction } from '../registration.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,
-		// 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;
-		if (arg instanceof Uint8Array) return arg.length;
-		return null; // Other types -> NULL
-	}
-);
-
-// --- substr(X, Y, Z?) --- Also SUBSTRING
-
-const substrImpl = (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);
-};
-
-const substrTypeInference = {
-	// Type inference: substr always returns TEXT
-	inferReturnType: (_argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ({
-		typeClass: 'scalar' as const,
-		logicalType: TEXT_TYPE,
-		nullable: false,
-		isReadOnly: true
-	})
-};
-
-export const substrFunc = createScalarFunction(
-	{ name: 'substr', numArgs: -1, deterministic: true, ...substrTypeInference },
-	substrImpl
-);
-
-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));
-	}
-);
-
-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));
-	}
-);
-
-// 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, ...textReturnTypeInference },
-	(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, ...textReturnTypeInference },
-	(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, ...textReturnTypeInference },
-	(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, ...textReturnTypeInference },
-	(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,
-		// 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;
-
-		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, ...textReturnTypeInference },
-	(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, ...textReturnTypeInference },
-	(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, ...textReturnTypeInference },
-	(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, ...textReturnTypeInference },
-	(arg: SqlValue): SqlValue => {
-		return typeof arg === 'string' ? arg.toLowerCase() : null;
-	}
-);
-
-// --- upper(X) ---
-export const upperFunc = createScalarFunction(
-	{ name: 'upper', numArgs: 1, deterministic: true, ...textReturnTypeInference },
-	(arg: SqlValue): SqlValue => {
-		return typeof arg === 'string' ? arg.toUpperCase() : null;
-	}
-);

package/src/func/builtins/timespan.ts

@@ -1,179 +0,0 @@
-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;
-		}
-	}
-);
-