@quereus/quereus 0.5.1 → 0.6.0

package/src/runtime/emit/temporal-arithmetic.ts

@@ -0,0 +1,302 @@
+import { StatusCode } from "../../common/types.js";
+import { QuereusError } from "../../common/errors.js";
+import type { SqlValue } from "../../common/types.js";
+import type { Instruction, InstructionRun, RuntimeContext } from "../types.js";
+import type { BinaryOpNode } from "../../planner/nodes/scalar.js";
+import { emitPlanNode } from "../emitters.js";
+import type { EmissionContext } from "../emission-context.js";
+import { Temporal } from 'temporal-polyfill';
+import { TIMESPAN_TYPE } from "../../types/temporal-types.js";
+
+/**
+ * Check if a value is a date string (YYYY-MM-DD format)
+ */
+function isDateValue(v: SqlValue): boolean {
+	if (typeof v !== 'string') return false;
+	// Simple check for ISO 8601 date format
+	return /^\d{4}-\d{2}-\d{2}$/.test(v);
+}
+
+/**
+ * Check if a value is a time string (HH:MM:SS format)
+ */
+function isTimeValue(v: SqlValue): boolean {
+	if (typeof v !== 'string') return false;
+	// Simple check for ISO 8601 time format
+	return /^\d{2}:\d{2}:\d{2}/.test(v);
+}
+
+/**
+ * Check if a value is a datetime string (ISO 8601 format)
+ */
+function isDateTimeValue(v: SqlValue): boolean {
+	if (typeof v !== 'string') return false;
+	// Check for ISO 8601 datetime format (with T separator)
+	return v.includes('T') && /^\d{4}-\d{2}-\d{2}T/.test(v);
+}
+
+/**
+ * Check if a value is a timespan/duration string (ISO 8601 duration format)
+ */
+function isTimespanValue(v: SqlValue): boolean {
+	if (typeof v !== 'string') return false;
+	// ISO 8601 duration starts with P (or -P for negative)
+	return v.startsWith('P') || v.startsWith('-P');
+}
+
+/**
+ * Try to perform temporal arithmetic on two values.
+ * Returns the result if successful, or undefined if the values are not temporal types.
+ * Throws QuereusError if the operation is invalid.
+ */
+export function tryTemporalArithmetic(operator: string, v1: SqlValue, v2: SqlValue): SqlValue | undefined {
+		if (v1 === null || v2 === null) return null;
+
+		// Detect types at runtime
+		const isV1Date = isDateValue(v1);
+		const isV1Time = isTimeValue(v1);
+		const isV1DateTime = isDateTimeValue(v1);
+		const isV1Timespan = isTimespanValue(v1);
+
+		const isV2Date = isDateValue(v2);
+		const isV2Time = isTimeValue(v2);
+		const isV2DateTime = isDateTimeValue(v2);
+		const isV2Timespan = isTimespanValue(v2);
+
+		// If neither operand is temporal, return undefined to signal non-temporal operation
+		const isV1Temporal = isV1Date || isV1Time || isV1DateTime || isV1Timespan;
+		const isV2Temporal = isV2Date || isV2Time || isV2DateTime || isV2Timespan;
+		if (!isV1Temporal && !isV2Temporal) {
+			return undefined;
+		}
+
+		try {
+
+			// DATE/DATETIME - DATE/DATETIME → TIMESPAN
+			if (operator === '-' &&
+				(isV1Date || isV1DateTime) &&
+				(isV2Date || isV2DateTime)) {
+
+				// Parse both values as dates
+				const date1 = isV1DateTime
+					? Temporal.PlainDateTime.from(v1 as string).toPlainDate()
+					: Temporal.PlainDate.from(v1 as string);
+				const date2 = isV2DateTime
+					? Temporal.PlainDateTime.from(v2 as string).toPlainDate()
+					: Temporal.PlainDate.from(v2 as string);
+
+				const duration = date1.since(date2);
+				return duration.toString();
+			}
+
+			// TIME - TIME → TIMESPAN
+			if (operator === '-' && isV1Time && isV2Time) {
+				const time1 = Temporal.PlainTime.from(v1 as string);
+				const time2 = Temporal.PlainTime.from(v2 as string);
+				const duration = time1.since(time2);
+				return duration.toString();
+			}
+
+			// DATE + TIMESPAN → DATE
+			if (operator === '+' && isV1Date && isV2Timespan) {
+				const date = Temporal.PlainDate.from(v1 as string);
+				const duration = Temporal.Duration.from(v2 as string);
+				const result = date.add(duration);
+				return result.toString();
+			}
+
+			// TIMESPAN + DATE → DATE (commutative)
+			if (operator === '+' && isV1Timespan && isV2Date) {
+				const duration = Temporal.Duration.from(v1 as string);
+				const date = Temporal.PlainDate.from(v2 as string);
+				const result = date.add(duration);
+				return result.toString();
+			}
+
+			// DATE - TIMESPAN → DATE
+			if (operator === '-' && isV1Date && isV2Timespan) {
+				const date = Temporal.PlainDate.from(v1 as string);
+				const duration = Temporal.Duration.from(v2 as string);
+				const result = date.subtract(duration);
+				return result.toString();
+			}
+
+			// DATETIME + TIMESPAN → DATETIME
+			if (operator === '+' && isV1DateTime && isV2Timespan) {
+				const dt = Temporal.PlainDateTime.from(v1 as string);
+				const duration = Temporal.Duration.from(v2 as string);
+				const result = dt.add(duration);
+				return result.toString();
+			}
+
+			// TIMESPAN + DATETIME → DATETIME (commutative)
+			if (operator === '+' && isV1Timespan && isV2DateTime) {
+				const duration = Temporal.Duration.from(v1 as string);
+				const dt = Temporal.PlainDateTime.from(v2 as string);
+				const result = dt.add(duration);
+				return result.toString();
+			}
+
+			// DATETIME - TIMESPAN → DATETIME
+			if (operator === '-' && isV1DateTime && isV2Timespan) {
+				const dt = Temporal.PlainDateTime.from(v1 as string);
+				const duration = Temporal.Duration.from(v2 as string);
+				const result = dt.subtract(duration);
+				return result.toString();
+			}
+
+			// TIME + TIMESPAN → TIME
+			if (operator === '+' && isV1Time && isV2Timespan) {
+				const time = Temporal.PlainTime.from(v1 as string);
+				const duration = Temporal.Duration.from(v2 as string);
+				const result = time.add(duration);
+				return result.toString();
+			}
+
+			// TIMESPAN + TIME → TIME (commutative)
+			if (operator === '+' && isV1Timespan && isV2Time) {
+				const duration = Temporal.Duration.from(v1 as string);
+				const time = Temporal.PlainTime.from(v2 as string);
+				const result = time.add(duration);
+				return result.toString();
+			}
+
+			// TIME - TIMESPAN → TIME
+			if (operator === '-' && isV1Time && isV2Timespan) {
+				const time = Temporal.PlainTime.from(v1 as string);
+				const duration = Temporal.Duration.from(v2 as string);
+				const result = time.subtract(duration);
+				return result.toString();
+			}
+
+			// TIMESPAN + TIMESPAN → TIMESPAN
+			if (operator === '+' && isV1Timespan && isV2Timespan) {
+				const d1 = Temporal.Duration.from(v1 as string);
+				const d2 = Temporal.Duration.from(v2 as string);
+				const result = d1.add(d2);
+				return result.toString();
+			}
+
+			// TIMESPAN - TIMESPAN → TIMESPAN
+			if (operator === '-' && isV1Timespan && isV2Timespan) {
+				const d1 = Temporal.Duration.from(v1 as string);
+				const d2 = Temporal.Duration.from(v2 as string);
+				const result = d1.subtract(d2);
+				return result.toString();
+			}
+
+			// TIMESPAN * NUMBER → TIMESPAN
+			if (operator === '*' && isV1Timespan && typeof v2 === 'number') {
+				const duration = Temporal.Duration.from(v1 as string);
+				// Convert to seconds, multiply, convert back
+				const totalSeconds = duration.total({ unit: 'seconds' });
+				const newDuration = Temporal.Duration.from({ seconds: totalSeconds * v2 });
+				return newDuration.toString();
+			}
+
+			// NUMBER * TIMESPAN → TIMESPAN (commutative)
+			if (operator === '*' && typeof v1 === 'number' && isV2Timespan) {
+				const duration = Temporal.Duration.from(v2 as string);
+				const totalSeconds = duration.total({ unit: 'seconds' });
+				const newDuration = Temporal.Duration.from({ seconds: totalSeconds * v1 });
+				return newDuration.toString();
+			}
+
+			// TIMESPAN / NUMBER → TIMESPAN
+			if (operator === '/' && isV1Timespan && typeof v2 === 'number') {
+				if (v2 === 0) return null;
+				const duration = Temporal.Duration.from(v1 as string);
+				const totalSeconds = duration.total({ unit: 'seconds' });
+				const newDuration = Temporal.Duration.from({ seconds: totalSeconds / v2 });
+				return newDuration.toString();
+			}
+
+			// TIMESPAN / TIMESPAN → NUMBER (ratio)
+			if (operator === '/' && isV1Timespan && isV2Timespan) {
+				const d1 = Temporal.Duration.from(v1 as string);
+				const d2 = Temporal.Duration.from(v2 as string);
+				const total1 = d1.total({ unit: 'seconds' });
+				const total2 = d2.total({ unit: 'seconds' });
+				if (total2 === 0) return null;
+				return total1 / total2;
+			}
+
+			// If we get here, the operation is not supported
+			throw new QuereusError(
+				`Unsupported temporal operation`,
+				StatusCode.UNSUPPORTED
+			);
+		} catch (e) {
+			// Invalid temporal operation - return null
+			if (e instanceof QuereusError) throw e;
+			return null;
+		}
+}
+
+/**
+ * Emit temporal arithmetic operations
+ * Handles operations between temporal types (DATE, TIME, DATETIME, TIMESPAN)
+ */
+export function emitTemporalArithmetic(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
+	const operator = plan.expression.operator;
+
+	function run(ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue {
+		return tryTemporalArithmetic(operator, v1, v2) ?? null;
+	}
+
+	const leftExpr = emitPlanNode(plan.left, ctx);
+	const rightExpr = emitPlanNode(plan.right, ctx);
+
+	return {
+		params: [leftExpr, rightExpr],
+		run: run as InstructionRun,
+		note: `${operator}(temporal)`
+	};
+}
+
+/**
+ * Attempts to perform temporal comparison. Returns undefined if not a temporal comparison.
+ * This allows the caller to fall back to standard comparison logic.
+ *
+ * Temporal types that need special comparison logic (beyond lexicographic string comparison):
+ * - TIMESPAN: Durations need to be compared semantically, not lexicographically
+ *   (e.g., "PT30M" > "PT1H" lexicographically, but 30 minutes < 1 hour semantically)
+ *
+ * Note: DATE, TIME, and DATETIME use ISO 8601 format which compares correctly lexicographically,
+ * so they don't need special handling here.
+ *
+ * @param operator The comparison operator (=, !=, <, <=, >, >=)
+ * @param v1 First value
+ * @param v2 Second value
+ * @returns Comparison result (0 or 1) if temporal comparison, undefined otherwise
+ */
+export function tryTemporalComparison(operator: string, v1: SqlValue, v2: SqlValue): SqlValue | undefined {
+	// Check if both values are timespans
+	// Timespans are the only temporal type that needs special comparison logic
+	// because ISO 8601 duration strings don't compare correctly lexicographically
+	if (!isTimespanValue(v1) || !isTimespanValue(v2)) {
+		return undefined;
+	}
+
+	// Use the TIMESPAN_TYPE's compare function
+	const cmp = TIMESPAN_TYPE.compare!(v1, v2);
+
+	switch (operator) {
+		case '=':
+		case '==':
+			return cmp === 0 ? 1 : 0;
+		case '!=':
+		case '<>':
+			return cmp !== 0 ? 1 : 0;
+		case '<':
+			return cmp < 0 ? 1 : 0;
+		case '<=':
+			return cmp <= 0 ? 1 : 0;
+		case '>':
+			return cmp > 0 ? 1 : 0;
+		case '>=':
+			return cmp >= 0 ? 1 : 0;
+		default:
+			return undefined;
+	}
+}

package/src/runtime/emit/unary.ts

@@ -6,6 +6,7 @@ import type { UnaryOpNode } from "../../planner/nodes/scalar.js";
 import { emitPlanNode } from "../emitters.js";
 import type { EmissionContext } from "../emission-context.js";
 import { isTruthy } from "../../util/comparison.js";
+import { Temporal } from 'temporal-polyfill';
 
 export function emitUnaryOp(plan: UnaryOpNode, ctx: EmissionContext): Instruction {
 	// Select the operation function at emit time
@@ -42,6 +43,18 @@ export function emitUnaryOp(plan: UnaryOpNode, ctx: EmissionContext): Instructio
 		case '-':
 			run = (ctx: RuntimeContext, operand: SqlValue) => {
 				if (operand === null) return null;
+
+				// Check if it's a timespan (ISO 8601 duration string)
+				if (typeof operand === 'string' && (operand.startsWith('P') || operand.startsWith('-P'))) {
+					try {
+						const duration = Temporal.Duration.from(operand);
+						return duration.negated().toString();
+					} catch {
+						// Not a valid duration, fall through to numeric handling
+					}
+				}
+
+				// Numeric negation
 				if (typeof operand === 'number') return -operand;
 				if (typeof operand === 'bigint') return -operand;
 				// Try to convert to number

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/ast-stringify.ts

@@ -167,7 +167,7 @@ export function expressionToString(expr: AST.Expression): string {
 			// Handle postfix operators like IS NULL, IS NOT NULL
 			if (expr.operator === 'IS NULL' || expr.operator === 'IS NOT NULL') {
 				return `${exprStr} ${expr.operator.toLowerCase()}`;
-			} else if (expr.operator === 'NOT') {
+			} else if (expr.operator.toUpperCase() === 'NOT') {
 				return `${expr.operator.toLowerCase()} ${exprStr}`;
 			}
 			return `${expr.operator.toLowerCase()}${exprStr}`;

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
 			},