@quereus/quereus 0.7.2 → 0.7.4

package/src/runtime/emit/schema-declarative.ts

@@ -1,215 +0,0 @@
-import type { EmissionContext } from '../emission-context.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { createLogger } from '../../common/logger.js';
-import { StatusCode, type Row, type SqlValue } from '../../common/types.js';
-import { QuereusError } from '../../common/errors.js';
-import { collectSchemaCatalog } from '../../schema/catalog.js';
-import { computeSchemaDiff, generateMigrationDDL } from '../../schema/schema-differ.js';
-import { computeShortSchemaHash } from '../../schema/schema-hasher.js';
-import type * as AST from '../../parser/ast.js';
-import type { PlanNode } from '../../planner/nodes/plan-node.js';
-
-const log = createLogger('runtime:emit:declare');
-
-export function emitDeclareSchema(plan: PlanNode, _ctx: EmissionContext): Instruction {
-	const declareStmt = (plan as unknown as { statementAst: AST.DeclareSchemaStmt }).statementAst;
-
-	const run = (rctx: RuntimeContext): Row => {
-		const schemaName = declareStmt.schemaName || 'main';
-		log('DECLARE SCHEMA %s', schemaName);
-
-		// Clear previous declaration and seed data for this schema
-		rctx.db.declaredSchemaManager.clearSeedData(schemaName);
-
-		// Store the declared schema
-		rctx.db.declaredSchemaManager.setDeclaredSchema(schemaName, declareStmt);
-
-		// Process seed data if present
-		for (const item of declareStmt.items) {
-			if (item.type === 'declaredSeed' && item.seedData) {
-				const tableName = item.tableName;
-				const rows = Array.from(item.seedData) as Array<SqlValue[]>;
-				rctx.db.declaredSchemaManager.setSeedData(schemaName, tableName, rows);
-				log('Stored seed data for %s.%s (%d rows)', schemaName, tableName, rows.length);
-			}
-		}
-
-		// Return empty row to satisfy type system (void result)
-		return [];
-	};
-
-	return {
-		params: [],
-		run: run as InstructionRun,
-		note: `declare schema ${declareStmt.schemaName || 'main'}`
-	};
-}
-
-export function emitDiffSchema(plan: PlanNode, _ctx: EmissionContext): Instruction {
-	const diffStmt = (plan as unknown as { statementAst: AST.DiffSchemaStmt }).statementAst;
-
-	const run = async function* (rctx: RuntimeContext): AsyncIterable<Row> {
-		const schemaName = diffStmt.schemaName || 'main';
-		log('DIFF SCHEMA %s', schemaName);
-
-		// Get declared schema
-		const declaredSchema = rctx.db.declaredSchemaManager.getDeclaredSchema(schemaName);
-		if (!declaredSchema) {
-			throw new QuereusError(`No declared schema found for '${schemaName}'`, StatusCode.ERROR);
-		}
-
-		// Collect actual catalog
-		const actualCatalog = collectSchemaCatalog(rctx.db, schemaName);
-
-		// Compute diff
-		const diff = computeSchemaDiff(declaredSchema, actualCatalog);
-
-		// Generate migration DDL statements
-		const migrationStatements = generateMigrationDDL(diff, schemaName);
-
-		// Return each DDL statement as a row
-		// This allows users to fetch the DDL and execute it themselves with custom logic
-		for (const ddl of migrationStatements) {
-			yield [ddl];
-		}
-	};
-
-	return {
-		params: [],
-		run: run as InstructionRun,
-		note: `diff schema ${diffStmt.schemaName || 'main'}`
-	};
-}
-
-export function emitApplySchema(plan: PlanNode, _ctx: EmissionContext): Instruction {
-	const applyStmt = (plan as unknown as { statementAst: AST.ApplySchemaStmt }).statementAst;
-
-	const run = async (rctx: RuntimeContext): Promise<Row> => {
-		const schemaName = applyStmt.schemaName || 'main';
-		log('APPLY SCHEMA %s', schemaName);
-
-		// Get declared schema
-		const declaredSchema = rctx.db.declaredSchemaManager.getDeclaredSchema(schemaName);
-		if (!declaredSchema) {
-			throw new QuereusError(`No declared schema found for '${schemaName}'`, StatusCode.ERROR);
-		}
-
-		// Ensure the target schema exists (create if it doesn't, except for main/temp)
-		const lowerSchemaName = schemaName.toLowerCase();
-		if (lowerSchemaName !== 'main' && lowerSchemaName !== 'temp') {
-			if (!rctx.db.schemaManager.getSchema(schemaName)) {
-				rctx.db.schemaManager.addSchema(schemaName);
-				log('Created schema: %s', schemaName);
-			}
-		}
-
-		// Collect actual catalog
-		const actualCatalog = collectSchemaCatalog(rctx.db, schemaName);
-
-		// Compute diff
-		const diff = computeSchemaDiff(declaredSchema, actualCatalog);
-
-		// Generate migration DDL
-		const migrationStatements = generateMigrationDDL(diff, schemaName);
-
-		// Execute each migration statement
-		for (const ddl of migrationStatements) {
-			log('Executing migration DDL: %s', ddl);
-			try {
-				await rctx.db.exec(ddl);
-			} catch (e) {
-				log('Migration failed for DDL: %s', ddl);
-				const errorMessage = e instanceof Error ? e.message : String(e);
-				throw new QuereusError(
-					`Failed to execute DDL: ${ddl}\nError: ${errorMessage}`,
-					StatusCode.ERROR,
-					e instanceof Error ? e : undefined
-				);
-			}
-		}
-
-		// Apply seed data if requested
-		if (applyStmt.withSeed) {
-			const allSeedData = rctx.db.declaredSchemaManager.getAllSeedData(schemaName);
-			log('Seed data available for %d tables', allSeedData.size);
-			for (const [tableName, rows] of allSeedData) {
-				log('Applying seed data to %s.%s (%d rows)', schemaName, tableName, rows.length);
-
-				// Qualify table name with schema if not main
-				const qualifiedTableName = (schemaName && schemaName.toLowerCase() !== 'main')
-					? `${schemaName}.${tableName}`
-					: tableName;
-
-				// Delete existing rows, then insert seed rows in one batch
-				const deleteAndInsertSql = [
-					`DELETE FROM ${qualifiedTableName}`,
-					...rows.map(row => {
-						const values = row.map(v =>
-							v === null ? 'NULL' :
-							typeof v === 'string' ? `'${v.replace(/'/g, "''")}'` :
-							typeof v === 'number' || typeof v === 'bigint' ? String(v) :
-							'NULL'
-						).join(', ');
-						return `INSERT INTO ${qualifiedTableName} VALUES (${values})`;
-					})
-				].join('; ');
-
-				log('Executing seed SQL (length=%d): %s', deleteAndInsertSql.length, deleteAndInsertSql);
-				try {
-					await rctx.db.exec(deleteAndInsertSql);
-					log('Seed application succeeded for table %s', tableName);
-				} catch (e) {
-					log('Seed application failed for table %s: %O', tableName, e);
-					const errorMessage = e instanceof Error ? e.message : String(e);
-					throw new QuereusError(
-						`Failed to apply seed data for table ${tableName}. SQL: ${deleteAndInsertSql}\nError: ${errorMessage}`,
-						StatusCode.ERROR,
-						e instanceof Error ? e : undefined
-					);
-				}
-			}
-		}
-
-		// Return empty row to satisfy type system (void result)
-		return [];
-	};
-
-	return {
-		params: [],
-		run: run as InstructionRun,
-		note: `apply schema ${applyStmt.schemaName || 'main'}${applyStmt.withSeed ? ' with seed' : ''}`
-	};
-}
-
-export function emitExplainSchema(plan: PlanNode, _ctx: EmissionContext): Instruction {
-	const explainStmt = (plan as unknown as { statementAst: AST.ExplainSchemaStmt }).statementAst;
-
-	const run = async function* (rctx: RuntimeContext): AsyncIterable<Row> {
-		const schemaName = explainStmt.schemaName || 'main';
-		log('EXPLAIN SCHEMA %s', schemaName);
-
-		// Get declared schema
-		const declaredSchema = rctx.db.declaredSchemaManager.getDeclaredSchema(schemaName);
-		if (!declaredSchema) {
-			throw new QuereusError(`No declared schema found for '${schemaName}'`, StatusCode.ERROR);
-		}
-
-		// Compute hash
-		const hash = computeShortSchemaHash(declaredSchema);
-
-		// Return hash with version if specified
-		const result = explainStmt.version
-			? `version:${explainStmt.version},hash:${hash}`
-			: `hash:${hash}`;
-
-		yield [result];
-	};
-
-	return {
-		params: [],
-		run: run as InstructionRun,
-		note: `explain schema ${explainStmt.schemaName || 'main'}`
-	};
-}
-
-

package/src/runtime/emit/sequencing.ts

@@ -1,24 +0,0 @@
-import type { SequencingNode } from '../../planner/nodes/sequencing-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 emitSequencing(plan: SequencingNode, ctx: EmissionContext): Instruction {
-	async function* run(ctx: RuntimeContext, source: AsyncIterable<Row>): AsyncIterable<Row> {
-		let rowNumber = 1;
-
-		for await (const sourceRow of source) {
-			// Append row number to each row
-			yield [...sourceRow, rowNumber++] as Row;
-		}
-	}
-
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-
-	return {
-		params: [sourceInstruction],
-		run: run as InstructionRun,
-		note: `sequencing(${plan.sequenceColumnName})`
-	};
-}

package/src/runtime/emit/set-operation.ts

@@ -1,141 +0,0 @@
-import type { SetOperationNode } from '../../planner/nodes/set-operation-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { emitPlanNode } from '../emitters.js';
-import type { Row } from '../../common/types.js';
-import { BTree } from 'inheritree';
-import { compareRows } from '../../util/comparison.js';
-
-export function emitSetOperation(plan: SetOperationNode, ctx: EmissionContext): Instruction {
-  const leftInst = emitPlanNode(plan.left, ctx);
-  const rightInst = emitPlanNode(plan.right, ctx);
-
-  // Helper function to create a properly structured output row
-  function createOutputRow(inputRow: Row): Row {
-    const outputRow: Row = [];
-    plan.getAttributes().forEach((attr, idx) => {
-      outputRow[idx] = inputRow[idx]; // Map by position since columns should align
-    });
-    return outputRow;
-  }
-
-  async function* runUnionAll(rctx: RuntimeContext, leftRows: AsyncIterable<Row>, rightRows: AsyncIterable<Row>): AsyncIterable<Row> {
-    // Process left rows - let SortNode handle row context
-    for await (const row of leftRows) {
-      yield createOutputRow(row);
-    }
-
-    // Process right rows - let SortNode handle row context
-    for await (const row of rightRows) {
-      yield createOutputRow(row);
-    }
-  }
-
-  async function* runUnionDistinct(rctx: RuntimeContext, leftRows: AsyncIterable<Row>, rightRows: AsyncIterable<Row>): AsyncIterable<Row> {
-    // Use BTree for proper SQL value comparison instead of JSON.stringify
-    const distinctTree = new BTree<Row, Row>(
-      (row: Row) => row,
-      compareRows
-    );
-
-    for await (const row of leftRows) {
-      const outputRow = createOutputRow(row);
-      const newPath = distinctTree.insert(outputRow);
-      if (newPath.on) {
-        // This is a new distinct row
-        yield outputRow; // Let SortNode handle row context
-      }
-    }
-    for await (const row of rightRows) {
-      const outputRow = createOutputRow(row);
-      const newPath = distinctTree.insert(outputRow);
-      if (newPath.on) {
-        // This is a new distinct row
-        yield outputRow; // Let SortNode handle row context
-      }
-    }
-  }
-
-  async function* runIntersect(rctx: RuntimeContext, leftRows: AsyncIterable<Row>, rightRows: AsyncIterable<Row>): AsyncIterable<Row> {
-    // Use BTree for proper SQL value comparison
-    const leftTree = new BTree<Row, Row>(
-      (row: Row) => row,
-      compareRows
-    );
-
-    // Build left set
-    for await (const row of leftRows) {
-      const outputRow = createOutputRow(row);
-      leftTree.insert(outputRow);
-    }
-
-    // Check right rows against left set
-    const yielded = new BTree<Row, Row>(
-      (row: Row) => row,
-      compareRows
-    );
-
-    for await (const row of rightRows) {
-      const outputRow = createOutputRow(row);
-      const leftPath = leftTree.find(outputRow);
-      if (leftPath.on) {
-        // This row exists in left set - yield the LEFT row to preserve left-side types
-        const leftRow = leftTree.get(outputRow)!;
-        const yieldedPath = yielded.insert(leftRow);
-        if (yieldedPath.on) {
-          // Haven't yielded this row yet (handles duplicates in right)
-          yield leftRow; // Let SortNode handle row context
-        }
-      }
-    }
-  }
-
-  async function* runExcept(rctx: RuntimeContext, leftRows: AsyncIterable<Row>, rightRows: AsyncIterable<Row>): AsyncIterable<Row> {
-    // Use BTree for proper SQL value comparison
-    const rightTree = new BTree<Row, Row>(
-      (row: Row) => row,
-      compareRows
-    );
-    const leftRowsArray: Row[] = [];
-
-    // Collect left rows
-    for await (const row of leftRows) {
-      leftRowsArray.push(createOutputRow(row));
-    }
-
-    // Build right set
-    for await (const row of rightRows) {
-      rightTree.insert(createOutputRow(row));
-    }
-
-    // Yield left rows that are not in right set
-    for (const outputRow of leftRowsArray) {
-      const rightPath = rightTree.find(outputRow);
-      if (!rightPath.on) {
-        yield outputRow; // Let SortNode handle row context
-      }
-    }
-  }
-
-  let run: InstructionRun;
-  switch (plan.op) {
-    case 'unionAll':
-      run = runUnionAll as InstructionRun;
-      break;
-    case 'union':
-      run = runUnionDistinct as InstructionRun;
-      break;
-    case 'intersect':
-      run = runIntersect as InstructionRun;
-      break;
-    case 'except':
-      run = runExcept as InstructionRun;
-      break;
-  }
-
-  return {
-    params: [leftInst, rightInst],
-    run,
-    note: plan.op
-  };
-}

package/src/runtime/emit/sink.ts

@@ -1,27 +0,0 @@
-import type { SinkNode } from '../../planner/nodes/sink-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import type { Row } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { emitPlanNode } from '../emitters.js';
-
-export function emitSink(plan: SinkNode, ctx: EmissionContext): Instruction {
-	async function run(ctx: RuntimeContext, sourceRows: AsyncIterable<Row>): Promise<number> {
-		let rowCount = 0;
-
-		// Consume all rows from the source to trigger side effects
-		for await (const _row of sourceRows) {
-			++rowCount;
-		}
-
-		// Return the count
-		return rowCount;
-	}
-
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-
-	return {
-		params: [sourceInstruction],
-		run: run as InstructionRun,
-		note: `sink(${plan.operation})`
-	};
-}

package/src/runtime/emit/sort.ts

@@ -1,75 +0,0 @@
-import type { SortNode } from '../../planner/nodes/sort.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
-import { type SqlValue, type Row, type MaybePromise } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { createOrderByComparatorFast, resolveCollation } from '../../util/comparison.js';
-import { buildRowDescriptor } from '../../util/row-descriptor.js';
-import { withAsyncRowContext } from '../context-helpers.js';
-
-export function emitSort(plan: SortNode, ctx: EmissionContext): Instruction {
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-
-	// Create row descriptor for source attributes
-	const sourceRowDescriptor = buildRowDescriptor(plan.source.getAttributes());
-
-	// Emit sort key instructions and pre-create optimized comparators with resolved collations
-	const sortKeyInstructions = plan.sortKeys.map(key => emitCallFromPlan(key.expression, ctx));
-	const sortKeyComparators = plan.sortKeys.map(key => {
-		const keyType = key.expression.getType();
-		const collationName = keyType.collationName || 'BINARY';
-		const collationFunc = resolveCollation(collationName);
-		return createOrderByComparatorFast(key.direction, key.nulls, collationFunc);
-	});
-
-	async function* run(
-		ctx: RuntimeContext,
-		source: AsyncIterable<Row>,
-		...sortKeyFunctions: Array<(ctx: RuntimeContext) => MaybePromise<SqlValue>>
-	): AsyncIterable<Row> {
-
-		// Collect all rows with their sort key values
-		const rowsWithKeys: Array<{ row: Row; keys: SqlValue[] }> = [];
-
-		for await (const sourceRow of source) {
-			const keys = await withAsyncRowContext(ctx, sourceRowDescriptor, () => sourceRow, async () => {
-				// Evaluate sort key expressions
-				const keyValues: SqlValue[] = [];
-				for (const keyFunc of sortKeyFunctions) {
-					const result = keyFunc(ctx);
-					keyValues.push(await Promise.resolve(result));
-				}
-				return keyValues;
-			});
-
-			rowsWithKeys.push({ row: sourceRow, keys });
-		}
-
-		// Sort the collected rows using pre-created optimized comparators
-		rowsWithKeys.sort((a, b) => {
-			for (let i = 0; i < sortKeyComparators.length; i++) {
-				const comparator = sortKeyComparators[i];
-				const aValue = a.keys[i];
-				const bValue = b.keys[i];
-
-				const comparison = comparator(aValue, bValue);
-
-				if (comparison !== 0) {
-					return comparison;
-				}
-			}
-			return 0;
-		});
-
-		// Yield sorted rows
-		for (const { row } of rowsWithKeys) {
-			yield row;
-		}
-	}
-
-	return {
-		params: [sourceInstruction, ...sortKeyInstructions],
-		run: run as InstructionRun,
-		note: `sort(${plan.sortKeys.length} keys)`
-	};
-}

package/src/runtime/emit/subquery.ts

@@ -1,203 +0,0 @@
-import type { InNode, ExistsNode, ScalarSubqueryNode } from '../../planner/nodes/subquery.js';
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import { emitPlanNode } from '../emitters.js';
-import type { SqlValue, Row } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { BTree } from 'inheritree';
-import { compareSqlValuesFast, resolveCollation } from '../../util/comparison.js';
-import { ConstantNode } from '../../planner/nodes/plan-node.js';
-
-export function emitScalarSubquery(plan: ScalarSubqueryNode, ctx: EmissionContext): Instruction {
-
-	async function run(_rctx: RuntimeContext, input: AsyncIterable<Row>): Promise<SqlValue> {
-		let result: SqlValue = null;
-		let seen = false;
-
-		for await (const row of input) {
-			if (seen) {
-				throw new QuereusError('Scalar subquery returned more than one row', StatusCode.ERROR, undefined, plan.expression.loc?.start.line, plan.expression.loc?.start.column);
-			}
-			if (row.length > 1) {
-				throw new QuereusError('Subquery should return at most one column', StatusCode.ERROR);
-			}
-			result = row.length === 0 ? null : row[0];
-			seen = true;
-		}
-
-		return result;
-	}
-
-	const innerInstruction = emitPlanNode(plan.subquery, ctx);
-
-	return {
-		params: [innerInstruction],
-		run: run as InstructionRun,
-		note: 'SCALAR_SUBQUERY'
-	};
-}
-
-export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
-	// Extract collation from the condition expression
-	const conditionType = plan.condition.getType();
-	const collationName = conditionType.collationName || 'BINARY';
-	const collation = resolveCollation(collationName);
-
-	if (plan.source) {
-		// IN subquery: expr IN (SELECT ...)
-		// Use streaming approach - check each row as we read it, return early on match
-		async function runSubqueryStreaming(_rctx: RuntimeContext, input: AsyncIterable<Row>, condition: SqlValue): Promise<SqlValue> {
-			// If condition is NULL, result is NULL
-			if (condition === null) {
-				return null;
-			}
-
-			let hasNull = false;
-			for await (const row of input) {
-				if (row.length > 0) {
-					const rowValue = row[0];
-					if (rowValue === null) {
-						hasNull = true;
-						continue;
-					}
-					// Check for match immediately - no need to materialize
-					if (compareSqlValuesFast(condition, rowValue, collation) === 0) {
-						return true; // Found a match
-					}
-				}
-			}
-
-			// No match found - if any value was NULL, result is NULL
-			return hasNull ? null : false;
-		}
-
-		const sourceInstruction = emitPlanNode(plan.source, ctx);
-		const conditionExpr = emitPlanNode(plan.condition, ctx);
-
-		return {
-			params: [sourceInstruction, conditionExpr],
-			run: runSubqueryStreaming as InstructionRun,
-			note: `IN (subquery)`
-		};
-	} else if (plan.values) {
-		// IN value list: expr IN (value1, value2, ...)
-
-		// Check if all values are truly constant (can be evaluated at emit time)
-		const allConstant = plan.values.every(val => val.physical.constant);
-
-		if (allConstant) {
-			// Pre-build BTree at emit time for constant values
-			const tree = new BTree<SqlValue, SqlValue>(
-				(val: SqlValue) => val,
-				(a: SqlValue, b: SqlValue) => compareSqlValuesFast(a, b, collation)
-			);
-			let hasNull = false;
-
-			function innerConstantRun(_rctx: RuntimeContext, condition: SqlValue): SqlValue {
-				// If condition is NULL, result is NULL
-				if (condition === null) {
-					return null;
-				}
-
-				// Check if condition exists in pre-built tree
-				const path = tree.find(condition);
-				if (path.on) {
-					return true; // Found a match
-				}
-
-				// No match found - if any value was NULL, result is NULL
-				return hasNull ? null : false;
-			}
-
-			const values = plan.values.map(val => (val as unknown as ConstantNode).getValue());
-
-			let runFunc: InstructionRun;
-
-			if (values.some(val => val instanceof Promise)) {
-				// Must resolve promises at runtime
-				runFunc = (async (rctx: RuntimeContext, condition: SqlValue): Promise<SqlValue> => {
-					const resolved = await Promise.all(values);
-
-					for (const value of resolved) {
-						if (value === null) {
-							hasNull = true;
-							continue;
-						}
-						tree.insert(value as SqlValue);
-					}
-
-					return innerConstantRun(rctx, condition);
-				}) as InstructionRun;
-			} else {
-				for (const value of values) {
-					if (value === null) {
-						hasNull = true;
-						continue;
-					}
-					tree.insert(value as SqlValue);
-				}
-				runFunc = innerConstantRun as InstructionRun;
-			}
-
-			const conditionExpr = emitPlanNode(plan.condition, ctx);
-
-			return {
-				params: [conditionExpr],
-				run: runFunc as InstructionRun,
-				note: `IN (${plan.values.length} constant values)`
-			};
-		} else {
-			// Some values are expressions - build tree at runtime
-			function runDynamicValues(_rctx: RuntimeContext, condition: SqlValue, ...values: SqlValue[]): SqlValue {
-				// If condition is NULL, result is NULL
-				if (condition === null) {
-					return null;
-				}
-
-				// Linear scan is optimal since we're only doing one lookup per execution
-				let hasNull = false;
-				for (const value of values) {
-					if (value === null) {
-						hasNull = true;
-						continue;
-					}
-					if (compareSqlValuesFast(condition, value, collation) === 0) {
-						return true; // Found a match
-					}
-				}
-
-				// No match found - if any value was NULL, result is NULL
-				return hasNull ? null : false;
-			}
-
-			const conditionExpr = emitPlanNode(plan.condition, ctx);
-			const valueExprs = plan.values.map(val => emitPlanNode(val, ctx));
-
-			return {
-				params: [conditionExpr, ...valueExprs],
-				run: runDynamicValues as InstructionRun,
-				note: `IN (${plan.values.length} dynamic values)`
-			};
-		}
-	} else {
-		throw new QuereusError('IN node must have either source or values', StatusCode.INTERNAL);
-	}
-}
-
-export function emitExists(plan: ExistsNode, ctx: EmissionContext): Instruction {
-	async function run(_rctx: RuntimeContext, input: AsyncIterable<Row>): Promise<SqlValue> {
-		for await (const _row of input) {
-			return true; // First row => TRUE
-		}
-		return false; // Empty => FALSE
-	}
-
-	const innerInstruction = emitPlanNode(plan.subquery, ctx);
-
-	return {
-		params: [innerInstruction],
-		run: run as InstructionRun,
-		note: 'EXISTS'
-	};
-}