@quereus/quereus 0.5.2 → 0.6.0

package/src/schema/catalog.ts

@@ -101,7 +101,7 @@ function tableSchemaToCatalog(tableSchema: TableSchema): CatalogTable {
 
 	const columns = tableSchema.columns.map(col => ({
 		name: col.name,
-		type: col.affinity?.toString() || 'TEXT',
+		type: col.logicalType.name,
 		notNull: col.notNull,
 		primaryKey: col.primaryKey
 	}));
@@ -165,8 +165,8 @@ function generateTableDDL(tableSchema: TableSchema): string {
 	const columnDefs: string[] = [];
 	for (const col of tableSchema.columns) {
 		let colDef = `"${col.name}"`;
-		if (col.affinity) {
-			colDef += ` ${col.affinity}`;
+		if (col.logicalType) {
+			colDef += ` ${col.logicalType.name}`;
 		}
 		if (col.notNull) {
 			colDef += ' NOT NULL';

package/src/schema/column.ts

@@ -10,8 +10,6 @@ export interface ColumnSchema {
 	name: string;
 	/** Logical type definition */
 	logicalType: LogicalType;
-	/** Data type affinity (TEXT, INTEGER, REAL, BLOB, NUMERIC) - kept for backward compatibility during transition */
-	affinity: SqlDataType;
 	/** Whether the column has a NOT NULL constraint */
 	notNull: boolean;
 	/** Whether the column is part of the primary key */
@@ -43,7 +41,6 @@ export function createDefaultColumnSchema(name: string, defaultNotNull: boolean
 	return {
 		name: name,
 		logicalType: TEXT_TYPE,
-		affinity: SqlDataType.TEXT,
 		notNull: defaultNotNull, // Third Manifesto: default to NOT NULL
 		primaryKey: false,
 		pkOrder: 0,

package/src/schema/function.ts

@@ -1,9 +1,10 @@
-import type { MaybePromise, Row, SqlValue } from '../common/types.js';
+import type { MaybePromise, Row, SqlValue, DeepReadonly } from '../common/types.js';
 import { FunctionFlags } from '../common/constants.js';
 import { SqlDataType } from '../common/types.js';
 import type { Database } from '../core/database.js';
 import type { BaseType, ScalarType, RelationType } from '../common/datatype.js';
 import type { AggValue } from '../func/registration.js';
+import type { LogicalType } from '../types/logical-type.js';
 
 /**
  * Type for a scalar function implementation.
@@ -74,6 +75,21 @@ export interface ScalarFunctionSchema extends BaseFunctionSchema {
 	returnType: ScalarType;
 	/** Direct scalar function implementation */
 	implementation: ScalarFunc;
+	/**
+	 * Optional type inference function for polymorphic functions.
+	 * If provided, this function will be called at planning time to determine
+	 * the return type based on the actual argument types.
+	 * This allows functions like abs() to return INTEGER when given INTEGER,
+	 * and REAL when given REAL.
+	 */
+	inferReturnType?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ScalarType;
+	/**
+	 * Optional argument type validation function.
+	 * If provided, this function will be called at planning time to validate
+	 * that the argument types are acceptable for this function.
+	 * Should return true if types are valid, false otherwise.
+	 */
+	validateArgTypes?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => boolean;
 }
 
 /**
@@ -98,6 +114,18 @@ export interface AggregateFunctionSchema extends BaseFunctionSchema {
 	finalizeFunction: AggregateFinalizer;
 	/** Initial accumulator value for aggregates */
 	initialValue?: AggValue;
+	/**
+	 * Optional type inference function for polymorphic aggregate functions.
+	 * If provided, this function will be called at planning time to determine
+	 * the return type based on the actual argument types.
+	 */
+	inferReturnType?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ScalarType;
+	/**
+	 * Optional argument type validation function.
+	 * If provided, this function will be called at planning time to validate
+	 * that the argument types are acceptable for this function.
+	 */
+	validateArgTypes?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => boolean;
 }
 
 /**

package/src/schema/table.ts

@@ -3,7 +3,6 @@ import type { AnyVirtualTableModule } from '../vtab/module.js';
 import { MemoryTableModule } from '../vtab/memory/module.js';
 import type { Expression } from '../parser/ast.js';
 import { type ColumnDef, type TableConstraint } from '../parser/ast.js';
-import { getAffinity } from '../common/type-inference.js';
 import { RowOp, SqlDataType, StatusCode, type SqlValue } from '../common/types.js';
 import type * as AST from '../parser/ast.js';
 import { quereusError, QuereusError } from '../common/errors.js';
@@ -99,7 +98,6 @@ export function columnDefToSchema(def: ColumnDef, defaultNotNull: boolean = true
 	const schema: Partial<ColumnSchema> & { name: string } = {
 		name: def.name,
 		logicalType: logicalType,
-		affinity: getAffinity(def.dataType), // Keep for backward compatibility during transition
 		notNull: defaultNotNull, // Default based on Third Manifesto principles
 		primaryKey: false,
 		pkOrder: 0,
@@ -166,8 +164,8 @@ export function columnDefToSchema(def: ColumnDef, defaultNotNull: boolean = true
 export interface MutationContextDefinition {
 	/** Variable name */
 	name: string;
-	/** Type affinity of the variable */
-	affinity: SqlDataType;
+	/** Logical type of the variable */
+	logicalType: import('../types/logical-type.js').LogicalType;
 	/** Whether the variable is NOT NULL */
 	notNull: boolean;
 }
@@ -182,7 +180,7 @@ export interface MutationContextDefinition {
 export function mutationContextVarToSchema(varDef: AST.MutationContextVar, defaultNotNull: boolean = true): MutationContextDefinition {
 	return {
 		name: varDef.name,
-		affinity: getAffinity(varDef.dataType),
+		logicalType: inferType(varDef.dataType),
 		notNull: varDef.notNull !== undefined ? varDef.notNull : defaultNotNull,
 	};
 }
@@ -403,8 +401,8 @@ function findColumnPKDefinition(columns: ReadonlyArray<ColumnSchema>): ReadonlyA
 
 	return Object.freeze(pkCols.map(col => ({
 		index: col.originalIndex,
-		desc: col.affinity === SqlDataType.INTEGER && col.pkDirection === 'desc',
-		autoIncrement: col.affinity === SqlDataType.INTEGER,
+		desc: col.logicalType.name === 'INTEGER' && col.pkDirection === 'desc',
+		autoIncrement: col.logicalType.name === 'INTEGER',
 		collation: col.collation || 'BINARY'
 	})));
 }

package/src/types/index.ts

@@ -5,7 +5,7 @@ export { PhysicalType, type LogicalType, getPhysicalType } from './logical-type.
 export { NULL_TYPE, INTEGER_TYPE, REAL_TYPE, TEXT_TYPE, BLOB_TYPE, BOOLEAN_TYPE, NUMERIC_TYPE, ANY_TYPE } from './builtin-types.js';
 
 // Temporal types
-export { DATE_TYPE, TIME_TYPE, DATETIME_TYPE } from './temporal-types.js';
+export { DATE_TYPE, TIME_TYPE, DATETIME_TYPE, TIMESPAN_TYPE } from './temporal-types.js';
 
 // JSON type
 export { JSON_TYPE } from './json-type.js';

package/src/types/registry.ts

@@ -9,7 +9,7 @@ import {
 	NUMERIC_TYPE,
 	ANY_TYPE,
 } from './builtin-types.js';
-import { DATE_TYPE, TIME_TYPE, DATETIME_TYPE } from './temporal-types.js';
+import { DATE_TYPE, TIME_TYPE, DATETIME_TYPE, TIMESPAN_TYPE } from './temporal-types.js';
 import { JSON_TYPE } from './json-type.js';
 import { createLogger } from '../common/logger.js';
 
@@ -36,9 +36,13 @@ class TypeRegistry {
 		this.registerType(DATE_TYPE);
 		this.registerType(TIME_TYPE);
 		this.registerType(DATETIME_TYPE);
+		this.registerType(TIMESPAN_TYPE);
 		this.registerType(JSON_TYPE);
 
 		// Register common aliases
+		// Temporal type aliases
+		this.types.set('INTERVAL', TIMESPAN_TYPE); // SQL standard alias
+		this.types.set('DURATION', TIMESPAN_TYPE); // Alternative name
 		this.types.set('INT', INTEGER_TYPE);
 		this.types.set('BIGINT', INTEGER_TYPE);
 		this.types.set('SMALLINT', INTEGER_TYPE);

package/src/types/temporal-types.ts

@@ -165,3 +165,126 @@ export const DATETIME_TYPE: LogicalType = {
 	supportedCollations: [],
 };
 
+/**
+ * Parse human-readable duration strings into Temporal.Duration
+ * Supports formats like "1 hour", "30 minutes", "2 days 3 hours"
+ */
+function parseHumanReadableDuration(input: string): Temporal.Duration | null {
+	const normalized = input.trim().toLowerCase();
+
+	// Handle negative durations
+	const isNegative = normalized.startsWith('-');
+	const workingInput = isNegative ? normalized.substring(1).trim() : normalized;
+
+	// Pattern: [number] [unit]
+	// Units: year(s), month(s), week(s), day(s), hour(s), minute(s), second(s), min(s), sec(s)
+	const pattern = /(\d+(?:\.\d+)?)\s*(years?|months?|weeks?|days?|hours?|minutes?|seconds?|mins?|secs?)/g;
+
+	const components: Record<string, number> = {};
+	let match;
+	let hasMatch = false;
+
+	while ((match = pattern.exec(workingInput)) !== null) {
+		hasMatch = true;
+		const value = parseFloat(match[1]);
+		const unit = match[2];
+
+		// Map unit to Temporal.Duration field
+		if (unit.startsWith('year')) {
+			components.years = (components.years || 0) + value;
+		} else if (unit.startsWith('month')) {
+			components.months = (components.months || 0) + value;
+		} else if (unit.startsWith('week')) {
+			components.weeks = (components.weeks || 0) + value;
+		} else if (unit.startsWith('day')) {
+			components.days = (components.days || 0) + value;
+		} else if (unit.startsWith('hour')) {
+			components.hours = (components.hours || 0) + value;
+		} else if (unit.startsWith('min')) {
+			components.minutes = (components.minutes || 0) + value;
+		} else if (unit.startsWith('sec')) {
+			components.seconds = (components.seconds || 0) + value;
+		}
+	}
+
+	if (!hasMatch) return null;
+
+	try {
+		const duration = Temporal.Duration.from(components);
+		return isNegative ? duration.negated() : duration;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * TIMESPAN type - stores ISO 8601 duration strings
+ * Uses Temporal.Duration for validation and parsing
+ */
+export const TIMESPAN_TYPE: LogicalType = {
+	name: 'TIMESPAN',
+	physicalType: PhysicalType.TEXT,
+	isTemporal: true,
+
+	validate: (v) => {
+		if (v === null) return true;
+		if (typeof v !== 'string') return false;
+		try {
+			Temporal.Duration.from(v);
+			return true;
+		} catch {
+			// Try parsing human-readable format
+			return parseHumanReadableDuration(v) !== null;
+		}
+	},
+
+	parse: (v) => {
+		if (v === null) return null;
+
+		if (typeof v === 'number') {
+			// Interpret as seconds
+			const duration = Temporal.Duration.from({ seconds: v });
+			return duration.toString();
+		}
+
+		if (typeof v === 'string') {
+			try {
+				// Try ISO 8601 first
+				const duration = Temporal.Duration.from(v);
+				return duration.toString();
+			} catch {
+				// Try human-readable format
+				const duration = parseHumanReadableDuration(v);
+				if (duration) return duration.toString();
+				throw new TypeError(`Cannot convert '${v}' to TIMESPAN`);
+			}
+		}
+
+		throw new TypeError(`Cannot convert ${typeof v} to TIMESPAN`);
+	},
+
+	compare: (a, b) => {
+		if (a === null && b === null) return 0;
+		if (a === null) return -1;
+		if (b === null) return 1;
+
+		try {
+			const durationA = Temporal.Duration.from(a as string);
+			const durationB = Temporal.Duration.from(b as string);
+
+			// Use a reference date to resolve calendar units
+			// This ensures consistent comparison of durations with months/years
+			const referenceDate = Temporal.PlainDate.from('2024-01-01');
+			const totalA = durationA.total({ unit: 'seconds', relativeTo: referenceDate });
+			const totalB = durationB.total({ unit: 'seconds', relativeTo: referenceDate });
+
+			return totalA < totalB ? -1 : totalA > totalB ? 1 : 0;
+		} catch {
+			// If parsing fails, fall back to string comparison
+			return (a as string).localeCompare(b as string);
+		}
+	},
+
+	supportedCollations: [],
+};
+

package/src/util/plan-formatter.ts

@@ -21,10 +21,7 @@ export function formatExpressionList(nodes: readonly ScalarPlanNode[]): string {
  * Format a scalar type to a simple string representation.
  */
 export function formatScalarType(type: ScalarType): string {
-	if (type.datatype !== undefined) {
-		return SqlDataType[type.datatype];
-	}
-	return SqlDataType[type.affinity];
+	return type.logicalType.name;
 }
 
 /**

package/src/util/row-descriptor.ts

@@ -1,6 +1,6 @@
 import type { RowDescriptor, Attribute } from '../planner/nodes/plan-node.js';
 import type { Row } from '../common/types.js';
-import { SqlDataType } from '../common/types.js';
+import { TEXT_TYPE } from '../types/builtin-types.js';
 
 /**
  * Utility to build a RowDescriptor (attributeId → columnIndex mapping)
@@ -94,7 +94,7 @@ export function buildAttributesFromFlatDescriptor(flatRowDescriptor: RowDescript
 			name: `attr_${attrId}`,
 			type: {
 				typeClass: 'scalar' as const,
-				affinity: SqlDataType.TEXT,
+				logicalType: TEXT_TYPE,
 				nullable: true,
 				isReadOnly: false
 			},

package/src/vtab/best-access-plan.ts

@@ -5,7 +5,8 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { quereusError } from '../common/errors.js';
-import { StatusCode, type SqlDataType, type SqlValue } from '../common/types.js';
+import { StatusCode, type SqlValue } from '../common/types.js';
+import type { LogicalType } from '../types/logical-type.js';
 
 /**
  * Constraint operators that can be pushed down to virtual tables
@@ -20,8 +21,8 @@ export interface ColumnMeta {
 	index: number;
 	/** Column name */
 	name: string;
-	/** SQL type information */
-	type: SqlDataType;
+	/** Logical type information */
+	type: LogicalType;
 	/** Whether this column is part of the primary key */
 	isPrimaryKey: boolean;
 	/** Whether this column has a unique constraint */

package/src/vtab/memory/module.ts

@@ -103,7 +103,7 @@ export class MemoryTableModule implements VirtualTableModule<MemoryTable, Memory
 		return tableInfo.columns.map((col, index) => ({
 			index,
 			name: col.name,
-			type: col.affinity,
+			type: col.logicalType,
 			isPrimaryKey: tableInfo.primaryKeyDefinition.some(pk => pk.index === index),
 			isUnique: col.primaryKey // Primary key columns are unique, others would be determined by constraints/indexes
 		}));