@quereus/quereus 0.4.11 → 0.5.1

package/src/vtab/memory/index.ts

@@ -1,178 +1,191 @@
-import { BTree } from 'inheritree';
-import { StatusCode, type Row, type SqlValue } from '../../common/types.js';
-import { compareSqlValues } from '../../util/comparison.js';
-import type { BTreeKeyForPrimary, BTreeKeyForIndex, MemoryIndexEntry } from './types.js';
-import type { IndexColumnSchema as IndexColumnSpec } from '../../schema/table.js'; // Renamed for clarity
-import type { ColumnSchema } from '../../schema/column.js';
-import { quereusError } from '../../common/errors.js';
-
-/** Definition for creating a memory index (matches IndexSchema columns usually) */
-export interface IndexSpec {
-	name?: string;
-	columns: ReadonlyArray<IndexColumnSpec>;
-}
-
-/** Functions for extracting and comparing index keys */
-interface IndexKeyFunctions {
-	keyFromRow: (row: Row) => BTreeKeyForIndex;
-	compareKeys: (a: BTreeKeyForIndex, b: BTreeKeyForIndex) => number;
-}
-
-/** Represents a secondary index within a MemoryTable */
-export class MemoryIndex {
-	public readonly name: string | undefined;
-	public readonly specColumns: ReadonlyArray<IndexColumnSpec>;
-	public readonly keyFromRow: (row: Row) => BTreeKeyForIndex;
-	public readonly compareKeys: (a: BTreeKeyForIndex, b: BTreeKeyForIndex) => number;
-	public data: BTree<BTreeKeyForIndex, MemoryIndexEntry>;
-
-	constructor(spec: IndexSpec, allTableColumnsSchema: ReadonlyArray<ColumnSchema>, baseInheritreeTable?: BTree<BTreeKeyForIndex, MemoryIndexEntry>) {
-		this.name = spec.name;
-		this.specColumns = Object.freeze(spec.columns.map(c => ({ ...c })));
-
-		this.validateColumnIndexes(allTableColumnsSchema);
-
-		const keyFunctions = this.createIndexKeyFunctions();
-		this.keyFromRow = keyFunctions.keyFromRow;
-		this.compareKeys = keyFunctions.compareKeys;
-
-		this.data = this.createBTree(baseInheritreeTable);
-	}
-
-	private validateColumnIndexes(allTableColumnsSchema: ReadonlyArray<ColumnSchema>): void {
-		const hasInvalidIndex = this.specColumns.some(sc =>
-			sc.index < 0 || sc.index >= allTableColumnsSchema.length
-		);
-
-		if (hasInvalidIndex) {
-			quereusError(`Invalid column index in index '${this.name ?? '(unnamed)'}'.`, StatusCode.INTERNAL);
-		}
-	}
-
-	private createIndexKeyFunctions(): IndexKeyFunctions {
-		if (this.specColumns.length === 1) {
-			return this.createSingleColumnKeyFunctions();
-		} else {
-			return this.createCompositeColumnKeyFunctions();
-		}
-	}
-
-	private createSingleColumnKeyFunctions(): IndexKeyFunctions {
-		const specCol = this.specColumns[0];
-		const colSchemaIndex = specCol.index;
-		const collation = specCol.collation || 'BINARY';
-		const descMultiplier = specCol.desc ? -1 : 1;
-
-		const keyFromRow = (row: Row): BTreeKeyForIndex => {
-			this.validateRowLength(row, colSchemaIndex);
-			return row[colSchemaIndex];
-		};
-
-		const compareKeys = (a: BTreeKeyForIndex, b: BTreeKeyForIndex): number => {
-			return compareSqlValues(a as SqlValue, b as SqlValue, collation) * descMultiplier;
-		};
-
-		return { keyFromRow, compareKeys };
-	}
-
-	private createCompositeColumnKeyFunctions(): IndexKeyFunctions {
-		const localSpecColumns = this.specColumns;
-
-		const keyFromRow = (row: Row): BTreeKeyForIndex => {
-			return localSpecColumns.map(sc => {
-				this.validateRowLength(row, sc.index);
-				return row[sc.index];
-			});
-		};
-
-		const compareKeys = (a: BTreeKeyForIndex, b: BTreeKeyForIndex): number => {
-			const arrA = a as SqlValue[];
-			const arrB = b as SqlValue[];
-
-			for (let i = 0; i < localSpecColumns.length; i++) {
-				if (i >= arrA.length || i >= arrB.length) {
-					return arrA.length - arrB.length;
-				}
-
-				const specCol = localSpecColumns[i];
-				const comparison = compareSqlValues(arrA[i], arrB[i], specCol.collation || 'BINARY');
-
-				if (comparison !== 0) {
-					return specCol.desc ? -comparison : comparison;
-				}
-			}
-			return 0;
-		};
-
-		return { keyFromRow, compareKeys };
-	}
-
-	private validateRowLength(row: Row, columnIndex: number): void {
-		if (columnIndex < 0 || columnIndex >= row.length) {
-			quereusError(`Index key col index ${columnIndex} OOB for row len ${row.length}`, StatusCode.INTERNAL);
-		}
-	}
-
-	private createBTree(baseInheritreeTable?: BTree<BTreeKeyForIndex, MemoryIndexEntry>): BTree<BTreeKeyForIndex, MemoryIndexEntry> {
-		return new BTree<BTreeKeyForIndex, MemoryIndexEntry>(
-			(entry: MemoryIndexEntry) => entry.indexKey,
-			this.compareKeys,
-			baseInheritreeTable
-		);
-	}
-
-	/** Adds a mapping from index key to primary key */
-	addEntry(indexKey: BTreeKeyForIndex, primaryKey: BTreeKeyForPrimary): void {
-		const path = this.data.find(indexKey);
-		if (path.on) {
-			// Entry exists, add to the existing set of primary keys
-			const existingEntry = this.data.at(path)!;
-			existingEntry.primaryKeys.add(primaryKey);
-		} else {
-			// Create new entry with a Set containing the primary key
-			const newEntry: MemoryIndexEntry = {
-				indexKey,
-				primaryKeys: new Set([primaryKey])
-			};
-			this.data.insert(newEntry);
-		}
-	}
-
-	/** Removes a mapping from index key to primary key */
-	removeEntry(indexKey: BTreeKeyForIndex, primaryKey: BTreeKeyForPrimary): void {
-		const path = this.data.find(indexKey);
-		if (path.on) {
-			const entry = this.data.at(path)!;
-			entry.primaryKeys.delete(primaryKey);
-
-			// If no primary keys remain, remove the entire entry
-			if (entry.primaryKeys.size === 0) {
-				this.data.deleteAt(path);
-			}
-		}
-	}
-
-	/** Returns the primary keys for a given index key */
-	getPrimaryKeys(indexKey: BTreeKeyForIndex): BTreeKeyForPrimary[] {
-		const entry = this.data.get(indexKey);
-		return entry ? Array.from(entry.primaryKeys) : [];
-	}
-
-	/** Gets the count of unique index values */
-	get size(): number {
-		return this.data.getCount();
-	}
-
-	/** Clears all entries from the index */
-	clear(): void {
-		const base = (this.data as any).baseTable as BTree<BTreeKeyForIndex, MemoryIndexEntry> | undefined;
-		this.data = this.createBTree(base);
-	}
-
-	/** Clears the base inheritance for this index (used during layer collapse) */
-	clearBase(): void {
-		if (typeof (this.data as any).clearBase === 'function') {
-			(this.data as any).clearBase();
-		}
-	}
-}
+import { BTree } from 'inheritree';
+import { StatusCode, type Row, type SqlValue } from '../../common/types.js';
+import { createTypedComparator, resolveCollation } from '../../util/comparison.js';
+import type { BTreeKeyForPrimary, BTreeKeyForIndex, MemoryIndexEntry } from './types.js';
+import type { IndexColumnSchema as IndexColumnSpec } from '../../schema/table.js'; // Renamed for clarity
+import type { ColumnSchema } from '../../schema/column.js';
+import { quereusError } from '../../common/errors.js';
+
+/** Definition for creating a memory index (matches IndexSchema columns usually) */
+export interface IndexSpec {
+	name?: string;
+	columns: ReadonlyArray<IndexColumnSpec>;
+}
+
+/** Functions for extracting and comparing index keys */
+interface IndexKeyFunctions {
+	keyFromRow: (row: Row) => BTreeKeyForIndex;
+	compareKeys: (a: BTreeKeyForIndex, b: BTreeKeyForIndex) => number;
+}
+
+/** Represents a secondary index within a MemoryTable */
+export class MemoryIndex {
+	public readonly name: string | undefined;
+	public readonly specColumns: ReadonlyArray<IndexColumnSpec>;
+	public readonly keyFromRow: (row: Row) => BTreeKeyForIndex;
+	public readonly compareKeys: (a: BTreeKeyForIndex, b: BTreeKeyForIndex) => number;
+	public data: BTree<BTreeKeyForIndex, MemoryIndexEntry>;
+	private readonly allTableColumnsSchema: ReadonlyArray<ColumnSchema>;
+
+	constructor(spec: IndexSpec, allTableColumnsSchema: ReadonlyArray<ColumnSchema>, baseInheritreeTable?: BTree<BTreeKeyForIndex, MemoryIndexEntry>) {
+		this.name = spec.name;
+		this.specColumns = Object.freeze(spec.columns.map(c => ({ ...c })));
+		this.allTableColumnsSchema = allTableColumnsSchema;
+
+		this.validateColumnIndexes(allTableColumnsSchema);
+
+		const keyFunctions = this.createIndexKeyFunctions();
+		this.keyFromRow = keyFunctions.keyFromRow;
+		this.compareKeys = keyFunctions.compareKeys;
+
+		this.data = this.createBTree(baseInheritreeTable);
+	}
+
+	private validateColumnIndexes(allTableColumnsSchema: ReadonlyArray<ColumnSchema>): void {
+		const hasInvalidIndex = this.specColumns.some(sc =>
+			sc.index < 0 || sc.index >= allTableColumnsSchema.length
+		);
+
+		if (hasInvalidIndex) {
+			quereusError(`Invalid column index in index '${this.name ?? '(unnamed)'}'.`, StatusCode.INTERNAL);
+		}
+	}
+
+	private createIndexKeyFunctions(): IndexKeyFunctions {
+		if (this.specColumns.length === 1) {
+			return this.createSingleColumnKeyFunctions();
+		} else {
+			return this.createCompositeColumnKeyFunctions();
+		}
+	}
+
+	private createSingleColumnKeyFunctions(): IndexKeyFunctions {
+		const specCol = this.specColumns[0];
+		const colSchemaIndex = specCol.index;
+		const columnSchema = this.allTableColumnsSchema[colSchemaIndex];
+		const descMultiplier = specCol.desc ? -1 : 1;
+
+		// Create type-aware comparator
+		const collationFunc = specCol.collation ? resolveCollation(specCol.collation) : undefined;
+		const typedComparator = createTypedComparator(columnSchema.logicalType, collationFunc);
+
+		const keyFromRow = (row: Row): BTreeKeyForIndex => {
+			this.validateRowLength(row, colSchemaIndex);
+			return row[colSchemaIndex];
+		};
+
+		const compareKeys = (a: BTreeKeyForIndex, b: BTreeKeyForIndex): number => {
+			return typedComparator(a as SqlValue, b as SqlValue) * descMultiplier;
+		};
+
+		return { keyFromRow, compareKeys };
+	}
+
+	private createCompositeColumnKeyFunctions(): IndexKeyFunctions {
+		const localSpecColumns = this.specColumns;
+
+		// Pre-create type-aware comparators for each column
+		const comparators = localSpecColumns.map(sc => {
+			const columnSchema = this.allTableColumnsSchema[sc.index];
+			const collationFunc = sc.collation ? resolveCollation(sc.collation) : undefined;
+			return createTypedComparator(columnSchema.logicalType, collationFunc);
+		});
+
+		const keyFromRow = (row: Row): BTreeKeyForIndex => {
+			return localSpecColumns.map(sc => {
+				this.validateRowLength(row, sc.index);
+				return row[sc.index];
+			});
+		};
+
+		const compareKeys = (a: BTreeKeyForIndex, b: BTreeKeyForIndex): number => {
+			const arrA = a as SqlValue[];
+			const arrB = b as SqlValue[];
+
+			for (let i = 0; i < localSpecColumns.length; i++) {
+				if (i >= arrA.length || i >= arrB.length) {
+					return arrA.length - arrB.length;
+				}
+
+				const specCol = localSpecColumns[i];
+				const comparison = comparators[i](arrA[i], arrB[i]);
+
+				if (comparison !== 0) {
+					return specCol.desc ? -comparison : comparison;
+				}
+			}
+			return 0;
+		};
+
+		return { keyFromRow, compareKeys };
+	}
+
+	private validateRowLength(row: Row, columnIndex: number): void {
+		if (columnIndex < 0 || columnIndex >= row.length) {
+			quereusError(`Index key col index ${columnIndex} OOB for row len ${row.length}`, StatusCode.INTERNAL);
+		}
+	}
+
+	private createBTree(baseInheritreeTable?: BTree<BTreeKeyForIndex, MemoryIndexEntry>): BTree<BTreeKeyForIndex, MemoryIndexEntry> {
+		return new BTree<BTreeKeyForIndex, MemoryIndexEntry>(
+			(entry: MemoryIndexEntry) => entry.indexKey,
+			this.compareKeys,
+			baseInheritreeTable
+		);
+	}
+
+	/** Adds a mapping from index key to primary key */
+	addEntry(indexKey: BTreeKeyForIndex, primaryKey: BTreeKeyForPrimary): void {
+		const path = this.data.find(indexKey);
+		if (path.on) {
+			// Entry exists, add to the existing set of primary keys
+			const existingEntry = this.data.at(path)!;
+			existingEntry.primaryKeys.add(primaryKey);
+		} else {
+			// Create new entry with a Set containing the primary key
+			const newEntry: MemoryIndexEntry = {
+				indexKey,
+				primaryKeys: new Set([primaryKey])
+			};
+			this.data.insert(newEntry);
+		}
+	}
+
+	/** Removes a mapping from index key to primary key */
+	removeEntry(indexKey: BTreeKeyForIndex, primaryKey: BTreeKeyForPrimary): void {
+		const path = this.data.find(indexKey);
+		if (path.on) {
+			const entry = this.data.at(path)!;
+			entry.primaryKeys.delete(primaryKey);
+
+			// If no primary keys remain, remove the entire entry
+			if (entry.primaryKeys.size === 0) {
+				this.data.deleteAt(path);
+			}
+		}
+	}
+
+	/** Returns the primary keys for a given index key */
+	getPrimaryKeys(indexKey: BTreeKeyForIndex): BTreeKeyForPrimary[] {
+		const entry = this.data.get(indexKey);
+		return entry ? Array.from(entry.primaryKeys) : [];
+	}
+
+	/** Gets the count of unique index values */
+	get size(): number {
+		return this.data.getCount();
+	}
+
+	/** Clears all entries from the index */
+	clear(): void {
+		const base = (this.data as any).baseTable as BTree<BTreeKeyForIndex, MemoryIndexEntry> | undefined;
+		this.data = this.createBTree(base);
+	}
+
+	/** Clears the base inheritance for this index (used during layer collapse) */
+	clearBase(): void {
+		if (typeof (this.data as any).clearBase === 'function') {
+			(this.data as any).clearBase();
+		}
+	}
+}

package/src/vtab/memory/layer/manager.ts

@@ -19,6 +19,7 @@ import { createPrimaryKeyFunctions, buildPrimaryKeyFromValues, type PrimaryKeyFu
 import { createMemoryTableLoggers } from '../utils/logging.js';
 import { getSyncLiteral } from '../../../parser/utils.js';
 import { createLogger } from '../../../common/logger.js';
+import { validateAndParse } from '../../../types/validation.js';
 
 let tableManagerCounter = 0;
 const logger = createMemoryTableLoggers('layer:manager');
@@ -420,7 +421,20 @@ export class MemoryTableManager {
 			throw new QuereusError("INSERT requires values.", StatusCode.MISUSE);
 		}
 
-		const newRowData: Row = values;
+		// Validate and parse values according to column types
+		const schema = targetLayer.getSchema();
+		const validatedRow: Row = values.map((value, index) => {
+			if (index >= schema.columns.length) {
+				throw new QuereusError(
+					`Too many values for INSERT into ${this._tableName}: expected ${schema.columns.length}, got ${values.length}`,
+					StatusCode.ERROR
+				);
+			}
+			const column = schema.columns[index];
+			return validateAndParse(value, column.logicalType, column.name);
+		});
+
+		const newRowData: Row = validatedRow;
 		const primaryKey = this.primaryKeyFromRow(newRowData);
 		const skipPkCheck = this.shouldSkipPkCheck(values);
 
@@ -448,8 +462,20 @@ export class MemoryTableManager {
 			throw new QuereusError("UPDATE requires new values and old key values.", StatusCode.MISUSE);
 		}
 
-		const newRowData: Row = values;
+		// Validate and parse values according to column types
 		const schema = targetLayer.getSchema();
+		const validatedRow: Row = values.map((value, index) => {
+			if (index >= schema.columns.length) {
+				throw new QuereusError(
+					`Too many values for UPDATE on ${this._tableName}: expected ${schema.columns.length}, got ${values.length}`,
+					StatusCode.ERROR
+				);
+			}
+			const column = schema.columns[index];
+			return validateAndParse(value, column.logicalType, column.name);
+		});
+
+		const newRowData: Row = validatedRow;
 		const targetPrimaryKey = buildPrimaryKeyFromValues(oldKeyValues, schema.primaryKeyDefinition);
 		const oldRowData = this.lookupEffectiveRow(targetPrimaryKey, targetLayer);
 

package/src/vtab/memory/utils/primary-key.ts

@@ -1,7 +1,7 @@
 import type { TableSchema, PrimaryKeyColumnDefinition } from '../../../schema/table.js';
 import type { Row, SqlValue } from '../../../common/types.js';
 import type { BTreeKeyForPrimary } from '../types.js';
-import { compareSqlValuesFast, resolveCollation, type CollationFunction } from '../../../util/comparison.js';
+import { compareSqlValuesFast, resolveCollation, type CollationFunction, createTypedComparator } from '../../../util/comparison.js';
 import { QuereusError } from '../../../common/errors.js';
 import { StatusCode } from '../../../common/types.js';
 
@@ -26,9 +26,9 @@ export function createPrimaryKeyFunctions(schema: TableSchema): PrimaryKeyFuncti
 	if (pkDefinition.length === 0) {
 		return createSingletonPrimaryKeyFunctions();
 	} else if (pkDefinition.length === 1) {
-		return createSingleColumnPrimaryKeyFunctions(pkDefinition[0]);
+		return createSingleColumnPrimaryKeyFunctions(pkDefinition[0], schema);
 	} else {
-		return createCompositeColumnPrimaryKeyFunctions(pkDefinition);
+		return createCompositeColumnPrimaryKeyFunctions(pkDefinition, schema);
 	}
 }
 
@@ -50,14 +50,16 @@ function createSingletonPrimaryKeyFunctions(): PrimaryKeyFunctions {
  * Creates functions for single-column primary keys (optimized path)
  */
 function createSingleColumnPrimaryKeyFunctions(
-	columnDef: PrimaryKeyColumnDefinition
+	columnDef: PrimaryKeyColumnDefinition,
+	schema: TableSchema
 ): PrimaryKeyFunctions {
 	const pkColIndex = columnDef.index;
-	const collation = columnDef.collation || 'BINARY';
 	const descMultiplier = columnDef.desc ? -1 : 1;
 
-	// Pre-resolve collation function for optimal performance
-	const collationFunc = resolveCollation(collation);
+	// Get the column's logical type and create type-aware comparator
+	const columnSchema = schema.columns[pkColIndex];
+	const collationFunc = columnDef.collation ? resolveCollation(columnDef.collation) : undefined;
+	const typedComparator = createTypedComparator(columnSchema.logicalType, collationFunc);
 
 	const extractFromRow = (row: Row): BTreeKeyForPrimary => {
 		if (!row || !Array.isArray(row)) {
@@ -76,7 +78,7 @@ function createSingleColumnPrimaryKeyFunctions(
 	};
 
 	const compare = (a: BTreeKeyForPrimary, b: BTreeKeyForPrimary): number => {
-		return compareSqlValuesFast(a as SqlValue, b as SqlValue, collationFunc) * descMultiplier;
+		return typedComparator(a as SqlValue, b as SqlValue) * descMultiplier;
 	};
 
 	return { extractFromRow, compare };
@@ -86,12 +88,15 @@ function createSingleColumnPrimaryKeyFunctions(
  * Creates functions for composite (multi-column) primary keys
  */
 function createCompositeColumnPrimaryKeyFunctions(
-	pkDefinition: ReadonlyArray<PrimaryKeyColumnDefinition>
+	pkDefinition: ReadonlyArray<PrimaryKeyColumnDefinition>,
+	schema: TableSchema
 ): PrimaryKeyFunctions {
-	// Pre-resolve all collation functions for optimal performance
-	const collationFuncs: CollationFunction[] = pkDefinition.map(def =>
-		resolveCollation(def.collation || 'BINARY')
-	);
+	// Pre-create type-aware comparators for each primary key column
+	const comparators = pkDefinition.map(def => {
+		const columnSchema = schema.columns[def.index];
+		const collationFunc = def.collation ? resolveCollation(def.collation) : undefined;
+		return createTypedComparator(columnSchema.logicalType, collationFunc);
+	});
 
 	const extractFromRow = (row: Row): BTreeKeyForPrimary => {
 		if (!row || !Array.isArray(row)) {
@@ -121,7 +126,7 @@ function createCompositeColumnPrimaryKeyFunctions(
 			}
 
 			const def = pkDefinition[i];
-			const comparison = compareSqlValuesFast(arrA[i], arrB[i], collationFuncs[i]);
+			const comparison = comparators[i](arrA[i], arrB[i]);
 
 			if (comparison !== 0) {
 				return def.desc ? -comparison : comparison;