@quereus/quereus 0.4.6 → 0.4.9

package/src/runtime/emit/dml-executor.ts

@@ -22,7 +22,7 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 		try {
 			for await (const flatRow of rows) {
 				const newRow = extractNewRowFromFlat(flatRow, tableSchema.columns.length);
-				await vtab.xUpdate!('insert', newRow, undefined, plan.onConflict ?? ConflictResolution.ABORT);
+				await vtab.update!('insert', newRow, undefined, plan.onConflict ?? ConflictResolution.ABORT);
 				// Track change (INSERT): record NEW primary key
 				const pkValues = tableSchema.primaryKeyDefinition.map(def => newRow[def.index]);
 				ctx.db._recordInsert(`${tableSchema.schemaName}.${tableSchema.name}`, pkValues);
@@ -48,7 +48,7 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 					}
 					return oldRow[pkColIdx];
 				});
-				await vtab.xUpdate!('update', newRow, keyValues, ConflictResolution.ABORT);
+				await vtab.update!('update', newRow, keyValues, ConflictResolution.ABORT);
 				// Track change (UPDATE): record OLD and NEW primary keys
 				const newKeyValues: SqlValue[] = tableSchema.primaryKeyDefinition.map(pkColDef => newRow[pkColDef.index]);
 				ctx.db._recordUpdate(`${tableSchema.schemaName}.${tableSchema.name}`, keyValues, newKeyValues);
@@ -72,7 +72,7 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 					}
 					return oldRow[pkColIdx];
 				});
-				await vtab.xUpdate!('delete', undefined, keyValues, ConflictResolution.ABORT);
+				await vtab.update!('delete', undefined, keyValues, ConflictResolution.ABORT);
 				// Track change (DELETE): record OLD primary key
 				ctx.db._recordDelete(`${tableSchema.schemaName}.${tableSchema.name}`, keyValues);
 				yield flatRow;

package/src/runtime/emit/remote-query.ts

@@ -8,7 +8,7 @@ import type { AnyVirtualTableModule } from '../../vtab/module.js';
 
 /**
  * Emitter for RemoteQueryNode.
- * Calls the virtual table's xExecutePlan() method to execute the pushed-down pipeline.
+ * Calls the virtual table's executePlan() method to execute the pushed-down pipeline.
  */
 export function emitRemoteQuery(plan: RemoteQueryNode, _ctx: EmissionContext): Instruction {
 	async function* run(rctx: RuntimeContext): AsyncIterable<Row> {
@@ -19,7 +19,7 @@ export function emitRemoteQuery(plan: RemoteQueryNode, _ctx: EmissionContext): I
 		const vtabModule = (moduleCtx as { vtabModule?: AnyVirtualTableModule } | undefined)?.vtabModule ?? tableRef.vtabModule;
 
 		// Connect to the table to get the instance
-		const table = vtabModule.xConnect(
+		const table = vtabModule.connect(
 			rctx.db,
 			undefined, // pAux
 			tableSchema.vtabModuleName,
@@ -28,15 +28,15 @@ export function emitRemoteQuery(plan: RemoteQueryNode, _ctx: EmissionContext): I
 			{} // empty config for now
 		);
 
-		if (!table.xExecutePlan) {
+		if (!table.executePlan) {
 			throw new QuereusError(
-				`Virtual table module for '${tableSchema.name}' does not implement xExecutePlan() ` +
+				`Virtual table module for '${tableSchema.name}' does not implement executePlan() ` +
 				`despite indicating support via supports() method.`,
 				StatusCode.INTERNAL
 			);
 		}
 
-		yield* table.xExecutePlan(rctx.db, plan.source, plan.moduleCtx);
+		yield* table.executePlan(rctx.db, plan.source, plan.moduleCtx);
 	}
 
 	return {

package/src/runtime/emit/scan.ts

@@ -38,14 +38,14 @@ export function emitSeqScan(plan: SeqScanNode | IndexScanNode | IndexSeekNode, c
 		}
 
 		const module = capturedModuleInfo.module;
-		if (typeof module.xConnect !== 'function') {
-			throw new QuereusError(`Virtual table module '${schema.vtabModuleName}' does not implement xConnect`, StatusCode.MISUSE);
+		if (typeof module.connect !== 'function') {
+			throw new QuereusError(`Virtual table module '${schema.vtabModuleName}' does not implement connect`, StatusCode.MISUSE);
 		}
 
 		let vtabInstance: VirtualTable;
     try {
       const options: BaseModuleConfig = (schema.vtabArgs ?? {}) as BaseModuleConfig;
-			vtabInstance = module.xConnect(
+			vtabInstance = module.connect(
 				runtimeCtx.db,
 				capturedModuleInfo.auxData,
 				schema.vtabModuleName,
@@ -55,13 +55,13 @@ export function emitSeqScan(plan: SeqScanNode | IndexScanNode | IndexSeekNode, c
 			);
 		} catch (e: any) {
 			const message = e instanceof Error ? e.message : String(e);
-			throw new QuereusError(`Module '${schema.vtabModuleName}' xConnect failed for table '${schema.name}': ${message}`, e instanceof QuereusError ? e.code : StatusCode.ERROR, e instanceof Error ? e : undefined);
+			throw new QuereusError(`Module '${schema.vtabModuleName}' connect failed for table '${schema.name}': ${message}`, e instanceof QuereusError ? e.code : StatusCode.ERROR, e instanceof Error ? e : undefined);
 		}
 
-		if (typeof vtabInstance.xQuery !== 'function') {
-			// Fallback or error if xQuery is not available. For now, throwing an error.
-			// Later, we could implement the xOpen/xFilter/xNext loop here as a fallback.
-			throw new QuereusError(`Virtual table '${schema.name}' does not support xQuery.`, StatusCode.UNSUPPORTED);
+		if (typeof vtabInstance.query !== 'function') {
+			// Fallback or error if query is not available. For now, throwing an error.
+			// Later, we could implement the open/filter/next loop here as a fallback.
+			throw new QuereusError(`Virtual table '${schema.name}' does not support query.`, StatusCode.UNSUPPORTED);
 		}
 
 		const rowSlot = createRowSlot(runtimeCtx, rowDescriptor);
@@ -74,14 +74,14 @@ export function emitSeqScan(plan: SeqScanNode | IndexScanNode | IndexSeekNode, c
         return plan.filterInfo;
       })();
 
-      const asyncRowIterable = vtabInstance.xQuery(effectiveFilterInfo);
+      const asyncRowIterable = vtabInstance.query(effectiveFilterInfo);
 			for await (const row of asyncRowIterable) {
 				rowSlot.set(row);
 				yield row;
 			}
 		} catch (e: any) {
 			const message = e instanceof Error ? e.message : String(e);
-			throw new QuereusError(`Error during xQuery on table '${schema.name}': ${message}`, e instanceof QuereusError ? e.code : StatusCode.ERROR, e instanceof Error ? e : undefined);
+			throw new QuereusError(`Error during query on table '${schema.name}': ${message}`, e instanceof QuereusError ? e.code : StatusCode.ERROR, e instanceof Error ? e : undefined);
 		} finally {
 			rowSlot.close();
 			// Properly disconnect the VirtualTable instance

package/src/runtime/emit/update.ts

@@ -51,7 +51,7 @@ export function emitUpdate(plan: UpdateNode, ctx: EmissionContext): Instruction
 
 			// Yield the flat row for constraint checking
 			// NOTE: UpdateNode only transforms rows - it does NOT execute the actual update
-			// The UpdateExecutorNode is responsible for calling vtab.xUpdate
+			// The UpdateExecutorNode is responsible for calling vtab.update
 			yield flatRow;
 		});
 	}

package/src/runtime/utils.ts

@@ -86,11 +86,11 @@ export async function getVTable(ctx: RuntimeContext, tableSchema: TableSchema):
 		throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' not found for table '${tableSchema.name}'`, StatusCode.ERROR);
 	}
 	const module = moduleInfo.module;
-	if (typeof module.xConnect !== 'function') {
-		throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' does not implement xConnect`, StatusCode.MISUSE);
+	if (typeof module.connect !== 'function') {
+		throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' does not implement connect`, StatusCode.MISUSE);
 	}
 	const vtabArgs = tableSchema.vtabArgs || {};
-	const vtabInstance = module.xConnect(ctx.db, moduleInfo.auxData, tableSchema.vtabModuleName, tableSchema.schemaName, tableSchema.name, vtabArgs);
+	const vtabInstance = module.connect(ctx.db, moduleInfo.auxData, tableSchema.vtabModuleName, tableSchema.schemaName, tableSchema.name, vtabArgs);
 
 	// If we have an active connection for this table, inject it into the VirtualTable
 	const tableName = tableSchema.name;
@@ -112,9 +112,9 @@ export async function getVTable(ctx: RuntimeContext, tableSchema: TableSchema):
  */
 export async function disconnectVTable(ctx: RuntimeContext, vtab: VirtualTable): Promise<void> {
 	// Disconnect the VirtualTable instance
-	if (typeof vtab.xDisconnect === 'function') {
-		await vtab.xDisconnect().catch((e: any) => {
-			errorLog(`Error during xDisconnect for table '${vtab.tableName}': ${e}`);
+	if (typeof vtab.disconnect === 'function') {
+		await vtab.disconnect().catch((e: any) => {
+			errorLog(`Error during disconnect for table '${vtab.tableName}': ${e}`);
 		});
 	}
 }

package/src/schema/catalog.ts

@@ -2,7 +2,7 @@ import type { Database } from '../core/database.js';
 import type { TableSchema } from './table.js';
 import type { ViewSchema } from './view.js';
 import type { IntegrityAssertionSchema } from './assertion.js';
-import { createTableToString } from '../util/ast-stringify.js';
+import { createTableToString, createViewToString } from '../util/ast-stringify.js';
 import type * as AST from '../parser/ast.js';
 
 /**
@@ -196,9 +196,23 @@ export function generateDeclaredDDL(declaredSchema: AST.DeclareSchemaStmt, targe
 			case 'declaredIndex':
 				// TODO: Implement index DDL generation
 				break;
-			case 'declaredView':
-				// TODO: Implement view DDL generation
+			case 'declaredView': {
+				// Qualify view name with schema if specified
+				const viewStmt = item.viewStmt;
+				if (targetSchema && targetSchema !== 'main' && !viewStmt.view.schema) {
+					const qualifiedStmt: AST.CreateViewStmt = {
+						...viewStmt,
+						view: {
+							...viewStmt.view,
+							schema: targetSchema
+						}
+					};
+					ddlStatements.push(createViewToString(qualifiedStmt));
+				} else {
+					ddlStatements.push(createViewToString(viewStmt));
+				}
 				break;
+			}
 		}
 	}
 

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/schema/schema-differ.ts

@@ -1,6 +1,6 @@
 import type { SchemaCatalog } from './catalog.js';
 import type * as AST from '../parser/ast.js';
-import { createTableToString } from '../util/ast-stringify.js';
+import { createTableToString, createViewToString } from '../util/ast-stringify.js';
 
 /**
  * Represents the difference between a declared schema and actual database state
@@ -104,8 +104,8 @@ export function computeSchemaDiff(
 	// Find views to create/drop
 	for (const [name, declaredView] of declaredViews) {
 		if (!actualViews.has(name)) {
-			// TODO: Generate view DDL
-			diff.viewsToCreate.push(`CREATE VIEW "${declaredView.viewStmt.view.name}" AS SELECT 1`);
+			// Generate proper view DDL using AST stringifier
+			diff.viewsToCreate.push(createViewToString(declaredView.viewStmt));
 		}
 	}
 

package/src/util/ast-stringify.ts

@@ -629,7 +629,7 @@ function createIndexToString(stmt: AST.CreateIndexStmt): string {
 	return parts.join(' ');
 }
 
-function createViewToString(stmt: AST.CreateViewStmt): string {
+export function createViewToString(stmt: AST.CreateViewStmt): string {
 	const parts: string[] = ['create'];
 	if (stmt.isTemporary) parts.push('temp');
 	parts.push('view');

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;
 }
 
 /**