@quereus/quereus 0.2.1 → 0.4.0

package/src/runtime/deferred-constraint-queue.ts

@@ -0,0 +1,196 @@
+import type { Row, SqlValue, OutputValue } from '../common/types.js';
+import type { RowDescriptor } from '../planner/nodes/plan-node.js';
+import type { RuntimeContext } from './types.js';
+import type { Database } from '../core/database.js';
+import { QuereusError } from '../common/errors.js';
+import { StatusCode } from '../common/types.js';
+import { createRowSlot } from './context-helpers.js';
+import type { VirtualTableConnection } from '../vtab/connection.js';
+
+export interface DeferredConstraintRow {
+	row: Row;
+	descriptor: RowDescriptor;
+	evaluator: (ctx: RuntimeContext) => OutputValue;
+	constraintName: string;
+	connectionId?: string;
+	contextRow?: Row; // Mutation context values
+	contextDescriptor?: RowDescriptor; // Mutation context row descriptor
+}
+
+type DeferredConstraintBuckets = Map<string, Map<string, DeferredConstraintRow[]>>;
+
+export class DeferredConstraintQueue {
+	private readonly entries: DeferredConstraintBuckets = new Map();
+	private layers: DeferredConstraintBuckets[] = [];
+
+	constructor(private readonly db: Database) { }
+
+	enqueue(baseTable: string, constraintName: string, row: Row, descriptor: RowDescriptor, evaluator: (ctx: RuntimeContext) => OutputValue, connectionId?: string, contextRow?: Row, contextDescriptor?: RowDescriptor): void {
+		const store = this.getActiveStore();
+		const tableKey = baseTable.toLowerCase();
+		if (!store.has(tableKey)) store.set(tableKey, new Map());
+		const constraints = store.get(tableKey)!;
+		if (!constraints.has(constraintName)) constraints.set(constraintName, []);
+		constraints.get(constraintName)!.push({
+			row: row.slice() as Row,
+			descriptor,
+			evaluator,
+			constraintName,
+			connectionId,
+			contextRow: contextRow ? contextRow.slice() as Row : undefined,
+			contextDescriptor
+		});
+	}
+
+	beginLayer(): void {
+		this.layers.push(new Map());
+	}
+
+	rollbackLayer(): void {
+		this.layers.pop();
+	}
+
+	releaseLayer(): void {
+		const top = this.layers.pop();
+		if (!top) return;
+		const target = this.getActiveStore();
+		this.merge(target, top);
+	}
+
+	clear(): void {
+		this.entries.clear();
+		this.layers = [];
+	}
+
+	async runDeferredRows(): Promise<void> {
+		if (!this.hasPending()) return;
+		const activeConnections = this.db.getAllConnections();
+		const runtimeCtx: RuntimeContext = {
+			db: this.db,
+			stmt: undefined,
+			params: {},
+			context: new Map(),
+			tableContexts: new Map(),
+			tracer: this.db.getInstructionTracer(),
+			enableMetrics: this.db.options.getBooleanOption('runtime_stats'),
+		};
+		const store = this.cloneAll();
+		for (const [table, constraints] of store) {
+			for (const [_, rows] of constraints) {
+				for (const entry of rows) {
+					const connection = this.findConnection(activeConnections, table, entry.connectionId);
+					runtimeCtx.activeConnection = connection;
+					await this.evaluateEntry(runtimeCtx, entry);
+				}
+			}
+		}
+		this.clear();
+	}
+
+	private async evaluateEntry(runtimeCtx: RuntimeContext, entry: DeferredConstraintRow): Promise<void> {
+		// Compose context row with the flat row if context is present
+		const evaluationRow = entry.contextRow ? [...entry.contextRow, ...entry.row] : entry.row;
+		const evaluationDescriptor = entry.contextRow && entry.contextDescriptor
+			? this.composeCombinedDescriptor(entry.contextDescriptor, entry.descriptor)
+			: entry.descriptor;
+
+
+		const slot = createRowSlot(runtimeCtx, evaluationDescriptor);
+		try {
+			slot.set(evaluationRow);
+			const value = await entry.evaluator(runtimeCtx) as SqlValue;
+			if (value === false || value === 0) {
+				throw new QuereusError(`CHECK constraint failed: ${entry.constraintName}`, StatusCode.CONSTRAINT);
+			}
+		} finally {
+			slot.close();
+		}
+	}
+
+	private composeCombinedDescriptor(contextDescriptor: RowDescriptor, flatRowDescriptor: RowDescriptor): RowDescriptor {
+		const combined: RowDescriptor = [];
+		const contextLength = Object.keys(contextDescriptor).filter(k => contextDescriptor[parseInt(k)] !== undefined).length;
+
+		// Copy context descriptor as-is (indices 0..contextLength-1)
+		for (const attrIdStr in contextDescriptor) {
+			const attrId = parseInt(attrIdStr);
+			if (contextDescriptor[attrId] !== undefined) {
+				combined[attrId] = contextDescriptor[attrId];
+			}
+		}
+
+		// Copy flat descriptor with offset indices (indices contextLength..end)
+		for (const attrIdStr in flatRowDescriptor) {
+			const attrId = parseInt(attrIdStr);
+			if (flatRowDescriptor[attrId] !== undefined) {
+				combined[attrId] = flatRowDescriptor[attrId] + contextLength;
+			}
+		}
+
+		return combined;
+	}
+
+	private getActiveStore(): DeferredConstraintBuckets {
+		return this.layers.length > 0 ? this.layers[this.layers.length - 1] : this.entries;
+	}
+
+	private hasPending(): boolean {
+		if (this.entries.size > 0) return true;
+		return this.layers.some(layer => layer.size > 0);
+	}
+
+	private cloneAll(): DeferredConstraintBuckets {
+		const clone: DeferredConstraintBuckets = new Map();
+		const append = (source: DeferredConstraintBuckets) => {
+			for (const [table, constraints] of source) {
+				const lowerTable = table.toLowerCase();
+				if (!clone.has(lowerTable)) clone.set(lowerTable, new Map());
+				const targetConstraints = clone.get(lowerTable)!;
+				for (const [constraintName, rows] of constraints) {
+					if (!targetConstraints.has(constraintName)) targetConstraints.set(constraintName, []);
+					targetConstraints.get(constraintName)!.push(...rows.map(entry => ({
+						row: entry.row.slice() as Row,
+						descriptor: entry.descriptor,
+						evaluator: entry.evaluator,
+						constraintName: entry.constraintName,
+						connectionId: entry.connectionId,
+						contextRow: entry.contextRow ? entry.contextRow.slice() as Row : undefined,
+						contextDescriptor: entry.contextDescriptor,
+					})));
+				}
+			}
+		};
+
+		append(this.entries);
+		for (const layer of this.layers) append(layer);
+		return clone;
+	}
+
+	private merge(target: DeferredConstraintBuckets, source: DeferredConstraintBuckets): void {
+		for (const [table, constraints] of source) {
+			const lowerTable = table.toLowerCase();
+			if (!target.has(lowerTable)) target.set(lowerTable, new Map());
+			const destConstraints = target.get(lowerTable)!;
+			for (const [constraintName, rows] of constraints) {
+				if (!destConstraints.has(constraintName)) destConstraints.set(constraintName, []);
+				destConstraints.get(constraintName)!.push(...rows);
+			}
+		}
+	}
+
+	private findConnection(connections: VirtualTableConnection[], tableKey: string, preferredId?: string): VirtualTableConnection | undefined {
+		if (preferredId) {
+			const direct = connections.find(conn => conn.connectionId === preferredId);
+			if (direct) {
+				return direct;
+			}
+		}
+		const normalized = tableKey.toLowerCase();
+		const simple = normalized.includes('.') ? normalized.substring(normalized.lastIndexOf('.') + 1) : normalized;
+		return connections.find(conn => {
+			const connName = conn.tableName.toLowerCase();
+			return connName === normalized || connName === simple;
+		});
+	}
+}
+

package/src/runtime/emission-context.ts

@@ -2,7 +2,7 @@ import type { Database } from '../core/database.js';
 import type { SchemaManager } from '../schema/manager.js';
 import type { TableSchema } from '../schema/table.js';
 import type { FunctionSchema } from '../schema/function.js';
-import type { VirtualTableModule } from '../vtab/module.js';
+import type { AnyVirtualTableModule } from '../vtab/module.js';
 import { createLogger } from '../common/logger.js';
 import { QuereusError } from '../common/errors.js';
 import { StatusCode } from '../common/types.js';
@@ -89,6 +89,8 @@ export class DependencyTracker {
 	}
 }
 
+type SchemaObject = TableSchema | FunctionSchema | { module: AnyVirtualTableModule, auxData?: unknown } | CollationFunction;
+
 /**
  * Context provided to emitters during plan emission.
  * Allows schema lookups and tracks dependencies for plan invalidation.
@@ -97,13 +99,17 @@ export class DependencyTracker {
 export class EmissionContext {
 	private readonly schemaManager: SchemaManager;
 	private readonly dependencyTracker = new DependencyTracker();
-	private readonly schemaSnapshot = new Map<string, any>();
+	/** Schema snapshot for table/view references during emission */
+	private readonly schemaSnapshot = new Map<string, SchemaObject>();
 	public readonly tracePlanStack: boolean;
 
 	constructor(
 		public readonly db: Database,
 	) {
-		this.tracePlanStack = !!db.getOption('trace_plan_stack').value;
+		const option = db.getOption('trace_plan_stack');
+		this.tracePlanStack = typeof option === 'object' && option !== null && 'value' in option
+			? Boolean((option as { value: unknown }).value)
+			: Boolean(option);
 		this.schemaManager = db.schemaManager;
 	}
 
@@ -148,7 +154,7 @@ export class EmissionContext {
 	 * Looks up a virtual table module and records the dependency.
 	 * Also captures the module reference for runtime use.
 	 */
-	getVtabModule(moduleName: string): { module: VirtualTableModule<any, any>, auxData?: unknown } | undefined {
+	getVtabModule(moduleName: string): { module: AnyVirtualTableModule, auxData?: unknown } | undefined {
 		const moduleInfo = this.schemaManager.getModule(moduleName);
 		if (moduleInfo) {
 			const key = `vtab_module:${moduleName}`;
@@ -222,7 +228,7 @@ export class EmissionContext {
 	 * This allows runtime instructions to use the schema objects that were
 	 * captured at emission time, providing consistency even if the schema changes.
 	 */
-	getCapturedSchemaObject<T = any>(key: string): T | undefined {
+	getCapturedSchemaObject<T = SchemaObject>(key: string): T | undefined {
 		return this.schemaSnapshot.get(key) as T | undefined;
 	}
 

package/src/runtime/emit/add-constraint.ts

@@ -4,7 +4,7 @@ import type { EmissionContext } from '../emission-context.js';
 import { QuereusError } from '../../common/errors.js';
 import { SqlValue, StatusCode } from '../../common/types.js';
 import { createLogger } from '../../common/logger.js';
-import type { RowConstraintSchema } from '../../schema/table.js';
+import type { RowConstraintSchema, TableSchema } from '../../schema/table.js';
 import { opsToMask } from '../../schema/table.js';
 
 const log = createLogger('runtime:emit:add-constraint');
@@ -12,7 +12,7 @@ const log = createLogger('runtime:emit:add-constraint');
 export function emitAddConstraint(plan: AddConstraintNode, _ctx: EmissionContext): Instruction {
 	const tableSchema = plan.table.tableSchema;
 
-	async function run(_rctx: RuntimeContext): Promise<SqlValue> {
+	async function run(rctx: RuntimeContext): Promise<SqlValue> {
 		// Convert the AST constraint to a schema constraint object
 		const constraint = plan.constraint;
 
@@ -35,13 +35,34 @@ export function emitAddConstraint(plan: AddConstraintNode, _ctx: EmissionContext
 			name: constraint.name || `check_${tableSchema.checkConstraints.length}`,
 			expr: constraint.expr,
 			operations: opsToMask(constraint.operations), // Convert operations array to bitmask
+			deferrable: constraint.deferrable ?? false,
+			initiallyDeferred: constraint.initiallyDeferred,
 		};
 
-		// Add the constraint to the table schema by creating a new frozen array
+		// Create a new table schema with the additional constraint (honor immutability)
 		const updatedConstraints = [...tableSchema.checkConstraints, constraintSchema];
-		(tableSchema as any).checkConstraints = Object.freeze(updatedConstraints);
+		const updatedTableSchema: TableSchema = {
+			...tableSchema,
+			checkConstraints: Object.freeze(updatedConstraints),
+		};
+
+		// Replace the table schema in the database
+		const schemaManager = rctx.db.schemaManager;
+		const schema = schemaManager.getSchemaOrFail(tableSchema.schemaName);
+
+		// Replace the table schema (addTable overwrites existing)
+		schema.addTable(updatedTableSchema);
+
+		// Notify schema change listeners that the table was modified
+		schemaManager.getChangeNotifier().notifyChange({
+			type: 'table_modified',
+			schemaName: tableSchema.schemaName,
+			objectName: tableSchema.name,
+			oldObject: tableSchema,
+			newObject: updatedTableSchema
+		});
 
-		log('Added constraint %s to table %s', constraintSchema.name, tableSchema.name);
+		log('Added constraint %s to table %s.%s', constraintSchema.name, tableSchema.schemaName, tableSchema.name);
 
 		return null;
 	}

package/src/runtime/emit/aggregate.ts

@@ -1,5 +1,5 @@
 import type { StreamAggregateNode } from '../../planner/nodes/stream-aggregate.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
 import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
 import { type SqlValue, type Row, type MaybePromise } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
@@ -7,6 +7,7 @@ import type { FunctionSchema } from '../../schema/function.js';
 import { isAggregateFunctionSchema } from '../../schema/function.js';
 import { AggregateFunctionCallNode } from '../../planner/nodes/aggregate-function.js';
 import type { PlanNode, RowDescriptor } from '../../planner/nodes/plan-node.js';
+import { isRelationalNode } from '../../planner/nodes/plan-node.js';
 import { compareSqlValues } from '../../util/comparison.js';
 import { BTree } from 'inheritree';
 import { createLogger } from '../../common/logger.js';
@@ -15,6 +16,7 @@ import { coerceForAggregate } from '../../util/coercion.js';
 import { quereusError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
 import { buildRowDescriptor } from '../../util/row-descriptor.js';
+import { AggValue } from '../../func/registration.js';
 
 export const ctxLog = createLogger('runtime:context');
 
@@ -83,14 +85,14 @@ export function emitStreamAggregate(plan: StreamAggregateNode, ctx: EmissionCont
 	// Create separate descriptors for group yielding to avoid conflicts with source row processing
 	const groupSourceRowDescriptor = buildRowDescriptor(sourceAttributes);
 	const groupSourceRelationRowDescriptor = sourceRelation !== plan.source
-		? buildRowDescriptor((sourceRelation as any).getAttributes?.() || sourceAttributes)
+		? buildRowDescriptor(isRelationalNode(sourceRelation) ? sourceRelation.getAttributes() : sourceAttributes)
 		: groupSourceRowDescriptor;
 
 	ctxLog('StreamAggregate setup: source=%s, sourceRelation=%s', plan.source.nodeType, sourceRelation.nodeType);
 	ctxLog('Source attributes: %O', sourceAttributes.map(attr => `${attr.name}(#${attr.id})`));
 	if (sourceRelation !== plan.source) {
-		const sourceRelationAttributes = (sourceRelation as any).getAttributes?.() || sourceAttributes;
-		ctxLog('Source relation attributes: %O', sourceRelationAttributes.map((attr: any) => `${attr.name}(#${attr.id})`));
+		const sourceRelationAttributes = isRelationalNode(sourceRelation) ? sourceRelation.getAttributes() : sourceAttributes;
+		ctxLog('Source relation attributes: %O', sourceRelationAttributes.map((attr) => `${attr.name}(#${attr.id})`));
 	}
 
 	// Create output row descriptor for the StreamAggregate's output
@@ -164,7 +166,7 @@ export function emitStreamAggregate(plan: StreamAggregateNode, ctx: EmissionCont
 		// Handle the case with no GROUP BY - aggregate everything into a single group
 		if (plan.groupBy.length === 0) {
 			// Initialize accumulators for each aggregate
-			const accumulators: any[] = aggregateSchemas.map(schema => {
+			const accumulators: SqlValue[] = aggregateSchemas.map(schema => {
 				// Get fresh initial value - if it's a function, call it; if it's an object/array, copy it
 				const initialValue = isAggregateFunctionSchema(schema) ? schema.initialValue : undefined;
 				if (typeof initialValue === 'function') {
@@ -287,7 +289,7 @@ export function emitStreamAggregate(plan: StreamAggregateNode, ctx: EmissionCont
 			let currentGroupKey: SqlValue[] | null = null;
 			let currentGroupValues: SqlValue[] = [];
 			let currentSourceRow: Row | null = null; // Track the current group's representative row
-			let currentAccumulators: any[] = [];
+			let currentAccumulators: AggValue[] = [];
 			let currentDistinctTrees: BTree<SqlValue | SqlValue[], SqlValue | SqlValue[]>[] = [];
 			let cleanupPreviousGroupContext: (() => void) | null = null;
 
@@ -573,7 +575,7 @@ export function emitStreamAggregate(plan: StreamAggregateNode, ctx: EmissionCont
 
 	return {
 		params: [sourceInstruction, ...groupByInstructions, ...aggregateArgInstructions],
-		run: run as any,
+		run: run as InstructionRun,
 		note: `stream_aggregate(${plan.groupBy.length > 0 ? `GROUP BY ${plan.groupBy.length}` : 'no grouping'}, ${plan.aggregates.length} aggs)`
 	};
 }

package/src/runtime/emit/array-index.ts

@@ -2,10 +2,10 @@ import type { ArrayIndexNode } from '../../planner/nodes/array-index-node.js';
 import type { Instruction, RuntimeContext } from '../types.js';
 import type { EmissionContext } from '../emission-context.js';
 import { quereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
+import { StatusCode, type OutputValue } from '../../common/types.js';
 
 export function emitArrayIndex(plan: ArrayIndexNode, _ctx: EmissionContext): Instruction {
-	function run(ctx: RuntimeContext): any {
+	function run(ctx: RuntimeContext): OutputValue {
 		// Look through the context to find a row that has the index we need
 		for (const [_descriptor, rowGetter] of ctx.context.entries()) {
 			const row = rowGetter();

package/src/runtime/emit/binary.ts

@@ -41,21 +41,39 @@ export function emitBinaryOp(plan: BinaryOpNode, ctx: EmissionContext): Instruct
 }
 
 export function emitNumericOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	let inner: (v1: any, v2: any) => any;
+	let inner: (v1: number, v2: number) => number;
+	let innerBigInt: (v1: bigint, v2: bigint) => bigint;
+
 	switch (plan.expression.operator) {
-		case '+': inner = (v1, v2) => v1 + v2; break;
-		case '-': inner = (v1, v2) => v1 - v2; break;
-		case '*': inner = (v1, v2) => v1 * v2; break;
-		case '/': inner = (v1, v2) => v1 / v2; break;
-		case '%': inner = (v1, v2) => v1 % v2; break;
-		default: throw new QuereusError(`Unsupported numeric operator: ${plan.expression.operator}`, StatusCode.UNSUPPORTED);
+		case '+':
+			inner = (v1, v2) => v1 + v2;
+			innerBigInt = (v1, v2) => v1 + v2;
+			break;
+		case '-':
+			inner = (v1, v2) => v1 - v2;
+			innerBigInt = (v1, v2) => v1 - v2;
+			break;
+		case '*':
+			inner = (v1, v2) => v1 * v2;
+			innerBigInt = (v1, v2) => v1 * v2;
+			break;
+		case '/':
+			inner = (v1, v2) => v1 / v2;
+			innerBigInt = (v1, v2) => v1 / v2;
+			break;
+		case '%':
+			inner = (v1, v2) => v1 % v2;
+			innerBigInt = (v1, v2) => v1 % v2;
+			break;
+		default:
+			throw new QuereusError(`Unsupported numeric operator: ${plan.expression.operator}`, StatusCode.UNSUPPORTED);
 	}
 
 	function run(ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue {
 		if (v1 !== null && v2 !== null) {
 			if (typeof v1 === 'bigint' || typeof v2 === 'bigint') {
 				try {
-					return inner(BigInt(v1 as any), BigInt(v2 as any));
+					return innerBigInt(v1 as bigint, v2 as bigint);
 				} catch {
 					return null;
 				}

package/src/runtime/emit/cache.ts

@@ -1,5 +1,5 @@
 import type { CacheNode } from '../../planner/nodes/cache-node.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
 import type { Row } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
 import { emitCallFromPlan } from '../emitters.js';
@@ -58,7 +58,7 @@ export function emitCache(plan: CacheNode, ctx: EmissionContext): Instruction {
 
 	return {
 		params: [sourceInstruction],
-		run,
+		run: run as InstructionRun,
 		note: `cache(${plan.strategy}, threshold=${plan.threshold})`
 	};
 }

package/src/runtime/emit/cast.ts

@@ -1,5 +1,5 @@
 import type { CastNode } from '../../planner/nodes/scalar.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
 import { emitPlanNode } from '../emitters.js';
 import { type SqlValue } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
@@ -63,7 +63,7 @@ export function emitCast(plan: CastNode, ctx: EmissionContext): Instruction {
 
 	return {
 		params: [emitPlanNode(plan.operand, ctx)],
-		run: run as any,
+		run: run as InstructionRun,
 		note: `cast(${plan.expression.targetType})`
 	};
 }