@quereus/quereus 0.4.6 → 0.4.8

package/src/schema/manager.ts

@@ -368,23 +368,23 @@ export class SchemaManager {
 
 		let destroyPromise: Promise<void> | null = null;
 
-		// Call xDestroy on the module, providing table details
+		// Call destroy on the module, providing table details
 		if (tableSchema.vtabModuleName) { // tableSchema is guaranteed to be defined here
 			const moduleRegistration = this.getModule(tableSchema.vtabModuleName);
-			if (moduleRegistration && moduleRegistration.module && moduleRegistration.module.xDestroy) {
-				log(`Calling xDestroy for VTab %s.%s via module %s`, schemaName, tableName, tableSchema.vtabModuleName);
-				destroyPromise = moduleRegistration.module.xDestroy(
+			if (moduleRegistration && moduleRegistration.module && moduleRegistration.module.destroy) {
+				log(`Calling destroy for VTab %s.%s via module %s`, schemaName, tableName, tableSchema.vtabModuleName);
+				destroyPromise = moduleRegistration.module.destroy(
 					this.db,
 					moduleRegistration.auxData,
 					tableSchema.vtabModuleName,
 					schemaName,
 					tableName
 				).catch(err => {
-					errorLog(`Error during VTab module xDestroy for %s.%s: %O`, schemaName, tableName, err);
-					// Potentially re-throw or handle as a critical error if xDestroy failure is problematic
+					errorLog(`Error during VTab module destroy for %s.%s: %O`, schemaName, tableName, err);
+					// Potentially re-throw or handle as a critical error if destroy failure is problematic
 				});
 			} else {
-				warnLog(`VTab module %s (for table %s.%s) or its xDestroy method not found during dropTable.`, tableSchema.vtabModuleName, schemaName, tableName);
+				warnLog(`VTab module %s (for table %s.%s) or its destroy method not found during dropTable.`, tableSchema.vtabModuleName, schemaName, tableName);
 			}
 		}
 
@@ -408,7 +408,7 @@ export class SchemaManager {
 
 		// Process destruction asynchronously
 		if (destroyPromise) {
-			void destroyPromise.then(() => log(`xDestroy completed for VTab %s.%s`, schemaName, tableName));
+			void destroyPromise.then(() => log(`destroy completed for VTab %s.%s`, schemaName, tableName));
 		}
 
 		return removed; // True if removed from schema, false if not found and ifExists was true.
@@ -469,11 +469,11 @@ export class SchemaManager {
 
 	/**
 	 * Creates a new index on an existing table based on an AST.CreateIndexStmt.
-	 * This method validates the index definition and calls the virtual table's xCreateIndex method.
+	 * This method validates the index definition and calls the virtual table's createIndex method.
 	 *
 	 * @param stmt The AST node for the CREATE INDEX statement.
 	 * @returns A Promise that resolves when the index is created.
-	 * @throws QuereusError on errors (e.g., table not found, column not found, xCreateIndex fails).
+	 * @throws QuereusError on errors (e.g., table not found, column not found, createIndex fails).
 	 */
 	async createIndex(stmt: AST.CreateIndexStmt): Promise<void> {
 		const targetSchemaName = stmt.table.schema || this.getCurrentSchemaName();
@@ -486,8 +486,8 @@ export class SchemaManager {
 			throw new QuereusError(`no such table: ${tableName}`, StatusCode.ERROR, undefined, stmt.table.loc?.start.line, stmt.table.loc?.start.column);
 		}
 
-		// Check if the virtual table module supports xCreateIndex
-		if (!tableSchema.vtabModule.xCreateIndex) {
+		// Check if the virtual table module supports createIndex
+		if (!tableSchema.vtabModule.createIndex) {
 			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);
 		}
 
@@ -531,8 +531,8 @@ export class SchemaManager {
 		};
 
 		try {
-			// Call xCreateIndex on the virtual table module
-			await tableSchema.vtabModule.xCreateIndex(
+			// Call createIndex on the virtual table module
+			await tableSchema.vtabModule.createIndex(
 				this.db,
 				targetSchemaName,
 				tableName,
@@ -563,18 +563,18 @@ export class SchemaManager {
 		} 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);
+			throw new QuereusError(`createIndex failed for index '${indexName}' on table '${tableName}': ${message}`, code, e instanceof Error ? e : undefined, stmt.loc?.start.line, stmt.loc?.start.column);
 		}
 	}
 
 	/**
 	 * Defines a new table in the schema based on an AST.CreateTableStmt.
-	 * This method encapsulates the logic for interacting with VTab modules (xCreate)
+	 * This method encapsulates the logic for interacting with VTab modules (create)
 	 * and registering the new table schema.
 	 *
 	 * @param stmt The AST node for the CREATE TABLE statement.
 	 * @returns A Promise that resolves to the created TableSchema.
-	 * @throws QuereusError on errors (e.g., module not found, xCreate fails, table exists).
+	 * @throws QuereusError on errors (e.g., module not found, create fails, table exists).
 	 */
 	async createTable(stmt: AST.CreateTableStmt): Promise<TableSchema> {
 		const targetSchemaName = stmt.table.schema || this.getCurrentSchemaName();
@@ -670,14 +670,14 @@ export class SchemaManager {
 
 		let tableInstance: VirtualTable;
 		try {
-			tableInstance = moduleInfo.module.xCreate(
+			tableInstance = moduleInfo.module.create(
 				this.db,
 				baseTableSchema
 			);
 		} 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);
+			throw new QuereusError(`Module '${moduleName}' create failed for table '${tableName}': ${message}`, code, e instanceof Error ? e : undefined, stmt.loc?.start.line, stmt.loc?.start.column);
 		}
 
 		const schema = this.getSchema(targetSchemaName);
@@ -687,7 +687,7 @@ export class SchemaManager {
 
 		const finalRegisteredSchema = tableInstance.tableSchema;
 		if (!finalRegisteredSchema) {
-			throw new QuereusError(`Module '${moduleName}' xCreate did not provide a tableSchema for '${tableName}'.`, StatusCode.INTERNAL);
+			throw new QuereusError(`Module '${moduleName}' create did not provide a tableSchema for '${tableName}'.`, StatusCode.INTERNAL);
 		}
 
 		// Create a properly typed schema object instead of mutating properties

package/src/vtab/best-access-plan.ts

@@ -238,34 +238,4 @@ export function validateAccessPlan(
 	}
 }
 
-/**
- * Helper to convert old IndexConstraint to new PredicateConstraint
- * @deprecated Use direct PredicateConstraint construction instead
- */
-export function convertIndexConstraint(
-	constraint: any, // Old IndexConstraint type
-	value?: SqlValue
-): PredicateConstraint {
-	// Map old constraint operators to new ones
-	const opMap: Record<string, ConstraintOp> = {
-		'EQ': '=',
-		'GT': '>',
-		'GE': '>=',
-		'LT': '<',
-		'LE': '<=',
-		'MATCH': 'MATCH',
-		'LIKE': 'LIKE',
-		'GLOB': 'GLOB',
-		'ISNULL': 'IS NULL',
-		'ISNOTNULL': 'IS NOT NULL'
-	};
 
-	const op = opMap[constraint.op] || '=';
-
-	return {
-		columnIndex: constraint.iColumn,
-		op,
-		value,
-		usable: constraint.usable
-	};
-}

package/src/vtab/memory/module.ts

@@ -27,7 +27,7 @@ export class MemoryTableModule implements VirtualTableModule<MemoryTable, Memory
 	/**
 	 * Creates a new memory table definition
 	 */
-	xCreate(db: Database, tableSchema: TableSchema): MemoryTable {
+	create(db: Database, tableSchema: TableSchema): MemoryTable {
 		// Ensure table doesn't already exist
 		const tableKey = `${tableSchema.schemaName}.${tableSchema.name}`.toLowerCase();
 		if (this.tables.has(tableKey)) {
@@ -58,7 +58,7 @@ export class MemoryTableModule implements VirtualTableModule<MemoryTable, Memory
 	/**
 	 * Connects to an existing memory table definition
 	 */
-	xConnect(db: Database, pAux: unknown, moduleName: string, schemaName: string, tableName: string, _options: MemoryTableConfig): MemoryTable {
+	connect(db: Database, pAux: unknown, moduleName: string, schemaName: string, tableName: string, _options: MemoryTableConfig): MemoryTable {
 		const tableKey = `${schemaName}.${tableName}`.toLowerCase();
 		const existingManager = this.tables.get(tableKey);
 
@@ -305,20 +305,7 @@ export class MemoryTableModule implements VirtualTableModule<MemoryTable, Memory
 		return true;
 	}
 
-	/**
-	 * Determines the best query plan for executing a query against a memory table
-	 * @deprecated Use getBestAccessPlan instead for better type safety and extensibility
-	 */
-	xBestIndex(db: Database, tableInfo: TableSchema, indexInfo: IndexInfo): number {
-		const planningContext = this.createPlanningContext(tableInfo, indexInfo);
-		const availableIndexes = this.gatherAvailableIndexes(tableInfo);
-		const bestPlan = this.findBestPlan(planningContext, availableIndexes, indexInfo);
-		this.populateIndexInfoOutput(indexInfo, bestPlan, availableIndexes);
 
-		logger.debugLog(`[xBestIndex] Selected plan for ${tableInfo.name}: ${bestPlan.planType} on index ${bestPlan.indexId} (cost: ${bestPlan.cost})`);
-
-		return StatusCode.OK;
-	}
 
 	private createPlanningContext(_tableInfo: TableSchema, _indexInfo: IndexInfo) {
 		return {
@@ -644,7 +631,7 @@ export class MemoryTableModule implements VirtualTableModule<MemoryTable, Memory
 	/**
 	 * Destroys a memory table and frees associated resources
 	 */
-	async xDestroy(db: Database, pAux: unknown, moduleName: string, schemaName: string, tableName: string): Promise<void> {
+	async destroy(db: Database, pAux: unknown, moduleName: string, schemaName: string, tableName: string): Promise<void> {
 		const tableKey = `${schemaName}.${tableName}`.toLowerCase();
 		const manager = this.tables.get(tableKey);
 
@@ -659,7 +646,7 @@ export class MemoryTableModule implements VirtualTableModule<MemoryTable, Memory
 	/**
 	 * Creates an index on a memory table
 	 */
-	async xCreateIndex(db: Database, schemaName: string, tableName: string, indexSchema: IndexSchema): Promise<void> {
+	async createIndex(db: Database, schemaName: string, tableName: string, indexSchema: IndexSchema): Promise<void> {
 		const tableKey = `${schemaName}.${tableName}`.toLowerCase();
 		const manager = this.tables.get(tableKey);
 

package/src/vtab/memory/table.ts

@@ -30,7 +30,7 @@ export class MemoryTable extends VirtualTable {
 	private connection: MemoryTableConnection | null = null;
 
 	/**
-	 * @internal - Use MemoryTableModule.xConnect or xCreate
+	 * @internal - Use MemoryTableModule.connect or create
 	 * Creates a connection-specific instance linked to a manager.
 	 */
 	constructor(
@@ -101,29 +101,29 @@ export class MemoryTable extends VirtualTable {
 		return new MemoryVirtualTableConnection(this.tableName, this.connection);
 	}
 
-	// New xQuery method for direct async iteration
-	async* xQuery(filterInfo: FilterInfo): AsyncIterable<Row> {
+	// Direct async iteration for query execution
+	async* query(filterInfo: FilterInfo): AsyncIterable<Row> {
 		const conn = await this.ensureConnection();
-		logger.debugLog(`xQuery using connection ${conn.connectionId} (pending: ${conn.pendingTransactionLayer?.getLayerId()}, read: ${conn.readLayer.getLayerId()})`);
+		logger.debugLog(`query using connection ${conn.connectionId} (pending: ${conn.pendingTransactionLayer?.getLayerId()}, read: ${conn.readLayer.getLayerId()})`);
 		const currentSchema = this.manager.tableSchema;
 		if (!currentSchema) {
-			logger.error('xQuery', this.tableName, 'Table schema is undefined');
+			logger.error('query', this.tableName, 'Table schema is undefined');
 			return;
 		}
 		const plan = buildScanPlanFromFilterInfo(filterInfo, currentSchema);
-		logger.debugLog(`xQuery invoked for ${this.tableName} with plan: ${safeJsonStringify(plan)}`);
+		logger.debugLog(`query invoked for ${this.tableName} with plan: ${safeJsonStringify(plan)}`);
 
 		const startLayer = conn.pendingTransactionLayer ?? conn.readLayer;
-		logger.debugLog(`xQuery reading from layer ${startLayer.getLayerId()}`);
+		logger.debugLog(`query reading from layer ${startLayer.getLayerId()}`);
 
 		// Delegate scanning to the manager, which handles layer recursion
 		yield* this.manager.scanLayer(startLayer, plan);
 	}
 
-	// Note: xBestIndex is handled by the MemoryTableModule, not the table instance.
+	// Note: getBestAccessPlan is handled by the MemoryTableModule, not the table instance.
 
 	/** Performs mutation through the connection's transaction layer */
-	async xUpdate(
+	async update(
 		operation: 'insert' | 'update' | 'delete',
 		values: Row | undefined,
 		oldKeyValues?: Row,
@@ -136,12 +136,12 @@ export class MemoryTable extends VirtualTable {
 	}
 
 	/** Begins a transaction for this connection */
-	async xBegin(): Promise<void> {
+	async begin(): Promise<void> {
 		(await this.ensureConnection()).begin();
 	}
 
 	/** Commits this connection's transaction */
-	async xCommit(): Promise<void> {
+	async commit(): Promise<void> {
 		// Only commit if a connection has actually been established
 		if (this.connection) {
 			await this.connection.commit();
@@ -149,7 +149,7 @@ export class MemoryTable extends VirtualTable {
 	}
 
 	/** Rolls back this connection's transaction */
-	async xRollback(): Promise<void> {
+	async rollback(): Promise<void> {
 		// Only rollback if a connection has actually been established
 		if (this.connection) {
 			this.connection.rollback();
@@ -157,14 +157,14 @@ export class MemoryTable extends VirtualTable {
 	}
 
 	/** Sync operation (currently no-op for memory table layers) */
-	async xSync(): Promise<void> {
+	async sync(): Promise<void> {
 		// This might trigger background collapse in the manager in the future
 		// await this.manager.tryCollapseLayers(); // Optional: trigger collapse on sync?
 		return Promise.resolve();
 	}
 
 	/** Renames the underlying table via the manager */
-	async xRename(newName: string): Promise<void> {
+	async rename(newName: string): Promise<void> {
 		logger.operation('Rename', this.tableName, { newName });
 		await this.manager.renameTable(newName);
 		// Update this instance's schema reference after rename
@@ -172,17 +172,17 @@ export class MemoryTable extends VirtualTable {
 	}
 
 	// --- Savepoint operations ---
-	async xSavepoint(savepointIndex: number): Promise<void> {
+	async savepoint(savepointIndex: number): Promise<void> {
 		const conn = await this.ensureConnection();
 		conn.createSavepoint(savepointIndex);
 	}
 
-	async xRelease(savepointIndex: number): Promise<void> {
+	async release(savepointIndex: number): Promise<void> {
 		if (!this.connection) return; // No connection, no savepoints to release
 		this.connection.releaseSavepoint(savepointIndex);
 	}
 
-	async xRollbackTo(savepointIndex: number): Promise<void> {
+	async rollbackTo(savepointIndex: number): Promise<void> {
 		if (!this.connection) return; // No connection, no savepoints to rollback to
 		this.connection.rollbackToSavepoint(savepointIndex);
 	}
@@ -190,7 +190,7 @@ export class MemoryTable extends VirtualTable {
 
 
 	/** Handles schema changes via the manager */
-	async xAlterSchema(changeInfo: SchemaChangeInfo): Promise<void> {
+	async alterSchema(changeInfo: SchemaChangeInfo): Promise<void> {
 		const originalManagerSchema = this.manager.tableSchema; // For potential error recovery
 		try {
 			switch (changeInfo.type) {
@@ -226,7 +226,7 @@ export class MemoryTable extends VirtualTable {
 	}
 
 	/** Disconnects this connection instance from the manager */
-	async xDisconnect(): Promise<void> {
+	async disconnect(): Promise<void> {
 		if (this.connection) {
 			// Manager handles cleanup and potential layer collapse trigger
 			await this.manager.disconnect(this.connection.connectionId);
@@ -235,13 +235,13 @@ export class MemoryTable extends VirtualTable {
 	}
 
 	// --- Index DDL methods delegate to the manager ---
-	async xCreateIndex(indexSchema: IndexSchema): Promise<void> {
+	async createIndex(indexSchema: IndexSchema): Promise<void> {
 		logger.operation('Create Index', this.tableName, { indexName: indexSchema.name });
 		await this.manager.createIndex(indexSchema);
 		this.tableSchema = this.manager.tableSchema; // Refresh local schema ref
 	}
 
-	async xDropIndex(indexName: string): Promise<void> {
+	async dropIndex(indexName: string): Promise<void> {
 		logger.operation('Drop Index', this.tableName, { indexName });
 		await this.manager.dropIndex(indexName);
 		// Update schema reference

package/src/vtab/module.ts

@@ -7,7 +7,7 @@ import type { BestAccessPlanRequest, BestAccessPlanResult } from './best-access-
 import type { PlanNode } from '../planner/nodes/plan-node.js';
 
 /**
- * Base interface for module-specific configuration passed to xCreate/xConnect.
+ * Base interface for module-specific configuration passed to create/connect.
  * Modules should define their own interface extending this if they need options.
  */
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -45,7 +45,7 @@ export interface VirtualTableModule<
 	 * @returns The new VirtualTable instance
 	 * @throws QuereusError on failure
 	 */
-	xCreate(
+	create(
 		db: Database,
 		tableSchema: TableSchema,
 	): TTable;
@@ -63,7 +63,7 @@ export interface VirtualTableModule<
 	 * @returns The connection-specific VirtualTable instance
 	 * @throws QuereusError on failure
 	 */
-	xConnect(
+	connect(
 		db: Database,
 		pAux: unknown,
 		moduleName: string,
@@ -98,17 +98,7 @@ export interface VirtualTableModule<
 		request: BestAccessPlanRequest
 	): BestAccessPlanResult;
 
-	/**
-	 * Determines the best query plan for a given set of constraints and orderings.
-	 * This method MUST be synchronous for performance. It modifies the passed IndexInfo object.
-	 *
-	 * @deprecated Use getBestAccessPlan instead for better type safety and extensibility
-	 * @param db The database connection
-	 * @param tableInfo The schema information for the table being planned
-	 * @param indexInfo Input constraints/orderings and output plan details
-	 * @returns StatusCode.OK on success, or an error code
-	 */
-	xBestIndex(db: Database, tableInfo: TableSchema, indexInfo: IndexInfo): number;
+
 
 	/**
 	 * Destroys the underlying persistent representation of the virtual table.
@@ -121,7 +111,7 @@ export interface VirtualTableModule<
 	 * @param tableName The name of the virtual table being destroyed
 	 * @throws QuereusError on failure
 	 */
-	xDestroy(
+	destroy(
 		db: Database,
 		pAux: unknown,
 		moduleName: string,
@@ -139,7 +129,7 @@ export interface VirtualTableModule<
 	 * @param indexSchema The schema definition for the index being created
 	 * @throws QuereusError on failure
 	 */
-	xCreateIndex?(
+	createIndex?(
 		db: Database,
 		schemaName: string,
 		tableName: string,
@@ -151,7 +141,7 @@ export interface VirtualTableModule<
 	 * @param name The name to check
 	 * @returns true if the name would conflict
 	 */
-	xShadowName?(name: string): boolean;
+	shadowName?(name: string): boolean;
 }
 
 /**

package/src/vtab/table.ts

@@ -41,16 +41,16 @@ export abstract class VirtualTable {
 	 * Called when the database connection closes or the statement is finalized
 	 * @throws QuereusError on failure
 	 */
-	abstract xDisconnect(): Promise<void>;
+	abstract disconnect(): Promise<void>;
 
 	/**
 	 * (Optional) Opens a direct data stream for this virtual table based on filter criteria.
-	 * This is an alternative to the cursor-based xOpen/filter/next model.
-	 * @param filterInfo Information from xBestIndex and query parameters.
+	 * This is an alternative to the cursor-based open/filter/next model.
+	 * @param filterInfo Information from getBestAccessPlan and query parameters.
 	 * @returns An AsyncIterable yielding Row tuples.
 	 * @throws QuereusError on failure
 	 */
-	xQuery?(filterInfo: FilterInfo): AsyncIterable<Row>;
+	query?(filterInfo: FilterInfo): AsyncIterable<Row>;
 
 	/**
 	 * Executes a pushed-down plan subtree.
@@ -61,7 +61,7 @@ export abstract class VirtualTable {
 	 * @param ctx Optional context from supports() assessment
 	 * @returns Async iterable of rows resulting from the plan execution
 	 */
-	xExecutePlan?(
+	executePlan?(
 		db: Database,
 		plan: PlanNode,
 		ctx?: unknown
@@ -76,7 +76,7 @@ export abstract class VirtualTable {
 	 * @returns new row for INSERT/UPDATE, undefined for DELETE
 	 * @throws QuereusError or ConstraintError on failure
 	 */
-	abstract xUpdate(
+	abstract update(
 		operation: RowOp,
 		values: Row | undefined,
 		oldKeyValues?: Row,
@@ -100,63 +100,63 @@ export abstract class VirtualTable {
 	/**
 	 * Begins a transaction on this virtual table
 	 */
-	xBegin?(): Promise<void>;
+	begin?(): Promise<void>;
 
 	/**
 	 * Syncs changes within the virtual table transaction
 	 */
-	xSync?(): Promise<void>;
+	sync?(): Promise<void>;
 
 	/**
 	 * Commits the virtual table transaction
 	 */
-	xCommit?(): Promise<void>;
+	commit?(): Promise<void>;
 
 	/**
 	 * Rolls back the virtual table transaction
 	 */
-	xRollback?(): Promise<void>;
+	rollback?(): Promise<void>;
 
 	/**
 	 * Renames the virtual table
 	 * @param newName The new name for the table
 	 */
-	xRename?(newName: string): Promise<void>;
+	rename?(newName: string): Promise<void>;
 
 	/**
 	 * Begins a savepoint
 	 * @param savepointIndex The savepoint identifier
 	 */
-	xSavepoint?(savepointIndex: number): Promise<void>;
+	savepoint?(savepointIndex: number): Promise<void>;
 
 	/**
 	 * Releases a savepoint
 	 * @param savepointIndex The savepoint identifier
 	 */
-	xRelease?(savepointIndex: number): Promise<void>;
+	release?(savepointIndex: number): Promise<void>;
 
 	/**
 	 * Rolls back to a savepoint
 	 * @param savepointIndex The savepoint identifier
 	 */
-	xRollbackTo?(savepointIndex: number): Promise<void>;
+	rollbackTo?(savepointIndex: number): Promise<void>;
 
 	/**
 	 * Modifies the schema of this virtual table
 	 * @param changeInfo Object describing the schema modification
 	 * @throws QuereusError or ConstraintError on failure
 	 */
-	xAlterSchema?(changeInfo: SchemaChangeInfo): Promise<void>;
+	alterSchema?(changeInfo: SchemaChangeInfo): Promise<void>;
 
 	/**
 	 * Creates a secondary index on the virtual table
 	 * @param indexInfo The index definition
 	 */
-	xCreateIndex?(indexInfo: IndexSchema): Promise<void>;
+	createIndex?(indexInfo: IndexSchema): Promise<void>;
 
 	/**
 	 * Drops a secondary index from the virtual table
 	 * @param indexName The name of the index to drop
 	 */
-	xDropIndex?(indexName: string): Promise<void>;
+	dropIndex?(indexName: string): Promise<void>;
 }