@quereus/quereus 0.7.3 → 0.7.5

package/src/runtime/emit/parameter.ts

@@ -1,59 +0,0 @@
-import type { ParameterReferenceNode } from '../../planner/nodes/reference.js';
-import type { Instruction, RuntimeContext } from '../types.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import type { SqlValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-
-export function emitParameterReference(plan: ParameterReferenceNode, _ctx: EmissionContext): Instruction {
-	function run(ctx: RuntimeContext): SqlValue {
-		const identifier = plan.nameOrIndex; // This comes from the ParameterReferenceNode instance
-
-		if (ctx.params === undefined) {
-			throw new QuereusError('Query executed with parameters, but no parameter values were provided.', StatusCode.MISUSE);
-		}
-
-		if (typeof identifier === 'number') {
-			// For ? (anonymous) parameters, identifier is a 1-based index.
-			// SqlParameters can be an array or an object.
-			if (Array.isArray(ctx.params)) {
-				if (identifier < 1 || identifier > ctx.params.length) {
-					throw new QuereusError(`Parameter index ${identifier} is out of bounds.`, StatusCode.RANGE);
-				}
-				return ctx.params[identifier - 1];
-			} else if (typeof ctx.params === 'object' && ctx.params !== null) {
-				// Support numbered parameters like :1, :2 in an object (e.g., { "1": value })
-				const key = String(identifier);
-				if (!(key in ctx.params)) {
-					throw new QuereusError(`Parameter with index ${identifier} not found in provided object.`, StatusCode.NOTFOUND);
-				}
-				return ctx.params[key as keyof typeof ctx.params];
-			} else {
-				throw new QuereusError('Parameters provided in an unsupported format for indexed access.', StatusCode.MISUSE);
-			}
-		} else if (typeof identifier === 'string') {
-			// For named parameters like :name.
-			if (Array.isArray(ctx.params)) {
-				throw new QuereusError('Named parameter found in query, but parameters provided as an array.', StatusCode.MISUSE);
-			}
-			if (typeof ctx.params === 'object' && ctx.params !== null) {
-				const key = identifier.startsWith(':') ? identifier.substring(1) : identifier;
-				if (!(key in ctx.params)) {
-					throw new QuereusError(`Parameter with name '${key}' not found.`, StatusCode.NOTFOUND);
-				}
-				return ctx.params[key as keyof typeof ctx.params];
-			} else {
-				throw new QuereusError('Parameters provided in an unsupported format for named access.', StatusCode.MISUSE);
-			}
-		} else {
-			// Should not happen given ParameterReferenceNode structure
-			throw new QuereusError('Invalid parameter identifier type.', StatusCode.INTERNAL);
-		}
-	}
-
-	return {
-		params: [],
-		run,
-		note: `param(${typeof plan.nameOrIndex === 'string' ? plan.nameOrIndex : '#' + plan.nameOrIndex})`
-	};
-}

package/src/runtime/emit/pragma.ts

@@ -1,56 +0,0 @@
-import type { EmissionContext } from '../emission-context.js';
-import type { PragmaPlanNode } from '../../planner/nodes/pragma.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import type { Row, SqlValue } from '../../common/types.js';
-import { createLogger } from '../../common/logger.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-
-const log = createLogger('runtime:emit:pragma');
-
-export function emitPragma(plan: PragmaPlanNode, _ctx: EmissionContext): Instruction {
-	const run = async function* (rctx: RuntimeContext): AsyncIterable<Row> {
-		const pragmaName = plan.pragmaName;
-		const value = plan.value;
-
-
-
-		if (value !== undefined) {
-			// Writing mode: set the pragma value
-			log(`PRAGMA ${pragmaName} = ${value}`);
-
-			// Try to set as a database option first
-			try {
-				rctx.db.setOption(pragmaName, value);
-				log(`Set option ${pragmaName} = ${value}`);
-			} catch {
-				// Treat unknown pragmas as no-ops for now, like SQLite often does
-				log(`Ignoring unrecognized PRAGMA: ${pragmaName}`);
-			}
-		} else {
-			// Reading mode: get the pragma value
-			log(`PRAGMA ${pragmaName} (reading)`);
-
-			try {
-				const currentValue = rctx.db.getOption(pragmaName) as SqlValue;
-				log(`Read option ${pragmaName} = ${currentValue}`);
-				// Return as a single-row result with the pragma name as column
-				yield [pragmaName, currentValue];
-			} catch (error) {
-				// If the pragma is unknown, return null or throw error depending on behavior needed
-				log(`Unknown PRAGMA: ${pragmaName}`);
-				throw new QuereusError(
-					`Unknown pragma: ${pragmaName}`,
-					StatusCode.ERROR,
-					error instanceof Error ? error : undefined
-				);
-			}
-		}
-	};
-
-	return {
-		params: [],
-		run: run as InstructionRun,
-		note: `PRAGMA ${plan.pragmaName}${plan.value !== undefined ? ` = ${plan.value}` : ''}`
-	};
-}

package/src/runtime/emit/project.ts

@@ -1,46 +0,0 @@
-import type { ProjectNode } from '../../planner/nodes/project-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
-import { type Row } from '../../common/types.js';
-import { type OutputValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { buildRowDescriptor } from '../../util/row-descriptor.js';
-import { withAsyncRowContext, withRowContextGenerator } from '../context-helpers.js';
-
-export function emitProject(plan: ProjectNode, ctx: EmissionContext): Instruction {
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-	const projectionFuncs = plan.projections.map((projection) => {
-		return emitCallFromPlan(projection.node, ctx);
-	});
-
-	// Row descriptors
-	const sourceRowDescriptor = buildRowDescriptor(plan.source.getAttributes());
-	const outputRowDescriptor = buildRowDescriptor(plan.getAttributes());
-
-	async function* run(rctx: RuntimeContext, source: AsyncIterable<Row>, ...projectionFunctions: Array<(ctx: RuntimeContext) => OutputValue>): AsyncIterable<Row> {
-		for await (const sourceRow of source) {
-			// Evaluate projections using the source row context
-			const outputs = await withAsyncRowContext(rctx, sourceRowDescriptor, () => sourceRow, async () => {
-				return Promise.all(projectionFunctions.map(fn => fn(rctx)));
-			});
-
-			// Push the output row descriptor for downstream consumers
-			yield* withRowContextGenerator(
-				rctx,
-				outputRowDescriptor,
-				(async function* () {
-					yield outputs as Row;
-				})(),
-				async function* (row) {
-					yield row;
-				}
-			);
-		}
-	}
-
-	return {
-		params: [sourceInstruction, ...projectionFuncs],
-		run: run as InstructionRun,
-		note: `project(${plan.projections.length} cols)`
-	};
-}

package/src/runtime/emit/recursive-cte.ts

@@ -1,111 +0,0 @@
-import type { RecursiveCTENode } from '../../planner/nodes/recursive-cte-node.js';
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { emitCallFromPlan, emitPlanNode } from '../emitters.js';
-import type { Row } from '../../common/types.js';
-import { createLogger } from '../../common/logger.js';
-import { BTree } from 'inheritree';
-import { compareRows } from '../../util/comparison.js';
-import { WorkingTableIterable } from '../../util/working-table-iterable.js';
-import { DEFAULT_TUNING } from '../../planner/optimizer-tuning.js';
-import { quereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { buildRowDescriptor } from '../../util/row-descriptor.js';
-import { withRowContext } from '../context-helpers.js';
-
-const log = createLogger('runtime:emit:recursive-cte');
-
-export function emitRecursiveCTE(plan: RecursiveCTENode, ctx: EmissionContext): Instruction {
-	// Create row descriptor for CTE output attributes
-	const rowDescriptor = buildRowDescriptor(plan.getAttributes());
-
-	// Use the plan's table descriptor for table context coordination
-	const { tableDescriptor } = plan;
-
-	async function* run(rctx: RuntimeContext, baseCaseResult: AsyncIterable<Row>, recursiveCaseCallback: (ctx: RuntimeContext) => AsyncIterable<Row>): AsyncIterable<Row> {
-		log('Starting recursive CTE execution for %s (union=%s, algorithm=semi-naive)', plan.cteName, plan.isUnionAll ? 'ALL' : 'DISTINCT');
-
-		// Get configuration - use plan node limit if specified, otherwise use default tuning
-		const maxIterations = plan.maxRecursion ?? DEFAULT_TUNING.recursiveCte.maxIterations;
-
-		// Step 1: Initialize deduplication storage (for UNION DISTINCT) and delta tracking
-		const allRowsTree = plan.isUnionAll ? null : new BTree<Row, Row>(
-			(row: Row) => row, // Identity function - use row as its own key
-			compareRows
-		);
-		let deltaRows: Row[] = [];
-
-		// Step 2: Execute base case and populate initial delta
-		// Stream base case results immediately while building delta for next iteration
-		for await (const row of baseCaseResult) {
-			// Yield if we're union all or if the row is new
-			const shouldYield = !allRowsTree || allRowsTree.insert(row).on;
-
-			if (shouldYield) {
-				// Yield immediately (streaming)
-				yield withRowContext(rctx, rowDescriptor, () => row, () => row);
-
-				// Add to delta for recursive processing (deep copy to avoid reference issues)
-				deltaRows.push([...row] as Row);
-			}
-		}
-
-		// Step 3: Semi-naïve iterative recursive execution
-		let iterationCount = 0;
-
-		while (deltaRows.length > 0 && (maxIterations === 0 || iterationCount < maxIterations)) {
-			++iterationCount;
-			log('Recursive CTE %s iteration %d, delta size: %d', plan.cteName, iterationCount, deltaRows.length);
-
-			// Create a working table iterable from ONLY the delta (not all accumulated rows)
-			const deltaIterable = new WorkingTableIterable([...deltaRows], rctx, rowDescriptor);
-			const newDeltaRows: Row[] = []; // Collect rows for next iteration
-
-			// Set up the delta table in context for CTE references to access
-			rctx.tableContexts.set(tableDescriptor, () => deltaIterable);
-			try {
-				// Execute recursive case using the callback - it only sees the delta
-				for await (const row of recursiveCaseCallback(rctx)) {
-					// For UNION DISTINCT: check if row is new; for UNION ALL: accept all rows
-					const shouldYield = !allRowsTree || allRowsTree.insert(row).on;
-
-					if (shouldYield) {
-						// Stream the row immediately
-						yield withRowContext(rctx, rowDescriptor, () => row, () => row);
-
-						// Add to next iteration's delta (deep copy to avoid reference issues)
-						newDeltaRows.push([...row] as Row);
-					}
-				}
-			} finally {
-				rctx.tableContexts.delete(tableDescriptor);
-			}
-
-			// Update delta for next iteration - only new rows, not accumulated result
-			deltaRows = newDeltaRows;
-		}
-
-		// Safety check for infinite recursion
-		if (iterationCount >= maxIterations) {
-			quereusError(
-				`Recursive CTE '${plan.cteName}' exceeded maximum iteration limit (${maxIterations})`,
-				StatusCode.ERROR
-			);
-		}
-
-		log('Recursive CTE %s completed after %d iterations (semi-naive algorithm)', plan.cteName, iterationCount);
-	}
-
-	// Emit both base case and recursive case instructions
-	const baseCaseInstruction = emitPlanNode(plan.baseCaseQuery, ctx);
-	const recursiveCaseInstruction = emitCallFromPlan(plan.recursiveCaseQuery, ctx);
-
-	return {
-		params: [baseCaseInstruction, recursiveCaseInstruction],
-		run: run as InstructionRun,
-		note: `recursiveCTE(${plan.cteName})`
-	};
-}
-
-
-

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

@@ -1,47 +0,0 @@
-import type { Instruction, RuntimeContext } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import type { Row } from '../../common/types.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import type { RemoteQueryNode } from '../../planner/nodes/remote-query-node.js';
-import type { AnyVirtualTableModule } from '../../vtab/module.js';
-
-/**
- * Emitter for RemoteQueryNode.
- * 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> {
-		// Retrieve virtual table connection via module context
-		const { tableRef, moduleCtx } = plan;
-		// Get the table instance - need to resolve this from the table reference
-		const tableSchema = tableRef.tableSchema;
-		const vtabModule = (moduleCtx as { vtabModule?: AnyVirtualTableModule } | undefined)?.vtabModule ?? tableRef.vtabModule;
-
-		// Connect to the table to get the instance
-		const table = vtabModule.connect(
-			rctx.db,
-			undefined, // pAux
-			tableSchema.vtabModuleName,
-			tableSchema.schemaName,
-			tableSchema.name,
-			{} // empty config for now
-		);
-
-		if (!table.executePlan) {
-			throw new QuereusError(
-				`Virtual table module for '${tableSchema.name}' does not implement executePlan() ` +
-				`despite indicating support via supports() method.`,
-				StatusCode.INTERNAL
-			);
-		}
-
-		yield* table.executePlan(rctx.db, plan.source, plan.moduleCtx);
-	}
-
-	return {
-		params: [],
-		run,
-		note: `remoteQuery(${plan.tableRef.tableSchema.name})`
-	};
-}

package/src/runtime/emit/retrieve.ts

@@ -1,15 +0,0 @@
-import type { RetrieveNode } from '../../planner/nodes/retrieve-node.js';
-import type { Instruction } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-
-export function emitRetrieve(plan: RetrieveNode, _ctx: EmissionContext): Instruction {
-	// RetrieveNode should always be rewritten by the optimizer's access path selection rule
-	// If we reach this point, it means the optimizer failed to convert it to a physical node
-	throw new QuereusError(
-		`RetrieveNode for table '${plan.tableRef.tableSchema.name}' was not rewritten to a physical access node. ` +
-		`This indicates the virtual table module has no supported access method (neither supports() nor getBestAccessPlan()).`,
-		StatusCode.INTERNAL
-	);
-}

package/src/runtime/emit/returning.ts

@@ -1,41 +0,0 @@
-import type { ReturningNode } from '../../planner/nodes/returning-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import type { Row, OutputValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
-import { buildRowDescriptor } from '../../util/row-descriptor.js';
-import { withRowContextGenerator } from '../context-helpers.js';
-
-export function emitReturning(plan: ReturningNode, ctx: EmissionContext): Instruction {
-	// Use the executor's attributes to build the row descriptor
-	// The executor should already output the correct flat OLD/NEW format for mutation operations
-	const sourceRowDescriptor = buildRowDescriptor(plan.executor.getAttributes());
-
-	// Pre-emit the projection expressions
-	const projectionEvaluators = plan.projections.map(proj =>
-		emitCallFromPlan(proj.node, ctx)
-	);
-
-	async function* run(
-		rctx: RuntimeContext,
-		executorRows: AsyncIterable<Row>,
-		...projectionCallbacks: Array<(ctx: RuntimeContext) => OutputValue>
-	): AsyncIterable<Row> {
-		// Project the results from the executor rows
-		yield* withRowContextGenerator(rctx, sourceRowDescriptor, executorRows, async function* (_sourceRow) {
-			// Evaluate projection expressions in the context of this row
-			const outputs = projectionCallbacks.map(func => func(rctx));
-			const resolved = await Promise.all(outputs);
-			yield resolved as Row;
-		});
-	}
-
-	// Emit the executor (now always produces rows)
-	const executorInstruction = emitPlanNode(plan.executor, ctx);
-
-	return {
-		params: [executorInstruction, ...projectionEvaluators],
-		run: run as InstructionRun,
-		note: `returning(${plan.projections.length} cols)`
-	};
-}

package/src/runtime/emit/scalar-function.ts

@@ -1,69 +0,0 @@
-import type { ScalarFunctionCallNode } from '../../planner/nodes/function.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { emitPlanNode, createValidatedInstruction } from '../emitters.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode, type SqlValue, type OutputValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import type { ScalarFunctionSchema } from '../../schema/function.js';
-import { isScalarFunctionSchema } from '../../schema/function.js';
-
-/**
- * Default emission logic for scalar function calls.
- * This is exported so custom emitters can call it if needed.
- */
-export function emitScalarFunctionCallDefault(plan: ScalarFunctionCallNode, ctx: EmissionContext): Instruction {
-	const functionName = plan.expression.name.toLowerCase();
-	const functionSchema = plan.functionSchema;
-
-	// Validate that it's a scalar function
-	if (!isScalarFunctionSchema(functionSchema)) {
-		throw new QuereusError(`Function ${functionName} is not a scalar function`, StatusCode.ERROR);
-	}
-
-	function run(_rctx: RuntimeContext, ...args: Array<SqlValue>): OutputValue {
-		// Use the pre-resolved function schema from the plan node
-		const scalarFunction = functionSchema as ScalarFunctionSchema;
-
-		// Validate argument count
-		if (scalarFunction.numArgs >= 0 && args.length !== scalarFunction.numArgs) {
-			throw new QuereusError(`Function ${functionName} called with ${args.length} arguments, expected ${scalarFunction.numArgs}`, StatusCode.ERROR);
-		}
-
-		try {
-			return scalarFunction.implementation(...args);
-		} catch (error: any) {
-			throw new QuereusError(`Function ${functionName} failed: ${error.message}`, StatusCode.ERROR, error, plan.expression.loc?.start.line, plan.expression.loc?.start.column);
-		}
-	}
-
-	const operandExprs = plan.operands.map(operand => emitPlanNode(operand, ctx));
-
-	return createValidatedInstruction(
-		[...operandExprs],
-		run as InstructionRun,
-		ctx,
-		`${plan.expression.name}(${plan.operands.length})`
-	);
-}
-
-/**
- * Main emitter for scalar function calls.
- * Checks if the function has a custom emitter and uses it, otherwise uses default logic.
- */
-export function emitScalarFunctionCall(plan: ScalarFunctionCallNode, ctx: EmissionContext): Instruction {
-	const functionSchema = plan.functionSchema;
-
-	// Validate that it's a scalar function
-	if (!isScalarFunctionSchema(functionSchema)) {
-		const functionName = plan.expression.name.toLowerCase();
-		throw new QuereusError(`Function ${functionName} is not a scalar function`, StatusCode.ERROR);
-	}
-
-	// Check if function has a custom emitter
-	if (functionSchema.customEmitter) {
-		return functionSchema.customEmitter(plan, ctx, emitScalarFunctionCallDefault);
-	}
-
-	// Use default emission logic
-	return emitScalarFunctionCallDefault(plan, ctx);
-}

package/src/runtime/emit/scan.ts

@@ -1,106 +0,0 @@
-import { StatusCode, type Row } from "../../common/types.js";
-import { SeqScanNode, IndexScanNode, IndexSeekNode } from "../../planner/nodes/table-access-nodes.js";
-import { QuereusError } from "../../common/errors.js";
-import type { VirtualTable } from "../../vtab/table.js";
-import type { BaseModuleConfig, AnyVirtualTableModule } from "../../vtab/module.js";
-import type { Instruction, RuntimeContext } from "../types.js";
-import type { EmissionContext } from "../emission-context.js";
-import { createValidatedInstruction, emitPlanNode } from "../emitters.js";
-import { disconnectVTable } from "../utils.js";
-import { buildRowDescriptor } from "../../util/row-descriptor.js";
-import { createRowSlot } from "../context-helpers.js";
-
-/**
- * Emits instructions for physical table access nodes (SeqScan, IndexScan, IndexSeek)
- */
-export function emitSeqScan(plan: SeqScanNode | IndexScanNode | IndexSeekNode, ctx: EmissionContext): Instruction {
-	// Handle physical access nodes
-	const source = plan.source;
-	const schema = source.tableSchema;
-
-	// Create row descriptor mapping attribute IDs to column indices
-	const rowDescriptor = buildRowDescriptor(plan.getAttributes());
-
-	// Look up the virtual table module during emission and record the dependency
-	const moduleInfo = ctx.getVtabModule(schema.vtabModuleName);
-	if (!moduleInfo) {
-		throw new QuereusError(`Virtual table module '${schema.vtabModuleName}' not found`, StatusCode.ERROR);
-	}
-
-	// Capture the module info key for runtime retrieval
-	const moduleKey = `vtab_module:${schema.vtabModuleName}`;
-
-  async function* run(runtimeCtx: RuntimeContext, ...dynamicArgs: any[]): AsyncIterable<Row> {
-		// Use the captured module info instead of doing a fresh lookup
-		const capturedModuleInfo = ctx.getCapturedSchemaObject<{ module: AnyVirtualTableModule, auxData?: unknown }>(moduleKey);
-		if (!capturedModuleInfo) {
-			throw new QuereusError(`Virtual table module '${schema.vtabModuleName}' was not captured during emission`, StatusCode.INTERNAL);
-		}
-
-		const module = capturedModuleInfo.module;
-		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.connect(
-				runtimeCtx.db,
-				capturedModuleInfo.auxData,
-				schema.vtabModuleName,
-				schema.schemaName,
-				schema.name,
-				options
-			);
-		} catch (e: any) {
-			const message = e instanceof Error ? e.message : String(e);
-			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.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);
-		try {
-      // If this is an IndexSeek with dynamic seek keys, populate args from params
-      const effectiveFilterInfo = (() => {
-        if (plan instanceof IndexSeekNode && dynamicArgs && dynamicArgs.length > 0) {
-          return { ...plan.filterInfo, args: dynamicArgs };
-        }
-        return plan.filterInfo;
-      })();
-
-      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 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
-			await disconnectVTable(runtimeCtx, vtabInstance);
-		}
-	}
-
-  // Emit parameter instructions for dynamic seek keys (IndexSeek only)
-  const params: Instruction[] = [];
-  if (plan instanceof IndexSeekNode) {
-    for (const key of plan.getSeekKeys()) {
-      params.push(emitPlanNode(key, ctx));
-    }
-  }
-
-  return createValidatedInstruction(
-    params,
-    run,
-    ctx,
-    `${plan.nodeType}(${schema.name})`
-  );
-}