@quereus/quereus 0.7.2 → 0.7.4

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

@@ -1,17 +0,0 @@
-import type { ColumnReferenceNode } from '../../planner/nodes/reference.js';
-import type { Instruction, RuntimeContext } from '../types.js';
-import type { SqlValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { resolveAttribute } from '../context-helpers.js';
-
-export function emitColumnReference(plan: ColumnReferenceNode, _ctx: EmissionContext): Instruction {
-	function run(rctx: RuntimeContext): SqlValue {
-		return resolveAttribute(rctx, plan.attributeId, plan.expression.name);
-	}
-
-	return {
-		params: [],
-		run,
-		note: `column(${plan.expression.name})`
-	};
-}

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

@@ -1,290 +0,0 @@
-import type { ConstraintCheckNode } from '../../planner/nodes/constraint-check-node.js';
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import type { Row } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode, type SqlValue, type OutputValue } from '../../common/types.js';
-import type { RowConstraintSchema, TableSchema } from '../../schema/table.js';
-import type { RowDescriptor } from '../../planner/nodes/plan-node.js';
-import { RowOpFlag } from '../../schema/table.js';
-import { withAsyncRowContext, createRowSlot } from '../context-helpers.js';
-import { expressionToString } from '../../util/ast-stringify.js';
-
-interface ConstraintMetadataEntry {
-	schema: RowConstraintSchema;
-	flatRowDescriptor: RowDescriptor;
-	evaluator: (ctx: RuntimeContext) => OutputValue;
-	constraintName: string;
-	constraintExpr: string; // Stringified constraint expression
-	shouldDefer: boolean;
-	baseTable: string;
-	contextRow?: Row; // Mutation context row if present
-	contextDescriptor?: RowDescriptor; // Mutation context row descriptor
-}
-
-export function emitConstraintCheck(plan: ConstraintCheckNode, ctx: EmissionContext): Instruction {
-	// Get the table schema to access constraints
-	const tableSchema = plan.table.tableSchema;
-
-	// Use the pre-built flat row descriptor from the plan
-	const flatRowDescriptor = plan.flatRowDescriptor;
-
-	// Get mutation context from the plan (passed from DML builders)
-	const mutationContextValues = plan.mutationContextValues;
-	const contextAttributes = plan.contextAttributes;
-	const contextDescriptor = plan.contextDescriptor;
-
-	// Emit mutation context value evaluators if present
-	const contextEvaluatorInstructions: Instruction[] = [];
-	if (mutationContextValues && contextAttributes) {
-		for (const attr of contextAttributes) {
-			const valueExpr = mutationContextValues.get(attr.name);
-			if (valueExpr) {
-				contextEvaluatorInstructions.push(emitCallFromPlan(valueExpr, ctx));
-			}
-		}
-	}
-
-	// Emit evaluator instructions for each pre-built constraint expression
-	const checkEvaluators = plan.constraintChecks.map(check =>
-		emitCallFromPlan(check.expression, ctx)
-	);
-
-	const constraintMetadata: ConstraintMetadataEntry[] = plan.constraintChecks.map((check, idx) => {
-		const evaluatorInstruction = checkEvaluators[idx];
-		const constraintName = check.constraint.name ?? generateDefaultConstraintName(tableSchema, check.constraint);
-		const constraintExpr = expressionToString(check.constraint.expr);
-		return {
-			schema: check.constraint,
-			flatRowDescriptor: plan.flatRowDescriptor,
-			evaluator: evaluatorInstruction.run,
-			constraintName,
-			constraintExpr,
-			shouldDefer: Boolean(check.deferrable || check.initiallyDeferred || check.containsSubquery),
-			baseTable: `${tableSchema.schemaName}.${tableSchema.name}`,
-			contextRow: undefined,
-			contextDescriptor
-		};
-	});
-
-	async function* run(rctx: RuntimeContext, inputRows: AsyncIterable<Row>, ...evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>): AsyncIterable<Row> {
-		if (!inputRows) {
-			return;
-		}
-
-		// Evaluate mutation context values once per statement (not per row)
-		let contextRow: Row | undefined;
-		let contextSlot: ReturnType<typeof createRowSlot> | undefined;
-
-		if (contextEvaluatorInstructions.length > 0 && contextDescriptor) {
-			// Split evaluatorFunctions into context evaluators and constraint evaluators
-			const contextEvalFunctions = evaluatorFunctions.slice(0, contextEvaluatorInstructions.length);
-			const constraintEvalFunctions = evaluatorFunctions.slice(contextEvaluatorInstructions.length);
-
-			// Evaluate all context values
-			contextRow = [];
-			for (const contextEvaluator of contextEvalFunctions) {
-				const value = await contextEvaluator(rctx) as SqlValue;
-				contextRow.push(value);
-			}
-
-			// Store context row in metadata for deferred constraints
-			constraintMetadata.forEach(meta => {
-				meta.contextRow = contextRow;
-			});
-
-			// Create a row slot for the mutation context that persists for the whole statement
-			contextSlot = createRowSlot(rctx, contextDescriptor);
-			contextSlot.set(contextRow);
-
-			// Use constraint evaluators for the rest of the function
-			evaluatorFunctions = constraintEvalFunctions;
-		}
-
-		try {
-			for await (const inputRow of inputRows) {
-				const flatRow = inputRow;
-
-				// If we have mutation context, compose it with the flat row for constraint evaluation
-				const combinedRow = contextRow ? [...contextRow, ...flatRow] : flatRow;
-				const combinedDescriptor = contextDescriptor && contextRow
-					? composeCombinedDescriptor(contextDescriptor, flatRowDescriptor)
-					: flatRowDescriptor;
-
-				const result = await withAsyncRowContext(rctx, combinedDescriptor, () => combinedRow, async () => {
-					// Check all constraints that apply to this operation
-					await checkConstraints(rctx, plan, tableSchema, flatRow, constraintMetadata, evaluatorFunctions);
-
-					// If all constraints pass, yield the flat row for downstream processing
-					// All downstream operations (INSERT executor, DELETE executor, RETURNING) expect flat rows
-					return flatRow;
-				});
-
-				yield result;
-			}
-		} finally {
-			// Clean up context slot if we created one
-			if (contextSlot) {
-				contextSlot.close();
-			}
-		}
-	}
-
-	// Emit the source instruction
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-
-	return {
-		params: [sourceInstruction, ...contextEvaluatorInstructions, ...checkEvaluators],
-		run: run as InstructionRun,
-		note: `constraintCheck(${plan.operation}, ${contextEvaluatorInstructions.length} ctx, ${plan.constraintChecks.length} checks)`
-	};
-}
-
-/**
- * Composes a combined row descriptor that includes both context and flat (OLD/NEW) descriptors.
- * Context attributes come first, followed by OLD/NEW attributes with offset indices.
- */
-function composeCombinedDescriptor(contextDescriptor: RowDescriptor, flatRowDescriptor: RowDescriptor): RowDescriptor {
-	const combined: RowDescriptor = [];
-	const contextLength = Object.keys(contextDescriptor).filter(k => contextDescriptor[parseInt(k)] !== undefined).length;
-
-	// Copy context descriptor as-is (indices 0..contextLength-1)
-	for (const attrIdStr in contextDescriptor) {
-		const attrId = parseInt(attrIdStr);
-		if (contextDescriptor[attrId] !== undefined) {
-			combined[attrId] = contextDescriptor[attrId];
-		}
-	}
-
-	// Copy flat descriptor with offset indices (indices contextLength..end)
-	for (const attrIdStr in flatRowDescriptor) {
-		const attrId = parseInt(attrIdStr);
-		if (flatRowDescriptor[attrId] !== undefined) {
-			combined[attrId] = flatRowDescriptor[attrId] + contextLength;
-		}
-	}
-
-	return combined;
-}
-
-async function checkConstraints(
-	rctx: RuntimeContext,
-	plan: ConstraintCheckNode,
-	tableSchema: TableSchema,
-	row: Row,
-	constraintMetadata: ConstraintMetadataEntry[],
-	evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>
-): Promise<void> {
-	// Check PRIMARY KEY constraints (UNIQUE constraints on PK columns)
-	await checkPrimaryKeyConstraints(rctx, plan, tableSchema, row);
-
-	// Check NOT NULL constraints on individual columns
-	await checkNotNullConstraints(rctx, plan, tableSchema, row);
-
-	// Check CHECK constraints (both column-level and table-level)
-	await checkCheckConstraints(rctx, plan, tableSchema, row, constraintMetadata, evaluatorFunctions);
-}
-
-async function checkNotNullConstraints(
-	rctx: RuntimeContext,
-	plan: ConstraintCheckNode,
-	tableSchema: TableSchema,
-	flatRow: Row
-): Promise<void> {
-	// For INSERT operations, check NOT NULL on NEW values
-	// For UPDATE operations, check NOT NULL on NEW values
-	// DELETE operations don't need NOT NULL checks
-	if (plan.operation === RowOpFlag.DELETE) {
-		return;
-	}
-
-	// Check each column for NOT NULL constraint using NEW values
-	if (plan.newRowDescriptor) {
-		for (let i = 0; i < tableSchema.columns.length; i++) {
-			const column = tableSchema.columns[i];
-			if (column.notNull) {
-				// Find the NEW value for this column in the flat row
-				const newValueIndex = tableSchema.columns.length + i; // NEW section: n..2n-1
-				const value = flatRow[newValueIndex];
-
-				if (value === null || value === undefined) {
-					throw new QuereusError(
-						`NOT NULL constraint failed: ${tableSchema.name}.${column.name}`,
-						StatusCode.CONSTRAINT
-					);
-				}
-			}
-		}
-	}
-}
-
-async function checkPrimaryKeyConstraints(
-	_rctx: RuntimeContext,
-	_plan: ConstraintCheckNode,
-	_tableSchema: TableSchema,
-	_row: Row
-): Promise<void> {
-	// Primary Key constraints are enforced at the VTable level for now
-	// This is simpler and more efficient than trying to implement it at the engine level
-	// since the VTable has direct access to the current table state
-	return;
-}
-
-async function checkCheckConstraints(
-	rctx: RuntimeContext,
-	plan: ConstraintCheckNode,
-	tableSchema: TableSchema,
-	row: Row,
-	constraintMetadata: ConstraintMetadataEntry[],
-	evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>
-): Promise<void> {
-	// Evaluate each CHECK constraint using pre-built evaluators
-	for (let i = 0; i < constraintMetadata.length; i++) {
-		const metadata = constraintMetadata[i];
-		const evaluator = evaluatorFunctions[i] ?? metadata.evaluator;
-
-		if (metadata.shouldDefer) {
-			const activeConnectionId = rctx.activeConnection?.connectionId;
-			rctx.db._queueDeferredConstraintRow(
-				metadata.baseTable,
-				metadata.constraintName,
-				row.slice() as Row,
-				metadata.flatRowDescriptor,
-				evaluator,
-				activeConnectionId,
-				metadata.contextRow,
-				metadata.contextDescriptor
-			);
-			continue;
-		}
-
-		try {
-			const result = await evaluator(rctx) as SqlValue;
-
-			// CHECK constraint passes if result is truthy or NULL
-			// It fails only if result is false or 0 (SQLite-style numeric boolean)
-			if (result === false || result === 0) {
-				// Include constraint expression in error message for better debugging
-				const exprHint = metadata.constraintExpr.length <= 60
-					? ` (${metadata.constraintExpr})`
-					: '';
-				throw new QuereusError(
-					`CHECK constraint failed: ${metadata.constraintName}${exprHint}`,
-					StatusCode.CONSTRAINT
-				);
-			}
-		} catch (error) {
-			if (error instanceof QuereusError && error.message.includes('CHECK constraint failed')) {
-				throw error;
-			}
-			throw error;
-		}
-	}
-}
-
-function generateDefaultConstraintName(tableSchema: TableSchema, constraint: RowConstraintSchema): string {
-	// Find the index of this constraint in the original array to get the correct constraint number
-	const originalIndex = tableSchema.checkConstraints.findIndex((c: RowConstraintSchema) => c === constraint);
-	return `_check_${originalIndex >= 0 ? originalIndex : 'unknown'}`;
-}

package/src/runtime/emit/create-assertion.ts

@@ -1,82 +0,0 @@
-import type { CreateAssertionNode } from '../../planner/nodes/create-assertion-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { QuereusError } from '../../common/errors.js';
-import { SqlValue, StatusCode } from '../../common/types.js';
-import { createLogger } from '../../common/logger.js';
-import type { IntegrityAssertionSchema, AssertionDependentTable } from '../../schema/assertion.js';
-import { expressionToString } from '../../util/ast-stringify.js';
-
-const log = createLogger('runtime:emit:create-assertion');
-
-export function emitCreateAssertion(plan: CreateAssertionNode, _ctx: EmissionContext): Instruction {
-
-	async function run(rctx: RuntimeContext): Promise<SqlValue> {
-		// Convert the CHECK expression to SQL text for storage
-		// The CHECK expression should be negated to become a violation query:
-		// CHECK (condition) becomes "SELECT 1 WHERE NOT (condition)"
-		let violationSql: string;
-		try {
-			const exprSql = expressionToString(plan.checkExpression);
-			violationSql = `SELECT 1 WHERE NOT (${exprSql})`;
-		} catch (e) {
-			log('Failed to stringify assertion expression: %O', e);
-			// Fallback for complex expressions
-			violationSql = 'SELECT 1 WHERE FALSE'; // Never violates
-		}
-
-		// Create the assertion schema object
-		const assertionSchema: IntegrityAssertionSchema = {
-			name: plan.name,
-			violationSql,
-			deferrable: true, // Auto-deferred for multi-table constraints
-			initiallyDeferred: true,
-			dependentTables: []
-		};
-
-		// Discover dependent base tables (best-effort; conservative if any failure)
-		try {
-			const planNode = rctx.db.getPlan(violationSql);
-			const deps = new Map<string, AssertionDependentTable>();
-			(function collect(node: unknown) {
-				const anyNode = node as any;
-				if (anyNode && typeof anyNode.getRelations === 'function') {
-					for (const child of anyNode.getRelations()) collect(child);
-				}
-				if (anyNode?.tableSchema?.name && anyNode?.id !== undefined) {
-					const base = `${anyNode.tableSchema.schemaName}.${anyNode.tableSchema.name}`.toLowerCase();
-					const relationKey = `${base}#${anyNode.id}`;
-					if (!deps.has(relationKey)) deps.set(relationKey, { relationKey, base });
-				}
-			})(planNode);
-			assertionSchema.dependentTables = Array.from(deps.values());
-			log('Assertion %s dependencies discovered: %o', plan.name, assertionSchema.dependentTables);
-		} catch (depErr) {
-			log('Dependency discovery failed for assertion %s: %O', plan.name, depErr);
-		}
-
-		// Add to schema
-		const schemaManager = rctx.db.schemaManager;
-		const schema = schemaManager.getMainSchema(); // Store in main schema for now
-
-		// Check for existing assertion
-		const existing = schema.getAssertion(plan.name);
-		if (existing) {
-			throw new QuereusError(
-				`Assertion ${plan.name} already exists`,
-				StatusCode.CONSTRAINT
-			);
-		}
-
-		schema.addAssertion(assertionSchema);
-
-		log('Created assertion %s with violationSql: %s', plan.name, violationSql);
-		return null;
-	}
-
-	return {
-		params: [],
-		run: run as InstructionRun,
-		note: `createAssertion(${plan.name})`
-	};
-}

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

@@ -1,15 +0,0 @@
-import type { CreateIndexNode } from '../../planner/nodes/create-index-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { type SqlValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-
-export function emitCreateIndex(plan: CreateIndexNode, _ctx: EmissionContext): Instruction {
-	async function run(rctx: RuntimeContext): Promise<SqlValue | undefined> {
-		await rctx.db.schemaManager.createIndex(plan.statementAst);
-		// The specific error handling for IF NOT EXISTS is within SchemaManager.createIndex.
-
-		return null; // Explicitly return null for successful void operations
-	}
-
-	return { params: [], run: run as InstructionRun };
-}

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

@@ -1,15 +0,0 @@
-import type { CreateTableNode } from '../../planner/nodes/create-table-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { type SqlValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-
-export function emitCreateTable(plan: CreateTableNode, _ctx: EmissionContext): Instruction {
-	async function run(rctx: RuntimeContext): Promise<SqlValue | undefined> {
-		await rctx.db.schemaManager.createTable(plan.statementAst);
-		// The specific error handling for IF NOT EXISTS is within SchemaManager.defineTable.
-
-		return null; // Explicitly return null for successful void operations
-	}
-
-	return { params: [], run: run as InstructionRun };
-}

package/src/runtime/emit/create-view.ts

@@ -1,52 +0,0 @@
-import type { CreateViewNode } from '../../planner/nodes/create-view-node.js';
-import type { Instruction, RuntimeContext } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode, type SqlValue } from '../../common/types.js';
-import type { ViewSchema } from '../../schema/view.js';
-
-export function emitCreateView(plan: CreateViewNode, _ctx: EmissionContext): Instruction {
-	async function run(rctx: RuntimeContext): Promise<SqlValue> {
-		// Check if view already exists
-		const existingView = rctx.db.schemaManager.getView(plan.schemaName, plan.viewName);
-
-		if (existingView && !plan.ifNotExists) {
-			throw new QuereusError(
-				`View '${plan.schemaName}.${plan.viewName}' already exists`,
-				StatusCode.ERROR
-			);
-		}
-
-		if (existingView && plan.ifNotExists) {
-			// View exists but IF NOT EXISTS was specified, so this is a no-op
-			return null;
-		}
-
-		// Create the view schema
-		const viewSchema: ViewSchema = {
-			name: plan.viewName,
-			schemaName: plan.schemaName,
-			sql: plan.sql,
-			selectAst: plan.selectStmt,
-			columns: plan.columns
-		};
-
-		// Add the view to the schema manager
-		const schema = rctx.db.schemaManager.getSchema(plan.schemaName);
-		if (!schema) {
-			throw new QuereusError(
-				`Schema '${plan.schemaName}' does not exist`,
-				StatusCode.ERROR
-			);
-		}
-
-		schema.addView(viewSchema);
-		return null; // Explicitly return null for successful void operations
-	}
-
-	return {
-		params: [],
-		run,
-		note: `createView(${plan.schemaName}.${plan.viewName})`
-	};
-}

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

@@ -1,38 +0,0 @@
-import type { Row } from '../../common/types.js';
-import type { CTEReferenceNode } from '../../planner/nodes/cte-reference-node.js';
-import type { EmissionContext } from '../emission-context.js';
-import { emitPlanNode, createValidatedInstruction } from '../emitters.js';
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import { buildRowDescriptor } from '../../util/row-descriptor.js';
-import { withRowContextGenerator } from '../context-helpers.js';
-import { createLogger } from '../../common/logger.js';
-
-const logger = createLogger('runtime:cte');
-
-export function emitCTEReference(plan: CTEReferenceNode, ctx: EmissionContext): Instruction {
-	// Create row descriptor for output attributes
-	const rowDescriptor = buildRowDescriptor(plan.getAttributes());
-	const attrs = plan.getAttributes();
-	const cteAlias = plan.alias || plan.source.cteName;
-
-	logger(`Emitting CTE reference ${cteAlias} with attrs=[${attrs.map(a => a.id).join(',')}]`);
-
-	// Standard CTE reference: Use normal instruction parameter approach
-	async function* run(rctx: RuntimeContext, cteResult: AsyncIterable<Row>): AsyncIterable<Row> {
-		logger(`Executing CTE reference ${cteAlias}`);
-		// Execute the CTE and yield each row
-		yield* withRowContextGenerator(rctx, rowDescriptor, cteResult, async function* (row) {
-			yield row;
-		});
-	}
-
-	// Emit the underlying CTE
-	const cteInstruction = emitPlanNode(plan.source, ctx);
-
-	return createValidatedInstruction(
-		[cteInstruction],
-		run as InstructionRun,
-		ctx,
-		`cte_ref(${plan.source.cteName}${plan.alias ? ` AS ${plan.alias}` : ''})`
-	);
-}

package/src/runtime/emit/cte.ts

@@ -1,39 +0,0 @@
-import type { CTENode } from '../../planner/nodes/cte-node.js';
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { emitPlanNode } from '../emitters.js';
-import type { Row } from '../../common/types.js';
-
-export function emitCTE(plan: CTENode, ctx: EmissionContext): Instruction {
-	// Emit the underlying query
-	const queryInstruction = emitPlanNode(plan.source, ctx);
-
-	// For now, we'll implement CTEs as simply executing the underlying query
-	// In a full implementation, this would handle materialization based on the hint
-	async function* run(rctx: RuntimeContext, queryResult: AsyncIterable<Row>): AsyncIterable<Row> {
-		// If materialization is explicitly requested or beneficial,
-		// we could materialize the result here
-		if (plan.materializationHint === 'materialized') {
-			// Materialize the CTE result
-			const materializedRows: Row[] = [];
-			for await (const row of queryResult) {
-				materializedRows.push(row);
-			}
-			// Yield all materialized rows
-			for (const row of materializedRows) {
-				yield row;
-			}
-		} else {
-			// Stream the results directly
-			for await (const row of queryResult) {
-				yield row;
-			}
-		}
-	}
-
-	return {
-		params: [queryInstruction],
-		run: run as InstructionRun,
-		note: `cte(${plan.cteName})`
-	};
-}

package/src/runtime/emit/delete.ts

@@ -1,24 +0,0 @@
-import type { DeleteNode } from '../../planner/nodes/delete-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { emitPlanNode } from '../emitters.js';
-import type { Row } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-
-export function emitDelete(plan: DeleteNode, ctx: EmissionContext): Instruction {
-	// DELETE node now only handles data transformations and passes flat rows through.
-	// The actual database delete operations are handled by DmlExecutorNode.
-	async function* run(ctx: RuntimeContext, flatRowsIterable: AsyncIterable<Row>): AsyncIterable<Row> {
-		// Simply yield all flat rows from the source (which has already applied filtering, etc.)
-		for await (const flatRow of flatRowsIterable) {
-			yield flatRow;
-		}
-	}
-
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-
-	return {
-		params: [sourceInstruction],
-		run: run as InstructionRun,
-		note: `deletePrep(${plan.table.tableSchema.name})`
-	};
-}

package/src/runtime/emit/distinct.ts

@@ -1,40 +0,0 @@
-import type { DistinctNode } from '../../planner/nodes/distinct-node.js';
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import { emitPlanNode } from '../emitters.js';
-import { type Row } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { compareRows } from '../../util/comparison.js';
-import { BTree } from 'inheritree';
-import { buildRowDescriptor } from '../../util/row-descriptor.js';
-import { withRowContext } from '../context-helpers.js';
-
-export function emitDistinct(plan: DistinctNode, ctx: EmissionContext): Instruction {
-	// Create row descriptor for output attributes (same as source since DISTINCT preserves attributes)
-	const outputRowDescriptor = buildRowDescriptor(plan.getAttributes());
-
-	async function* run(ctx: RuntimeContext, source: AsyncIterable<Row>): AsyncIterable<Row> {
-		// Create BTree to efficiently track distinct rows
-		const distinctTree = new BTree<Row, Row>(
-			(row: Row) => row, // Identity function - use row as its own key
-			compareRows
-		);
-
-		for await (const sourceRow of source) {
-			// Check if we've seen this row before using BTree lookup
-			const newPath = distinctTree.insert(sourceRow);
-
-			if (newPath.on) {
-				// This is a new distinct row - set up context and yield it
-				yield await withRowContext(ctx, outputRowDescriptor, () => sourceRow, () => sourceRow);
-			}
-		}
-	}
-
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-
-	return {
-		params: [sourceInstruction],
-		run: run as InstructionRun,
-		note: 'distinct (btree-optimized)'
-	};
-}