@quereus/quereus 0.7.2 → 0.7.4

package/src/func/builtins/aggregate.ts

@@ -1,269 +0,0 @@
-import { createLogger } from '../../common/logger.js';
-import type { SqlValue } from '../../common/types.js';
-import { createAggregateFunction } from '../registration.js';
-import { compareSqlValuesFast, BINARY_COLLATION } from '../../util/comparison.js';
-
-const log = createLogger('func:builtins:aggregate');
-const warnLog = log.extend('warn');
-
-// --- count(*) ---
-export const countStarFunc = createAggregateFunction(
-	{ name: 'count', numArgs: 0, initialValue: 0 },
-	(acc: number): number => acc + 1,
-	(acc: number): number => acc
-);
-
-// --- SUM(X) ---
-export const sumFunc = createAggregateFunction(
-	{ name: 'sum', numArgs: 1, initialValue: null },
-	(acc: { sum: number | bigint } | null, value: SqlValue): { sum: number | bigint } | null => {
-		if (value === null) return acc; // Ignore NULLs
-		const currentSum = acc?.sum ?? 0; // Initialize sum to 0 if null
-		let numValue: number | bigint;
-
-		try {
-			if (typeof value === 'bigint') {
-				numValue = value;
-			} else if (typeof value === 'number') {
-				numValue = value;
-			} else if (typeof value === 'string') {
-				const parsed = Number(value);
-				if (isNaN(parsed)) return acc;
-				numValue = parsed;
-			} else if (typeof value === 'boolean') {
-				numValue = value ? 1 : 0;
-			} else {
-				return acc; // Ignore non-numeric types like Uint8Array
-			}
-
-			// Promote to BigInt if either is BigInt or if result might overflow Number
-			if (typeof currentSum === 'bigint' || typeof numValue === 'bigint') {
-				return { sum: BigInt(currentSum) + BigInt(numValue) };
-			} else {
-				// Check potential overflow before adding as numbers
-				const potentialSum = (currentSum as number) + (numValue as number);
-				if (potentialSum > Number.MAX_SAFE_INTEGER || potentialSum < Number.MIN_SAFE_INTEGER) {
-					return { sum: BigInt(currentSum) + BigInt(numValue) };
-				}
-				return { sum: potentialSum };
-			}
-		} catch (e) {
-			warnLog("Error during SUM step coercion: %O", e);
-			return acc; // Ignore value if coercion fails
-		}
-	},
-	(acc: { sum: number | bigint } | null): number | bigint | null => {
-		// SQLite returns NULL for SUM of empty set, INTEGER or REAL result
-		return acc?.sum ?? null;
-	}
-);
-
-// --- AVG(X) ---
-interface AvgAccumulator { sum: number; count: number }
-export const avgFunc = createAggregateFunction(
-	{ name: 'avg', numArgs: 1, initialValue: { sum: 0, count: 0 } },
-	(acc: AvgAccumulator, value: SqlValue): AvgAccumulator => {
-		if (value === null) return acc; // Ignore NULLs
-		let numValue = value;
-		try {
-			if (typeof value !== 'bigint') {
-				numValue = Number(value);
-				if (isNaN(numValue as number)) return acc; // Ignore non-numeric
-			}
-
-			// Use floating point for sum in AVG to avoid potential BigInt division issues
-			const newSum = acc.sum + Number(numValue);
-			return { sum: newSum, count: acc.count + 1 };
-		} catch (e) {
-			warnLog("Error during AVG step coercion: %O", e);
-			return acc;
-		}
-	},
-	(acc: AvgAccumulator): number | null => {
-		if (acc.count === 0) return null; // NULL for empty set
-		return acc.sum / acc.count;
-	}
-);
-
-// --- MIN(X) ---
-export const minFunc = createAggregateFunction(
-	{
-		name: 'min',
-		numArgs: 1,
-		initialValue: null,
-		// Type inference: return the same type as the input argument
-		inferReturnType: (argTypes) => ({
-			typeClass: 'scalar',
-			logicalType: argTypes[0],
-			nullable: true, // MIN can return NULL if all values are NULL or no rows
-			isReadOnly: true
-		})
-	},
-	(acc: { min: SqlValue } | null, value: SqlValue): { min: SqlValue } | null => {
-		if (value === null) return acc; // Ignore NULLs
-		if (acc === null) return { min: value }; // First non-null value
-		return compareSqlValuesFast(value, acc.min, BINARY_COLLATION) < 0 ? { min: value } : acc;
-	},
-	(acc: { min: SqlValue } | null): SqlValue | null => {
-		return acc?.min ?? null;
-	}
-);
-
-// --- MAX(X) ---
-export const maxFunc = createAggregateFunction(
-	{
-		name: 'max',
-		numArgs: 1,
-		initialValue: null,
-		// Type inference: return the same type as the input argument
-		inferReturnType: (argTypes) => ({
-			typeClass: 'scalar',
-			logicalType: argTypes[0],
-			nullable: true, // MAX can return NULL if all values are NULL or no rows
-			isReadOnly: true
-		})
-	},
-	(acc: { max: SqlValue } | null, value: SqlValue): { max: SqlValue } | null => {
-		if (value === null) return acc; // Ignore NULLs
-		if (acc === null) return { max: value }; // First non-null value
-		return compareSqlValuesFast(value, acc.max, BINARY_COLLATION) > 0 ? { max: value } : acc;
-	},
-	(acc: { max: SqlValue } | null): SqlValue | null => {
-		return acc?.max ?? null;
-	}
-);
-
-// --- COUNT(X) ---
-// Counts non-NULL values of X
-export const countXFunc = createAggregateFunction(
-	{ name: 'count', numArgs: 1, initialValue: 0 },
-	(acc: number, value: SqlValue): number => {
-		if (value === null) return acc; // Do not count NULLs
-		return acc + 1;
-	},
-	(acc: number): number => acc
-);
-
-// --- GROUP_CONCAT(X, Y?) ---
-interface GroupConcatAccumulator {
-	values: string[];
-	separator: string;
-}
-export const groupConcatFuncRev = createAggregateFunction(
-	{ name: 'group_concat', numArgs: -1, initialValue: { values: [], separator: ',' } },
-	(acc: GroupConcatAccumulator, value: SqlValue, separator: SqlValue = ','): GroupConcatAccumulator => {
-		const currentSeparator = (separator === undefined || separator === null) ? acc.separator : String(separator);
-
-		if (value === null) {
-			// Update separator even if value is NULL
-			return { ...acc, separator: currentSeparator };
-		}
-
-		const strValue = String(value);
-		// Create a new array instead of mutating the existing one
-		return { values: [...acc.values, strValue], separator: currentSeparator };
-	},
-	(acc: GroupConcatAccumulator): string | null => {
-		if (acc.values.length === 0) {
-			return null;
-		}
-		return acc.values.join(acc.separator);
-	}
-);
-
-// --- TOTAL(X) ---
-export const totalFunc = createAggregateFunction(
-	{ name: 'total', numArgs: 1, initialValue: 0.0 },
-	(acc: number, value: SqlValue): number => {
-		let numValue = 0.0;
-		if (value !== null) {
-			try {
-				// Attempt numeric conversion, default to 0.0 if not possible
-				numValue = Number(value);
-				if (isNaN(numValue)) {
-					numValue = 0.0;
-				}
-			} catch {
-				numValue = 0.0;
-			}
-		}
-		// Always use floating-point arithmetic
-		return acc + numValue;
-	},
-	(acc: number): number => acc // Returns 0.0 for empty set or only NULL inputs
-);
-
-// --- Statistical Aggregates (Variance, Standard Deviation) ---
-interface StatAccumulator {
-	count: number;
-	sum: number;
-	sumSq: number;
-}
-
-const statReducer = (acc: StatAccumulator, value: SqlValue): StatAccumulator => {
-	if (value === null) {
-		return acc; // Ignore NULLs
-	}
-	try {
-		const numValue = Number(value);
-		if (isNaN(numValue)) {
-			return acc; // Ignore non-numeric
-		}
-		// Use floating-point for calculations
-		return {
-			count: acc.count + 1,
-			sum: acc.sum + numValue,
-			sumSq: acc.sumSq + (numValue * numValue),
-		};
-	} catch (e) {
-		warnLog("Error during statistical aggregate step coercion: %O", e);
-		return acc;
-	}
-};
-
-// Population Variance (VAR_POP)
-export const varPopFunc = createAggregateFunction(
-	{ name: 'var_pop', numArgs: 1, initialValue: { count: 0, sum: 0, sumSq: 0 } },
-	statReducer,
-	(acc: StatAccumulator): number | null => {
-		if (acc.count === 0) return null; // NULL for empty set
-		const avg = acc.sum / acc.count;
-		const variance = (acc.sumSq / acc.count) - (avg * avg);
-		return variance;
-	}
-);
-
-// Sample Variance (VAR_SAMP)
-export const varSampFunc = createAggregateFunction(
-	{ name: 'var_samp', numArgs: 1, initialValue: { count: 0, sum: 0, sumSq: 0 } },
-	statReducer,
-	(acc: StatAccumulator): number | null => {
-		if (acc.count <= 1) return null; // NULL if count is 0 or 1
-		// Sample variance: (sumSq - n*avg^2) / (n-1) == (sumSq - sum*sum/n) / (n-1)
-		const variance = (acc.sumSq - (acc.sum * acc.sum) / acc.count) / (acc.count - 1);
-		return variance;
-	}
-);
-
-// Population Standard Deviation (STDDEV_POP)
-export const stdDevPopFunc = createAggregateFunction(
-	{ name: 'stddev_pop', numArgs: 1, initialValue: { count: 0, sum: 0, sumSq: 0 } },
-	statReducer,
-	(acc: StatAccumulator): number | null => {
-		if (acc.count === 0) return null;
-		const avg = acc.sum / acc.count;
-		const variance = (acc.sumSq / acc.count) - (avg * avg);
-		return variance < 0 ? null : Math.sqrt(variance);
-	}
-);
-
-// Sample Standard Deviation (STDDEV_SAMP)
-export const stdDevSampFunc = createAggregateFunction(
-	{ name: 'stddev_samp', numArgs: 1, initialValue: { count: 0, sum: 0, sumSq: 0 } },
-	statReducer,
-	(acc: StatAccumulator): number | null => {
-		if (acc.count <= 1) return null;
-		const variance = (acc.sumSq - (acc.sum * acc.sum) / acc.count) / (acc.count - 1);
-		return variance < 0 ? null : Math.sqrt(variance);
-	}
-);

package/src/func/builtins/builtin-window-functions.ts

@@ -1,166 +0,0 @@
-import { registerWindowFunction } from '../../schema/window-function.js';
-import { AggValue } from '../registration.js';
-import { INTEGER_TYPE, REAL_TYPE } from '../../types/builtin-types.js';
-
-// Built-in window function schemas
-export function registerBuiltinWindowFunctions(): void {
-	// Ranking functions
-	registerWindowFunction({
-		name: 'ROW_NUMBER',
-		argCount: 0,
-		returnType: {
-			typeClass: 'scalar',
-			logicalType: INTEGER_TYPE,
-			nullable: false,
-			isReadOnly: true
-		},
-		requiresOrderBy: true,
-		kind: 'ranking'
-	});
-
-	registerWindowFunction({
-		name: 'RANK',
-		argCount: 0,
-		returnType: {
-			typeClass: 'scalar',
-			logicalType: INTEGER_TYPE,
-			nullable: false,
-			isReadOnly: true
-		},
-		requiresOrderBy: true,
-		kind: 'ranking'
-	});
-
-	registerWindowFunction({
-		name: 'DENSE_RANK',
-		argCount: 0,
-		returnType: {
-			typeClass: 'scalar',
-			logicalType: INTEGER_TYPE,
-			nullable: false,
-			isReadOnly: true
-		},
-		requiresOrderBy: true,
-		kind: 'ranking'
-	});
-
-	registerWindowFunction({
-		name: 'NTILE',
-		argCount: 1,
-		returnType: {
-			typeClass: 'scalar',
-			logicalType: INTEGER_TYPE,
-			nullable: false,
-			isReadOnly: true
-		},
-		requiresOrderBy: true,
-		kind: 'ranking'
-	});
-
-	// Aggregate functions as window functions
-	registerWindowFunction({
-		name: 'COUNT',
-		argCount: 1,
-		returnType: {
-			typeClass: 'scalar',
-			logicalType: INTEGER_TYPE,
-			nullable: false,
-			isReadOnly: true
-		},
-		requiresOrderBy: false,
-		kind: 'aggregate',
-		step: (state: AggValue, value: AggValue) => {
-			if (state === null || state === undefined) {
-				state = 0;
-			}
-			return value !== null ? state + 1 : state;
-		},
-		final: (state: AggValue) => state || 0
-	});
-
-	registerWindowFunction({
-		name: 'SUM',
-		argCount: 1,
-		returnType: {
-			typeClass: 'scalar',
-			logicalType: REAL_TYPE,
-			nullable: true,
-			isReadOnly: true
-		},
-		requiresOrderBy: false,
-		kind: 'aggregate',
-		step: (state: AggValue, value: AggValue) => {
-			if (value === null) return state;
-			if (state === null || state === undefined) {
-				return Number(value);
-			}
-			return state + Number(value);
-		},
-		final: (state: AggValue) => state
-	});
-
-	registerWindowFunction({
-		name: 'AVG',
-		argCount: 1,
-		returnType: {
-			typeClass: 'scalar',
-			logicalType: REAL_TYPE,
-			nullable: true,
-			isReadOnly: true
-		},
-		requiresOrderBy: false,
-		kind: 'aggregate',
-		step: (state: AggValue, value: AggValue) => {
-			if (value === null) return state;
-			if (!state) {
-				state = { sum: 0, count: 0 };
-			}
-			state.sum += Number(value);
-			state.count += 1;
-			return state;
-		},
-		final: (state: AggValue) => state ? state.sum / state.count : null
-	});
-
-	registerWindowFunction({
-		name: 'MIN',
-		argCount: 1,
-		returnType: {
-			typeClass: 'scalar',
-			logicalType: REAL_TYPE,
-			nullable: true,
-			isReadOnly: true
-		},
-		requiresOrderBy: false,
-		kind: 'aggregate',
-		step: (state: AggValue, value: AggValue) => {
-			if (value === null) return state;
-			if (state === null || state === undefined) {
-				return value;
-			}
-			return value < state ? value : state;
-		},
-		final: (state: AggValue) => state
-	});
-
-	registerWindowFunction({
-		name: 'MAX',
-		argCount: 1,
-		returnType: {
-			typeClass: 'scalar',
-			logicalType: REAL_TYPE,
-			nullable: true,
-			isReadOnly: true
-		},
-		requiresOrderBy: false,
-		kind: 'aggregate',
-		step: (state: AggValue, value: AggValue) => {
-			if (value === null) return state;
-			if (state === null || state === undefined) {
-				return value;
-			}
-			return value > state ? value : state;
-		},
-		final: (state: AggValue) => state
-	});
-}

package/src/func/builtins/conversion.ts

@@ -1,226 +0,0 @@
-import type { SqlValue } from '../../common/types.js';
-import { createScalarFunction } from '../registration.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { INTEGER_TYPE, REAL_TYPE, TEXT_TYPE, BOOLEAN_TYPE } from '../../types/builtin-types.js';
-import { DATE_TYPE, TIME_TYPE, DATETIME_TYPE, TIMESPAN_TYPE } from '../../types/temporal-types.js';
-import { JSON_TYPE } from '../../types/json-type.js';
-
-/**
- * integer() - Convert value to INTEGER
- * Usage: integer(value)
- */
-export const INTEGER_FUNC = createScalarFunction(
-	{ name: 'integer', numArgs: 1, deterministic: true },
-	(value: SqlValue): SqlValue => {
-		if (value === null) return null;
-
-		try {
-			return INTEGER_TYPE.parse!(value);
-		} catch (e) {
-			throw new QuereusError(
-				`Cannot convert to INTEGER: ${e instanceof Error ? e.message : String(e)}`,
-				StatusCode.MISMATCH
-			);
-		}
-	}
-);
-
-/**
- * real() - Convert value to REAL
- * Usage: real(value)
- */
-export const REAL_FUNC = createScalarFunction(
-	{ name: 'real', numArgs: 1, deterministic: true },
-	(value: SqlValue): SqlValue => {
-		if (value === null) return null;
-
-		try {
-			return REAL_TYPE.parse!(value);
-		} catch (e) {
-			throw new QuereusError(
-				`Cannot convert to REAL: ${e instanceof Error ? e.message : String(e)}`,
-				StatusCode.MISMATCH
-			);
-		}
-	}
-);
-
-/**
- * text() - Convert value to TEXT
- * Usage: text(value)
- */
-export const TEXT_FUNC = createScalarFunction(
-	{ name: 'text', numArgs: 1, deterministic: true },
-	(value: SqlValue): SqlValue => {
-		if (value === null) return null;
-
-		try {
-			return TEXT_TYPE.parse!(value);
-		} catch (e) {
-			throw new QuereusError(
-				`Cannot convert to TEXT: ${e instanceof Error ? e.message : String(e)}`,
-				StatusCode.MISMATCH
-			);
-		}
-	}
-);
-
-/**
- * boolean() - Convert value to BOOLEAN
- * Usage: boolean(value)
- */
-export const BOOLEAN_FUNC = createScalarFunction(
-	{ name: 'boolean', numArgs: 1, deterministic: true },
-	(value: SqlValue): SqlValue => {
-		if (value === null) return null;
-
-		try {
-			return BOOLEAN_TYPE.parse!(value);
-		} catch (e) {
-			throw new QuereusError(
-				`Cannot convert to BOOLEAN: ${e instanceof Error ? e.message : String(e)}`,
-				StatusCode.MISMATCH
-			);
-		}
-	}
-);
-
-/**
- * date() - Convert value to DATE
- * Usage: date(value)
- *
- * Note: This replaces the existing date() function in datetime.ts
- * The old date() function will be renamed to date_now() or similar
- */
-export const DATE_FUNC = createScalarFunction(
-	{ name: 'date', numArgs: 1, deterministic: false }, // 'now' is non-deterministic
-	(value: SqlValue): SqlValue => {
-		if (value === null) return null;
-
-		// Special case: 'now' returns current date
-		if (value === 'now') {
-			const now = new Date();
-			const year = now.getUTCFullYear();
-			const month = String(now.getUTCMonth() + 1).padStart(2, '0');
-			const day = String(now.getUTCDate()).padStart(2, '0');
-			return `${year}-${month}-${day}`;
-		}
-
-		try {
-			return DATE_TYPE.parse!(value);
-		} catch (e) {
-			throw new QuereusError(
-				`Cannot convert to DATE: ${e instanceof Error ? e.message : String(e)}`,
-				StatusCode.MISMATCH
-			);
-		}
-	}
-);
-
-/**
- * time() - Convert value to TIME
- * Usage: time(value)
- *
- * Note: This replaces the existing time() function in datetime.ts
- */
-export const TIME_FUNC = createScalarFunction(
-	{ name: 'time', numArgs: 1, deterministic: false }, // 'now' is non-deterministic
-	(value: SqlValue): SqlValue => {
-		if (value === null) return null;
-
-		// Special case: 'now' returns current time
-		if (value === 'now') {
-			const now = new Date();
-			const hours = String(now.getUTCHours()).padStart(2, '0');
-			const minutes = String(now.getUTCMinutes()).padStart(2, '0');
-			const seconds = String(now.getUTCSeconds()).padStart(2, '0');
-			return `${hours}:${minutes}:${seconds}`;
-		}
-
-		try {
-			return TIME_TYPE.parse!(value);
-		} catch (e) {
-			throw new QuereusError(
-				`Cannot convert to TIME: ${e instanceof Error ? e.message : String(e)}`,
-				StatusCode.MISMATCH
-			);
-		}
-	}
-);
-
-/**
- * datetime() - Convert value to DATETIME
- * Usage: datetime(value)
- *
- * Note: This replaces the existing datetime() function in datetime.ts
- */
-export const DATETIME_FUNC = createScalarFunction(
-	{ name: 'datetime', numArgs: 1, deterministic: false }, // 'now' is non-deterministic
-	(value: SqlValue): SqlValue => {
-		if (value === null) return null;
-
-		// Special case: 'now' returns current datetime
-		if (value === 'now') {
-			return new Date().toISOString();
-		}
-
-		try {
-			return DATETIME_TYPE.parse!(value);
-		} catch (e) {
-			throw new QuereusError(
-				`Cannot convert to DATETIME: ${e instanceof Error ? e.message : String(e)}`,
-				StatusCode.MISMATCH
-			);
-		}
-	}
-);
-
-/**
- * json() - Convert value to JSON
- * Usage: json(value)
- *
- * Converts a value to a JSON string. If the value is already a valid JSON string,
- * it normalizes it. Otherwise, it converts the value to JSON representation.
- */
-export const JSON_FUNC = createScalarFunction(
-	{ name: 'json', numArgs: 1, deterministic: true },
-	(value: SqlValue): SqlValue => {
-		if (value === null) return 'null';
-
-		try {
-			return JSON_TYPE.parse!(value);
-		} catch (e) {
-			throw new QuereusError(
-				`Cannot convert to JSON: ${e instanceof Error ? e.message : String(e)}`,
-				StatusCode.MISMATCH
-			);
-		}
-	}
-);
-
-/**
- * timespan() - Convert value to TIMESPAN
- * Usage: timespan(value)
- *
- * Accepts:
- * - ISO 8601 duration strings: 'PT1H30M', 'P1D', 'P1Y2M3D'
- * - Human-readable strings: '1 hour', '30 minutes', '2 days 3 hours'
- * - Numeric values (interpreted as seconds): 3600, 86400
- */
-export const TIMESPAN_FUNC = createScalarFunction(
-	{ name: 'timespan', numArgs: 1, deterministic: true },
-	(value: SqlValue): SqlValue => {
-		if (value === null) return null;
-
-		try {
-			return TIMESPAN_TYPE.parse!(value);
-		} catch (e) {
-			throw new QuereusError(
-				`Cannot convert to TIMESPAN: ${e instanceof Error ? e.message : String(e)}`,
-				StatusCode.MISMATCH
-			);
-		}
-	}
-);
-