@quereus/quereus 0.5.1 → 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/set-operation.ts

@@ -3,6 +3,8 @@ import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
 import type { EmissionContext } from '../emission-context.js';
 import { emitPlanNode } from '../emitters.js';
 import type { Row } from '../../common/types.js';
+import { BTree } from 'inheritree';
+import { compareRows } from '../../util/comparison.js';
 
 export function emitSetOperation(plan: SetOperationNode, ctx: EmissionContext): Instruction {
   const leftInst = emitPlanNode(plan.left, ctx);
@@ -30,58 +32,86 @@ export function emitSetOperation(plan: SetOperationNode, ctx: EmissionContext):
   }
 
   async function* runUnionDistinct(rctx: RuntimeContext, leftRows: AsyncIterable<Row>, rightRows: AsyncIterable<Row>): AsyncIterable<Row> {
-    const seen = new Set<string>();
-    const hash = (row: Row) => JSON.stringify(row);
+    // Use BTree for proper SQL value comparison instead of JSON.stringify
+    const distinctTree = new BTree<Row, Row>(
+      (row: Row) => row,
+      compareRows
+    );
+
     for await (const row of leftRows) {
       const outputRow = createOutputRow(row);
-      const h = hash(outputRow);
-      if (!seen.has(h)) {
-        seen.add(h);
+      const newPath = distinctTree.insert(outputRow);
+      if (newPath.on) {
+        // This is a new distinct row
         yield outputRow; // Let SortNode handle row context
       }
     }
     for await (const row of rightRows) {
       const outputRow = createOutputRow(row);
-      const h = hash(outputRow);
-      if (!seen.has(h)) {
-        seen.add(h);
+      const newPath = distinctTree.insert(outputRow);
+      if (newPath.on) {
+        // This is a new distinct row
         yield outputRow; // Let SortNode handle row context
       }
     }
   }
 
   async function* runIntersect(rctx: RuntimeContext, leftRows: AsyncIterable<Row>, rightRows: AsyncIterable<Row>): AsyncIterable<Row> {
-    const leftSet = new Set<string>();
-    const hash = (row: Row) => JSON.stringify(row);
-    const leftRowsArray: Row[] = [];
+    // Use BTree for proper SQL value comparison
+    const leftTree = new BTree<Row, Row>(
+      (row: Row) => row,
+      compareRows
+    );
+
+    // Build left set
     for await (const row of leftRows) {
       const outputRow = createOutputRow(row);
-      leftSet.add(hash(outputRow));
-      leftRowsArray.push(outputRow);
+      leftTree.insert(outputRow);
     }
+
+    // Check right rows against left set
+    const yielded = new BTree<Row, Row>(
+      (row: Row) => row,
+      compareRows
+    );
+
     for await (const row of rightRows) {
       const outputRow = createOutputRow(row);
-      const h = hash(outputRow);
-      if (leftSet.has(h)) {
-        yield outputRow; // Let SortNode handle row context
-        leftSet.delete(h);
+      const leftPath = leftTree.find(outputRow);
+      if (leftPath.on) {
+        // This row exists in left set - yield the LEFT row to preserve left-side types
+        const leftRow = leftTree.get(outputRow)!;
+        const yieldedPath = yielded.insert(leftRow);
+        if (yieldedPath.on) {
+          // Haven't yielded this row yet (handles duplicates in right)
+          yield leftRow; // Let SortNode handle row context
+        }
       }
     }
   }
 
   async function* runExcept(rctx: RuntimeContext, leftRows: AsyncIterable<Row>, rightRows: AsyncIterable<Row>): AsyncIterable<Row> {
-    const rightSet = new Set<string>();
-    const hash = (row: Row) => JSON.stringify(row);
+    // Use BTree for proper SQL value comparison
+    const rightTree = new BTree<Row, Row>(
+      (row: Row) => row,
+      compareRows
+    );
     const leftRowsArray: Row[] = [];
+
+    // Collect left rows
     for await (const row of leftRows) {
       leftRowsArray.push(createOutputRow(row));
     }
+
+    // Build right set
     for await (const row of rightRows) {
-      rightSet.add(hash(createOutputRow(row)));
+      rightTree.insert(createOutputRow(row));
     }
+
+    // Yield left rows that are not in right set
     for (const outputRow of leftRowsArray) {
-      const h = hash(outputRow);
-      if (!rightSet.has(h)) {
+      const rightPath = rightTree.find(outputRow);
+      if (!rightPath.on) {
         yield outputRow; // Let SortNode handle row context
       }
     }