@quereus/quereus 0.5.2 → 0.6.0

package/src/planner/nodes/subquery.ts

@@ -1,13 +1,14 @@
 import { PlanNode, type ScalarPlanNode } from "./plan-node.js";
 import type { ScalarType } from "../../common/datatype.js";
 import type { RelationalPlanNode } from "./plan-node.js";
-import { type CompareFn, SqlDataType } from "../../common/types.js";
+import { type CompareFn } from "../../common/types.js";
 import { PlanNodeType } from "./plan-node-type.js";
 import type { Scope } from "../scopes/scope.js";
 import { compareSqlValues } from "../../util/comparison.js";
 import type { Expression } from "../../parser/ast.js";
 import { formatExpression, formatScalarType } from "../../util/plan-formatter.js";
 import { quereusError } from "../../common/errors.js";
+import { BLOB_TYPE, INTEGER_TYPE } from "../../types/builtin-types.js";
 import { StatusCode } from "../../common/types.js";
 
 export class ScalarSubqueryNode extends PlanNode implements ScalarPlanNode {
@@ -31,10 +32,9 @@ export class ScalarSubqueryNode extends PlanNode implements ScalarPlanNode {
 		// Fallback to nullable BLOB if we can't determine type
 		return {
 			typeClass: 'scalar',
-			affinity: SqlDataType.BLOB,
+			logicalType: BLOB_TYPE,
 			nullable: true,
 			isReadOnly: true,
-			datatype: SqlDataType.BLOB,
 		};
 	}
 
@@ -103,10 +103,9 @@ export class InNode extends PlanNode implements ScalarPlanNode {
 	getType(): ScalarType {
 		return {
 			typeClass: 'scalar',
-			affinity: SqlDataType.INTEGER,
+			logicalType: INTEGER_TYPE,
 			nullable: false,
 			isReadOnly: true,
-			datatype: SqlDataType.INTEGER,
 		}
 	}
 
@@ -216,10 +215,9 @@ export class ExistsNode extends PlanNode implements ScalarPlanNode {
 	getType(): ScalarType {
 		return {
 			typeClass: 'scalar',
-			affinity: SqlDataType.INTEGER,
+			logicalType: INTEGER_TYPE,
 			nullable: false,
 			isReadOnly: true,
-			datatype: SqlDataType.INTEGER,
 		};
 	}
 

package/src/planner/nodes/view-reference-node.ts

@@ -1,10 +1,10 @@
 import { PlanNode, type ZeroAryRelationalNode, type Attribute } from './plan-node.js';
 import type { RelationType } from '../../common/datatype.js';
-import { SqlDataType } from '../../common/types.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
 import type { ViewSchema } from '../../schema/view.js';
 import { Cached } from '../../util/cached.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 
 /**
  * Plan node for referencing a view in a FROM clause.
@@ -36,7 +36,7 @@ export class ViewReferenceNode extends PlanNode implements ZeroAryRelationalNode
 			name: columnName,
 			type: {
 				typeClass: 'scalar' as const,
-				affinity: SqlDataType.TEXT,
+				logicalType: TEXT_TYPE,
 				nullable: true,
 				isReadOnly: false
 			}, // Default type, should be inferred

package/src/planner/nodes/window-function.ts

@@ -4,8 +4,8 @@ import type { ScalarType } from '../../common/datatype.js';
 import type { Scope } from '../scopes/scope.js';
 import type { WindowFunctionExpr } from '../../parser/ast.js';
 import { Cached } from '../../util/cached.js';
-import { SqlDataType } from '../../common/types.js';
 import { formatScalarType } from '../../util/plan-formatter.js';
+import { INTEGER_TYPE, REAL_TYPE } from '../../types/builtin-types.js';
 
 /**
  * Represents a window function call in the query plan.
@@ -30,10 +30,10 @@ export class WindowFunctionCallNode extends PlanNode implements ZeroAryScalarNod
 			// Most window functions return numeric types
 			// row_number() specifically returns an integer
 			if (this.functionName === 'row_number') {
-				return { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false } satisfies ScalarType;
+				return { typeClass: 'scalar', logicalType: INTEGER_TYPE, nullable: false } satisfies ScalarType;
 			}
 			// Other window functions would have their own type inference
-			return { typeClass: 'scalar', affinity: SqlDataType.NUMERIC, nullable: false } satisfies ScalarType;
+			return { typeClass: 'scalar', logicalType: REAL_TYPE, nullable: false } satisfies ScalarType;
 		});
 	}
 

package/src/planner/rules/access/rule-select-access-path.ts

@@ -120,7 +120,7 @@ function createIndexBasedAccess(retrieveNode: RetrieveNode, context: OptContext)
 			columns: tableSchema.columns.map((col, index) => ({
 				index,
 				name: col.name,
-				type: col.affinity,
+				type: col.logicalType,
 				isPrimaryKey: col.primaryKey || false,
 				isUnique: col.primaryKey || false // For now, assume only PK columns are unique
 			} as ColumnMeta)),

package/src/planner/rules/retrieve/rule-grow-retrieve.ts

@@ -231,7 +231,7 @@ function fallbackIndexSupports(
 		columns: tableSchema.columns.map((col, index) => ({
 			index,
 			name: col.name,
-			type: col.affinity,
+			type: col.logicalType,
 			isPrimaryKey: col.primaryKey || false,
 			isUnique: col.primaryKey || false
 		})),

package/src/planner/scopes/global.ts

@@ -5,8 +5,8 @@ import * as AST from "../../parser/ast.js";
 import { FunctionReferenceNode, TableReferenceNode } from "../nodes/reference.js";
 import { Ambiguous } from "./scope.js";
 import type { ScalarType } from "../../common/datatype.js";
-import { SqlDataType } from "../../common/types.js";
 import { isScalarFunctionSchema } from "../../schema/function.js";
+import { REAL_TYPE } from "../../types/builtin-types.js";
 
 export class GlobalScope extends BaseScope {
 	constructor(public readonly manager: SchemaManager) {
@@ -25,7 +25,7 @@ export class GlobalScope extends BaseScope {
 			// Get the proper scalar type from the function schema
 			const scalarType: ScalarType = isScalarFunctionSchema(func)
 				? func.returnType
-				: { typeClass: 'scalar', affinity: SqlDataType.NUMERIC, nullable: true, isReadOnly: true };
+				: { typeClass: 'scalar', logicalType: REAL_TYPE, nullable: true, isReadOnly: true };
 
 			return new FunctionReferenceNode(this, func, scalarType);
 		}
@@ -54,7 +54,7 @@ export class GlobalScope extends BaseScope {
 			// Get the proper scalar type from the function schema
 			const scalarType: ScalarType = isScalarFunctionSchema(func)
 				? func.returnType
-				: { typeClass: 'scalar', affinity: SqlDataType.NUMERIC, nullable: true, isReadOnly: true };
+				: { typeClass: 'scalar', logicalType: REAL_TYPE, nullable: true, isReadOnly: true };
 
 			return new FunctionReferenceNode(this, func, scalarType);
 		}

package/src/planner/scopes/param.ts

@@ -3,13 +3,13 @@ import { ParameterReferenceNode } from '../nodes/reference.js'; // Corrected imp
 import { BaseScope } from './base.js';
 import { Ambiguous, type Scope } from './scope.js';
 import type { ScalarType } from '../../common/datatype.js';
-import { SqlDataType } from '../../common/types.js';
 import type { PlanNode } from '../nodes/plan-node.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 
 // Default type for parameters when not otherwise specified.
 const DEFAULT_PARAMETER_TYPE: ScalarType = {
 	typeClass: 'scalar',
-	affinity: SqlDataType.TEXT,
+	logicalType: TEXT_TYPE,
 	nullable: true,
 };
 

package/src/planner/type-utils.ts

@@ -4,8 +4,7 @@ import type { RelationType, ColumnDef, ScalarType, ColRef } from '../common/data
 import { SqlDataType, StatusCode, type DeepReadonly, type SqlValue } from '../common/types.js'; // Import SqlValue and ensure SqlDataType is not type-only
 import type { AstNode } from '../parser/ast.js';
 import { QuereusError } from '../common/errors.js';
-// Note: getAffinity from '../schema/column.js' is used by the ColumnSchema type from table.js itself if that's what we use.
-// If tableSchema.columns are of type from '../schema/column.js', then their affinity is already SqlDataType.
+import { inferLogicalTypeFromValue } from '../common/type-inference.js';
 
 /**
  * Converts a TableSchema (from src/schema/table.ts) to a RelationType (from src/common/datatype.ts).
@@ -17,7 +16,7 @@ export function relationTypeFromTableSchema(tableSchema: TableSchema): RelationT
       name: col.name,
       type: {
 				typeClass: 'scalar',
-				affinity: col.affinity,
+				logicalType: col.logicalType,
 				collationName: col.collation,
 				nullable: !col.notNull,
 				isReadOnly: false,
@@ -53,18 +52,11 @@ export function relationTypeFromTableSchema(tableSchema: TableSchema): RelationT
  * @returns A ScalarType representing the inferred type of the value.
  */
 export function getParameterScalarType(value: SqlValue): ScalarType {
-  let affinity: SqlDataType;
-  if (value === null) affinity = SqlDataType.NULL;
-  else if (typeof value === 'number') affinity = SqlDataType.REAL;
-  else if (typeof value === 'bigint') affinity = SqlDataType.INTEGER;
-  else if (typeof value === 'string') affinity = SqlDataType.TEXT;
-  else if (value instanceof Uint8Array) affinity = SqlDataType.BLOB;
-  else if (typeof value === 'boolean') affinity = SqlDataType.INTEGER; // Store booleans as INTEGER
-  else affinity = SqlDataType.BLOB; // Default for unknown types that might pass as SqlValue
+  const logicalType = inferLogicalTypeFromValue(value);
 
   return {
     typeClass: 'scalar',
-    affinity: affinity,
+    logicalType,
     nullable: true,	// No guarantees about the value, so it's nullable
     isReadOnly: true, // Parameters are read-only within the query execution context
   };
@@ -80,12 +72,12 @@ export function checkRelationsAssignable(source: RelationType, target: RelationT
 	return checkColumnsAssignable(source.columns, target.columns, astNode);
 }
 
-export function columnSchemaToDef(colName: string, colDef: ColumnSchema): { name: string; type: { typeClass: "scalar"; affinity: SqlDataType; collationName: string; nullable: boolean; isReadOnly: false; }; generated: boolean; } {
+export function columnSchemaToDef(colName: string, colDef: ColumnSchema): ColumnDef {
 	return {
 		name: colName,
 		type: {
 			typeClass: 'scalar',
-			affinity: colDef.affinity,
+			logicalType: colDef.logicalType,
 			collationName: colDef.collation,
 			nullable: !colDef.notNull,
 			isReadOnly: false,

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,13 +135,21 @@ 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;
@@ -145,6 +161,12 @@ 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;
@@ -155,6 +177,12 @@ 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;
@@ -165,6 +193,12 @@ 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;
@@ -177,6 +211,12 @@ 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);
@@ -189,13 +229,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;
 			};
 			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);

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