@quereus/quereus 0.1.0 → 0.2.0

package/src/schema/manager.ts

@@ -473,7 +473,7 @@ export class SchemaManager {
 		}
 
 		// Check if the virtual table module supports xCreateIndex
-		if (typeof (tableSchema.vtabModule as any)?.xCreateIndex !== 'function') {
+		if (!tableSchema.vtabModule.xCreateIndex) {
 			throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' for table '${tableName}' does not support CREATE INDEX.`, StatusCode.ERROR, undefined, stmt.table.loc?.start.line, stmt.table.loc?.start.column);
 		}
 
@@ -518,19 +518,26 @@ export class SchemaManager {
 
 		try {
 			// Call xCreateIndex on the virtual table module
-			await tableSchema.vtabModule.xCreateIndex!(
+			await tableSchema.vtabModule.xCreateIndex(
 				this.db,
 				targetSchemaName,
 				tableName,
 				indexSchema
 			);
 
-			// Update the table schema with the new index
+			// Update the table schema with the new index by creating a new schema object
 			const updatedIndexes = [...(tableSchema.indexes || []), indexSchema];
-			(tableSchema as any).indexes = Object.freeze(updatedIndexes);
+			const updatedTableSchema: TableSchema = {
+				...tableSchema,
+				indexes: Object.freeze(updatedIndexes),
+			};
+
+			// Replace the table schema in the schema
+			const schema = this.getSchemaOrFail(targetSchemaName);
+			schema.addTable(updatedTableSchema);
 
 			log(`Successfully created index %s on table %s.%s`, indexName, targetSchemaName, tableName);
-		} catch (e: any) {
+		} catch (e: unknown) {
 			const message = e instanceof Error ? e.message : String(e);
 			const code = e instanceof QuereusError ? e.code : StatusCode.ERROR;
 			throw new QuereusError(`xCreateIndex failed for index '${indexName}' on table '${tableName}': ${message}`, code, e instanceof Error ? e : undefined, stmt.loc?.start.line, stmt.loc?.start.column);
@@ -634,7 +641,7 @@ export class SchemaManager {
 				this.db,
 				baseTableSchema
 			);
-		} catch (e: any) {
+		} catch (e: unknown) {
 			const message = e instanceof Error ? e.message : String(e);
 			const code = e instanceof QuereusError ? e.code : StatusCode.ERROR;
 			throw new QuereusError(`Module '${moduleName}' xCreate failed for table '${tableName}': ${message}`, code, e instanceof Error ? e : undefined, stmt.loc?.start.line, stmt.loc?.start.column);
@@ -650,20 +657,28 @@ export class SchemaManager {
 			throw new QuereusError(`Module '${moduleName}' xCreate did not provide a tableSchema for '${tableName}'.`, StatusCode.INTERNAL);
 		}
 
+		// Create a properly typed schema object instead of mutating properties
+		let correctedSchema = finalRegisteredSchema;
 		if (finalRegisteredSchema.name.toLowerCase() !== tableName.toLowerCase() ||
 			finalRegisteredSchema.schemaName.toLowerCase() !== targetSchemaName.toLowerCase()) {
-			warnLog(`Module ${moduleName} returned schema for ${finalRegisteredSchema.schemaName}.${finalRegisteredSchema.name} but expected ${targetSchemaName}.${tableName}. Overwriting name/schemaName.`);
-			(finalRegisteredSchema as any).name = tableName;
-			(finalRegisteredSchema as any).schemaName = targetSchemaName;
-		}
-		(finalRegisteredSchema as any).vtabModuleName = moduleName;
-		(finalRegisteredSchema as any).vtabArgs = effectiveModuleArgs;
-		(finalRegisteredSchema as any).vtabModule = moduleInfo.module;
-		(finalRegisteredSchema as any).vtabAuxData = moduleInfo.auxData;
-		if (finalRegisteredSchema.estimatedRows === undefined) {
-			(finalRegisteredSchema as any).estimatedRows = 0;
+			warnLog(`Module ${moduleName} returned schema for ${finalRegisteredSchema.schemaName}.${finalRegisteredSchema.name} but expected ${targetSchemaName}.${tableName}. Correcting name/schemaName.`);
+			correctedSchema = {
+				...finalRegisteredSchema,
+				name: tableName,
+				schemaName: targetSchemaName,
+			};
 		}
 
+		// Ensure all required properties are properly set
+		const completeTableSchema: TableSchema = {
+			...correctedSchema,
+			vtabModuleName: moduleName,
+			vtabArgs: effectiveModuleArgs,
+			vtabModule: moduleInfo.module,
+			vtabAuxData: moduleInfo.auxData,
+			estimatedRows: correctedSchema.estimatedRows ?? 0,
+		};
+
 		const existingTable = schema.getTable(tableName);
 		const existingView = schema.getView(tableName);
 
@@ -678,7 +693,7 @@ export class SchemaManager {
 			}
 		}
 
-		schema.addTable(finalRegisteredSchema);
+		schema.addTable(completeTableSchema);
 		log(`Successfully created table %s.%s using module %s`, targetSchemaName, tableName, moduleName);
 
 		// Notify schema change listeners
@@ -686,9 +701,9 @@ export class SchemaManager {
 			type: 'table_added',
 			schemaName: targetSchemaName,
 			objectName: tableName,
-			newObject: finalRegisteredSchema
+			newObject: completeTableSchema
 		});
 
-		return finalRegisteredSchema;
+		return completeTableSchema;
 	}
 }

package/src/util/plugin-loader.ts

@@ -1,7 +1,21 @@
 import type { Database } from '../core/database.js';
-import type { PluginManifest } from '../vtab/manifest.js';
+import type { PluginManifest, PluginRegistrations } from '../vtab/manifest.js';
 import { StatusCode, type SqlValue } from '../common/types.js';
 import { quereusError } from '../common/errors.js';
+import { createLogger } from '../common/logger.js';
+
+const log = createLogger('util:plugin-loader');
+
+/**
+ * Plugin module interface - what we expect from a plugin module
+ */
+export interface PluginModule {
+	/** Plugin manifest with metadata */
+	manifest?: PluginManifest;
+	
+	/** Default export - the plugin registration function */
+	default: (db: Database, config: Record<string, SqlValue>) => Promise<PluginRegistrations> | PluginRegistrations;
+}
 
 /**
  * Dynamically loads and registers a plugin module
@@ -24,7 +38,7 @@ export async function dynamicLoadModule(
 		}
 
 		// Dynamic import with Vite ignore comment for bundler compatibility
-		const mod = await import(/* @vite-ignore */ moduleUrl.toString());
+		const mod = await import(/* @vite-ignore */ moduleUrl.toString()) as PluginModule;
 
 		// Validate module structure
 		if (typeof mod.default !== 'function') {
@@ -32,16 +46,74 @@ export async function dynamicLoadModule(
 		}
 
 		// Call the module's register function with the database and config
-		await mod.default(db, config);
+		const registrations = await mod.default(db, config);
+
+		// Register all the items the plugin provides
+		await registerPluginItems(db, registrations);
+
+		log('Successfully loaded plugin from %s', url);
+		if (registrations.vtables?.length) {
+			log('  Registered %d vtable module(s): %s', registrations.vtables.length, 
+				registrations.vtables.map(v => v.name).join(', '));
+		}
+		if (registrations.functions?.length) {
+			log('  Registered %d function(s): %s', registrations.functions.length,
+				registrations.functions.map(f => `${f.schema.name}/${f.schema.numArgs}`).join(', '));
+		}
+		if (registrations.collations?.length) {
+			log('  Registered %d collation(s): %s', registrations.collations.length,
+				registrations.collations.map(c => c.name).join(', '));
+		}
 
 		// Return the manifest if available
-		return mod.manifest as PluginManifest | undefined;
+		return mod.manifest;
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		quereusError(`Failed to load plugin from ${url}: ${message}`);
 	}
 }
 
+/**
+ * Registers all items provided by a plugin
+ * 
+ * @param db Database instance to register with
+ * @param registrations The items to register
+ */
+async function registerPluginItems(db: Database, registrations: PluginRegistrations): Promise<void> {
+	// Register virtual table modules
+	if (registrations.vtables) {
+		for (const vtable of registrations.vtables) {
+			try {
+				db.registerVtabModule(vtable.name, vtable.module, vtable.auxData);
+			} catch (error) {
+				quereusError(`Failed to register vtable module '${vtable.name}': ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+
+	// Register functions
+	if (registrations.functions) {
+		for (const func of registrations.functions) {
+			try {
+				db.registerFunction(func.schema);
+			} catch (error) {
+				quereusError(`Failed to register function '${func.schema.name}/${func.schema.numArgs}': ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+
+	// Register collations
+	if (registrations.collations) {
+		for (const collation of registrations.collations) {
+			try {
+				db.registerCollation(collation.name, collation.func);
+			} catch (error) {
+				quereusError(`Failed to register collation '${collation.name}': ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+}
+
 /**
  * Validates that a URL is likely to be a valid plugin module
  *
@@ -67,3 +139,5 @@ export function validatePluginUrl(url: string): boolean {
 		return false;
 	}
 }
+
+

package/src/util/working-table-iterable.ts

@@ -1,6 +1,7 @@
 import type { Row } from '../common/types.js';
 import type { RuntimeContext } from '../runtime/types.js';
 import type { RowDescriptor } from '../planner/nodes/plan-node.js';
+import { withRowContextGenerator } from '../runtime/context-helpers.js';
 
 /**
  * A reusable async iterable for working table data that can be iterated multiple times.
@@ -16,15 +17,22 @@ export class WorkingTableIterable implements AsyncIterable<Row> {
 	) {}
 
 	async *[Symbol.asyncIterator](): AsyncIterator<Row> {
-		for (const row of this.rows) {
-			// Set up context for this row using the CTE row descriptor
-			this.rctx.context.set(this.rowDescriptor, () => row);
-			try {
+		// Convert rows array to async iterable
+		async function* rowsIterable(rows: Row[]): AsyncIterable<Row> {
+			for (const row of rows) {
 				yield row;
-			} finally {
-				// Clean up context
-				this.rctx.context.delete(this.rowDescriptor);
 			}
 		}
+
+		// Use the helper to manage context
+		yield* withRowContextGenerator(
+			this.rctx,
+			this.rowDescriptor,
+			rowsIterable(this.rows),
+			async function* (row) {
+				yield row;
+			}
+		);
 	}
 }
+

package/src/vtab/manifest.ts

@@ -1,4 +1,6 @@
 import type { SqlValue } from '../common/types.js';
+import type { FunctionSchema } from '../schema/function.js';
+import type { CollationFunction } from '../util/comparison.js';
 
 /**
  * Configuration setting definition for a plugin
@@ -12,6 +14,39 @@ export interface PluginSetting {
 	help?: string;
 }
 
+/**
+ * Virtual table module registration info
+ */
+export interface VTablePluginInfo {
+	name: string;                   // module name for registration
+	module: any;                   // the VirtualTableModule implementation
+	auxData?: unknown;             // optional auxiliary data
+}
+
+/**
+ * Function registration info
+ */
+export interface FunctionPluginInfo {
+	schema: FunctionSchema;        // complete function schema
+}
+
+/**
+ * Collation registration info
+ */
+export interface CollationPluginInfo {
+	name: string;                  // collation name
+	func: CollationFunction;       // comparison function
+}
+
+/**
+ * Plugin registration items - what the plugin wants to register
+ */
+export interface PluginRegistrations {
+	vtables?: VTablePluginInfo[];
+	functions?: FunctionPluginInfo[];
+	collations?: CollationPluginInfo[];
+}
+
 /**
  * Plugin manifest that describes the plugin's metadata and configuration options
  */
@@ -23,6 +58,13 @@ export interface PluginManifest {
 	pragmaPrefix?: string;          // default = name, used for PRAGMA commands
 	settings?: PluginSetting[];     // configuration options
 	capabilities?: string[];        // e.g. ['scan', 'index', 'write']
+	
+	// Plugin type indicators (for UI display)
+	provides?: {
+		vtables?: string[];         // names of vtable modules provided
+		functions?: string[];       // names of functions provided
+		collations?: string[];      // names of collations provided
+	};
 }
 
 /**

package/src/planner/nodes/scan.ts

@@ -1,103 +0,0 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type UnaryRelationalNode, type PhysicalProperties, type Attribute } from './plan-node.js';
-import { TableReferenceNode } from './reference.js';
-import type { RelationType } from '../../common/datatype.js';
-import type { Scope } from '../scopes/scope.js';
-import { Cached } from '../../util/cached.js';
-import type { FilterInfo } from '../../vtab/filter-info.js';
-import { quereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-
-/**
- * Represents a table scan operation (full or filtered).
- * This is a physical node that accesses actual table data.
- */
-export class TableScanNode extends PlanNode implements UnaryRelationalNode {
-	override readonly nodeType = PlanNodeType.TableScan;
-
-	private outputType: Cached<RelationType>;
-
-	constructor(
-		scope: Scope,
-		public readonly source: TableReferenceNode,
-		public readonly filterInfo: FilterInfo,
-		estimatedCostOverride?: number
-	) {
-		super(scope, estimatedCostOverride ?? filterInfo.indexInfoOutput.estimatedCost);
-
-		this.outputType = new Cached(() => this.source.getType());
-	}
-
-	getType(): RelationType {
-		return this.outputType.value;
-	}
-
-	getAttributes(): Attribute[] {
-		// Table scans produce the same attributes as their source table reference
-		return this.source.getAttributes();
-	}
-
-	getChildren(): readonly [TableReferenceNode] {
-		return [this.source];
-	}
-
-	getRelations(): readonly [TableReferenceNode] {
-		return [this.source];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 1) {
-			quereusError(`TableScanNode expects 1 child, got ${newChildren.length}`, StatusCode.INTERNAL);
-		}
-
-		const [newSource] = newChildren;
-
-		// Type check - TableScanNode specifically needs a TableReferenceNode
-		if (!(newSource instanceof TableReferenceNode)) {
-			quereusError('TableScanNode: child must be a TableReferenceNode', StatusCode.INTERNAL);
-		}
-
-		// Return same instance if nothing changed
-		if (newSource === this.source) {
-			return this;
-		}
-
-		// Create new instance preserving attributes (scan preserves table attributes)
-		return new TableScanNode(
-			this.scope,
-			newSource,
-			this.filterInfo
-		);
-	}
-
-	get estimatedRows(): number | undefined {
-		return Number(this.filterInfo.indexInfoOutput.estimatedRows);
-	}
-
-	override computePhysical(): Partial<PhysicalProperties> {
-		const tableType = this.source.getType();
-
-		return {
-			estimatedRows: this.estimatedRows,
-			// Table scans preserve the logical keys from the table schema
-			uniqueKeys: tableType.keys.map(key => key.map(colRef => colRef.index)),
-		};
-	}
-
-	override toString(): string {
-		return `SCAN ${this.source.tableSchema.name}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			table: this.source.tableSchema.name,
-			schema: this.source.tableSchema.schemaName,
-			filterInfo: {
-				usableIndex: this.filterInfo.indexInfoOutput.idxStr,
-				matchedClauses: this.filterInfo.indexInfoOutput.aConstraintUsage?.length || 0,
-				estimatedCost: this.filterInfo.indexInfoOutput.estimatedCost,
-				estimatedRows: this.filterInfo.indexInfoOutput.estimatedRows
-			}
-		};
-	}
-}

package/src/planner/rules/physical/rule-mark-physical.ts

@@ -1,37 +0,0 @@
-/**
- * Rule: Mark Physical (Fallback)
- *
- * Transforms: Any logical node → Same node (marked as physical)
- * Conditions: When no other rule has made the node physical
- * Benefits: Ensures all nodes become physical even if no specific transformation is needed
- */
-
-import { createLogger } from '../../../common/logger.js';
-import type { PlanNode } from '../../nodes/plan-node.js';
-import type { OptContext } from '../../framework/context.js';
-
-const log = createLogger('optimizer:rule:mark-physical');
-
-export function ruleMarkPhysical(node: PlanNode, _context: OptContext): PlanNode | null {
-	// This is a fallback rule - only apply if the node is not already physical
-	if (node.physical) {
-		return null; // Already physical
-	}
-
-	// Some node types cannot be made physical directly (like AggregateNode)
-	// These should have been handled by specific transformation rules
-	const cannotBePhysical = new Set([
-		'Aggregate', // Should be transformed to StreamAggregate/HashAggregate
-	]);
-
-	if (cannotBePhysical.has(node.nodeType)) {
-		log('Cannot mark %s as physical - requires transformation', node.nodeType);
-		return null; // Let the optimizer handle this as an error
-	}
-
-	log('Marking %s as physical (fallback rule)', node.nodeType);
-
-	// Return the node - framework will set physical properties via markPhysical()
-	// Don't hardcode properties, let the framework compute them from children
-	return node;
-}

package/src/runtime/emit/table-reference.ts

@@ -1,92 +0,0 @@
-import type { TableReferenceNode } from '../../planner/nodes/reference.js';
-import type { Instruction, RuntimeContext } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import type { Row } from '../../common/types.js';
-import { disconnectVTable } from '../utils.js';
-import { createValidatedInstruction } from '../emitters.js';
-import type { FilterInfo } from '../../vtab/filter-info.js';
-import type { IndexInfo, IndexConstraintUsage } from '../../vtab/index-info.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { buildRowDescriptor } from '../../util/row-descriptor.js';
-
-export function emitTableReference(plan: TableReferenceNode, ctx: EmissionContext): Instruction {
-	// Create row descriptor for output attributes
-	const rowDescriptor = buildRowDescriptor(plan.getAttributes());
-
-	async function* run(rctx: RuntimeContext): AsyncIterable<Row> {
-		// Get the table schema and pre-resolved vtab module
-		const tableSchema = plan.tableSchema;
-		const vtabModule = plan.vtabModule;
-		const vtabAuxData = plan.vtabAuxData;
-
-		// Create vtab instance using pre-resolved module
-		if (typeof vtabModule.xConnect !== 'function') {
-			throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' does not implement xConnect`, StatusCode.MISUSE);
-		}
-
-		const vtabArgs = tableSchema.vtabArgs || {};
-		const vtab = vtabModule.xConnect(
-			rctx.db,
-			vtabAuxData,
-			tableSchema.vtabModuleName,
-			tableSchema.schemaName,
-			tableSchema.name,
-			vtabArgs
-		);
-
-		try {
-			// Set up context for each row using row descriptor
-			let row: Row;
-			rctx.context.set(rowDescriptor, () => row);
-
-			// Check if the virtual table supports xQuery
-			if (typeof vtab.xQuery === 'function') {
-				// Create a minimal FilterInfo for full table scan
-				const defaultIndexInfo: IndexInfo = {
-					nConstraint: 0,
-					aConstraint: [],
-					nOrderBy: 0,
-					aOrderBy: [],
-					aConstraintUsage: [] as IndexConstraintUsage[],
-					idxNum: 0,
-					idxStr: 'fullscan',
-					orderByConsumed: false,
-					estimatedCost: 1000,
-					estimatedRows: BigInt(100),
-					idxFlags: 0,
-					colUsed: 0n,
-				};
-
-				const filterInfo: FilterInfo = {
-					idxNum: 0,
-					idxStr: 'fullscan',
-					constraints: [],
-					args: [],
-					indexInfoOutput: defaultIndexInfo,
-				};
-
-				// Use xQuery with the filter info
-				const asyncRowIterable = vtab.xQuery(filterInfo);
-				for await (row of asyncRowIterable) {
-					yield row;
-				}
-			} else {
-				throw new QuereusError(`Virtual table '${tableSchema.name}' does not support xQuery.`, StatusCode.UNSUPPORTED);
-			}
-
-			// Clean up context
-			rctx.context.delete(rowDescriptor);
-		} finally {
-			// Properly disconnect the VirtualTable instance
-			await disconnectVTable(rctx, vtab);
-		}
-	}
-
-	return createValidatedInstruction(
-		[],
-		run,
-		ctx,
-		`table_ref(${plan.tableSchema.schemaName}.${plan.tableSchema.name})`
-	);
-}