@quereus/quereus 0.5.2 → 0.6.1

package/src/runtime/emit/binary.ts

@@ -8,6 +8,7 @@ import { compareSqlValuesFast, resolveCollation } from "../../util/comparison.js
 import { coerceForComparison, coerceToNumberForArithmetic } from "../../util/coercion.js";
 import { simpleLike } from "../../util/patterns.js";
 import type { EmissionContext } from "../emission-context.js";
+import { tryTemporalArithmetic, tryTemporalComparison } from "./temporal-arithmetic.js";
 
 export function emitBinaryOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
 	// Normalize operator to uppercase for case-insensitive matching of keywords
@@ -73,6 +74,13 @@ export function emitNumericOp(plan: BinaryOpNode, ctx: EmissionContext): Instruc
 	}
 
 	function run(ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue {
+		// Try temporal arithmetic first
+		const temporalResult = tryTemporalArithmetic(plan.expression.operator, v1, v2);
+		if (temporalResult !== undefined) {
+			return temporalResult;
+		}
+
+		// Fall back to numeric arithmetic
 		if (v1 !== null && v2 !== null) {
 			if (typeof v1 === 'bigint' || typeof v2 === 'bigint') {
 				try {
@@ -127,16 +135,24 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 	// Pre-resolve collation function for optimal performance
 	const collationFunc = resolveCollation(collationName);
 
-	switch (plan.expression.operator) {
+	const operator = plan.expression.operator;
+
+	switch (operator) {
 		case '=':
 		case '==':
 			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
 				// SQL comparison: NULL = anything -> NULL
 				if (v1 === null || v2 === null) return null;
 
+				// Try temporal comparison first
+				const temporalResult = tryTemporalComparison(operator, v1, v2);
+				if (temporalResult !== undefined) {
+					return temporalResult;
+				}
+
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) === 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) === 0;
 			};
 			break;
 		case '!=':
@@ -145,9 +161,15 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 				// SQL comparison: NULL != anything -> NULL
 				if (v1 === null || v2 === null) return null;
 
+				// Try temporal comparison first
+				const temporalResult = tryTemporalComparison(operator, v1, v2);
+				if (temporalResult !== undefined) {
+					return temporalResult;
+				}
+
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) !== 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) !== 0;
 			};
 			break;
 		case '<':
@@ -155,9 +177,15 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 				// SQL comparison: NULL < anything -> NULL
 				if (v1 === null || v2 === null) return null;
 
+				// Try temporal comparison first
+				const temporalResult = tryTemporalComparison(operator, v1, v2);
+				if (temporalResult !== undefined) {
+					return temporalResult;
+				}
+
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) < 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) < 0;
 			};
 			break;
 		case '<=':
@@ -165,9 +193,15 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 				// SQL comparison: NULL <= anything -> NULL
 				if (v1 === null || v2 === null) return null;
 
+				// Try temporal comparison first
+				const temporalResult = tryTemporalComparison(operator, v1, v2);
+				if (temporalResult !== undefined) {
+					return temporalResult;
+				}
+
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) <= 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) <= 0;
 			};
 			break;
 		case '>':
@@ -177,11 +211,15 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 					return null;
 				}
 
+				// Try temporal comparison first
+				const temporalResult = tryTemporalComparison(operator, v1, v2);
+				if (temporalResult !== undefined) {
+					return temporalResult;
+				}
+
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				const comparisonResult = compareSqlValuesFast(coercedV1, coercedV2, collationFunc);
-				const finalResult = comparisonResult > 0 ? 1 : 0;
-				return finalResult;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) > 0;
 			};
 			break;
 		case '>=':
@@ -189,13 +227,19 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 				// SQL comparison: NULL >= anything -> NULL
 				if (v1 === null || v2 === null) return null;
 
+				// Try temporal comparison first
+				const temporalResult = tryTemporalComparison(operator, v1, v2);
+				if (temporalResult !== undefined) {
+					return temporalResult;
+				}
+
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) >= 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) >= 0;
 			};
 			break;
 		default:
-			throw new QuereusError(`Unsupported comparison operator: ${plan.expression.operator}`, StatusCode.UNSUPPORTED);
+			throw new QuereusError(`Unsupported comparison operator: ${operator}`, StatusCode.UNSUPPORTED);
 	}
 
 	const leftExpr = emitPlanNode(plan.left, ctx);
@@ -237,38 +281,38 @@ export function emitLogicalOp(plan: BinaryOpNode, ctx: EmissionContext): Instruc
 		// SQL three-valued logic
 		switch (operator) {
 			case 'AND': {
-				// NULL AND x -> NULL if x is true or NULL, otherwise 0
-				// 0 AND x -> 0
-				// 1 AND x -> x
+				// NULL AND x -> NULL if x is true or NULL, otherwise false
+				// false AND x -> false
+				// true AND x -> x
 				if (v1 === null) {
-					return (v2 === null || v2) ? null : 0;
+					return (v2 === null || v2) ? null : false;
 				}
-				if (!v1) return 0;
-				return v2 === null ? null : (v2 ? 1 : 0);
+				if (!v1) return false;
+				return v2 === null ? null : (v2 ? true : false);
 			}
 
 			case 'OR': {
-				// NULL OR x -> NULL if x is false or NULL, otherwise 1
-				// 1 OR x -> 1
-				// 0 OR x -> x
+				// NULL OR x -> NULL if x is false or NULL, otherwise true
+				// true OR x -> true
+				// false OR x -> x
 				if (v1 === null) {
-					return (v2 === null || !v2) ? null : 1;
+					return (v2 === null || !v2) ? null : true;
 				}
-				if (v1) return 1;
-				return v2 === null ? null : (v2 ? 1 : 0);
+				if (v1) return true;
+				return v2 === null ? null : (v2 ? true : false);
 			}
 
 			case 'XOR': {
 				// NULL XOR x -> NULL
 				// x XOR NULL -> NULL
-				// 0 XOR 0 -> 0
-				// 0 XOR 1 -> 1
-				// 1 XOR 0 -> 1
-				// 1 XOR 1 -> 0
+				// false XOR false -> false
+				// false XOR true -> true
+				// true XOR false -> true
+				// true XOR true -> false
 				if (v1 === null || v2 === null) return null;
-				const b1 = v1 ? 1 : 0;
-				const b2 = v2 ? 1 : 0;
-				return b1 !== b2 ? 1 : 0;
+				const b1 = !!v1;
+				const b2 = !!v2;
+				return b1 !== b2;
 			}
 
 			default:
@@ -298,7 +342,7 @@ export function emitLikeOp(plan: BinaryOpNode, ctx: EmissionContext): Instructio
 		const textStr = String(text);
 		const patternStr = String(pattern);
 
-		return simpleLike(patternStr, textStr) ? 1 : 0;
+		return simpleLike(patternStr, textStr);
 	}
 
 	const leftExpr = emitPlanNode(plan.left, ctx);

package/src/runtime/emit/subquery.ts

@@ -63,13 +63,13 @@ export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
 					}
 					// Check for match immediately - no need to materialize
 					if (compareSqlValuesFast(condition, rowValue, collation) === 0) {
-						return 1; // Found a match
+						return true; // Found a match
 					}
 				}
 			}
 
 			// No match found - if any value was NULL, result is NULL
-			return hasNull ? null : 0;
+			return hasNull ? null : false;
 		}
 
 		const sourceInstruction = emitPlanNode(plan.source, ctx);
@@ -103,11 +103,11 @@ export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
 				// Check if condition exists in pre-built tree
 				const path = tree.find(condition);
 				if (path.on) {
-					return 1; // Found a match
+					return true; // Found a match
 				}
 
 				// No match found - if any value was NULL, result is NULL
-				return hasNull ? null : 0;
+				return hasNull ? null : false;
 			}
 
 			const values = plan.values.map(val => (val as unknown as ConstantNode).getValue());
@@ -163,12 +163,12 @@ export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
 						continue;
 					}
 					if (compareSqlValuesFast(condition, value, collation) === 0) {
-						return 1; // Found a match
+						return true; // Found a match
 					}
 				}
 
 				// No match found - if any value was NULL, result is NULL
-				return hasNull ? null : 0;
+				return hasNull ? null : false;
 			}
 
 			const conditionExpr = emitPlanNode(plan.condition, ctx);
@@ -188,9 +188,9 @@ export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
 export function emitExists(plan: ExistsNode, ctx: EmissionContext): Instruction {
 	async function run(_rctx: RuntimeContext, input: AsyncIterable<Row>): Promise<SqlValue> {
 		for await (const _row of input) {
-			return 1; // First row => TRUE
+			return true; // First row => TRUE
 		}
-		return 0; // Empty => FALSE
+		return false; // Empty => FALSE
 	}
 
 	const innerInstruction = emitPlanNode(plan.subquery, ctx);

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 (boolean) 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;
+		case '!=':
+		case '<>':
+			return cmp !== 0;
+		case '<':
+			return cmp < 0;
+		case '<=':
+			return cmp <= 0;
+		case '>':
+			return cmp > 0;
+		case '>=':
+			return cmp >= 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
@@ -18,23 +19,23 @@ export function emitUnaryOp(plan: UnaryOpNode, ctx: EmissionContext): Instructio
 	switch (operator) {
 		case 'NOT':
 			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				// SQL NOT: NULL -> NULL, 0 -> 1, anything else -> 0
+				// SQL NOT: NULL -> NULL, false -> true, true -> false
 				if (operand === null) return null;
-				return isTruthy(operand) ? 0 : 1;
+				return !isTruthy(operand);
 			};
 			note = 'NOT';
 			break;
 
 		case 'IS NULL':
 			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				return operand === null ? 1 : 0;
+				return operand === null;
 			};
 			note = 'IS NULL';
 			break;
 
 		case 'IS NOT NULL':
 			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				return operand !== null ? 1 : 0;
+				return operand !== null;
 			};
 			note = 'IS NOT NULL';
 			break;
@@ -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,