@quereus/quereus 0.1.0

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

@@ -0,0 +1,120 @@
+import type { RecursiveCTENode } from '../../planner/nodes/recursive-cte-node.js';
+import type { Instruction, 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';
+
+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)
+				rctx.context.set(rowDescriptor, () => row);
+				try {
+					yield row;
+				} finally {
+					rctx.context.delete(rowDescriptor);
+				}
+
+				// 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
+						rctx.context.set(rowDescriptor, () => row);
+						try {
+							yield row;
+						} finally {
+							rctx.context.delete(rowDescriptor);
+						}
+
+						// 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,
+		note: `recursiveCTE(${plan.cteName})`
+	};
+}
+
+
+

package/src/runtime/emit/returning.ts

@@ -0,0 +1,48 @@
+import type { ReturningNode } from '../../planner/nodes/returning-node.js';
+import type { Instruction, 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 { buildRowDescriptor } from '../../util/row-descriptor.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) => any>
+	): AsyncIterable<Row> {
+		// Project the results from the executor rows
+		for await (const sourceRow of executorRows) {
+			// Set up the source context - the row is already in the correct flat OLD/NEW format
+			rctx.context.set(sourceRowDescriptor, () => sourceRow);
+
+			try {
+				// 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;
+			} finally {
+				// Clean up source context
+				rctx.context.delete(sourceRowDescriptor);
+			}
+		}
+	}
+
+	// Emit the executor (now always produces rows)
+	const executorInstruction = emitPlanNode(plan.executor, ctx);
+
+	return {
+		params: [executorInstruction, ...projectionEvaluators],
+		run,
+		note: `returning(${plan.projections.length} cols)`
+	};
+}

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

@@ -0,0 +1,43 @@
+import type { ScalarFunctionCallNode } from '../../planner/nodes/function.js';
+import type { Instruction, RuntimeContext } 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';
+
+export function emitScalarFunctionCall(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 any,
+		ctx,
+		`${plan.expression.name}(${plan.operands.length})`
+	);
+}

package/src/runtime/emit/scan.ts

@@ -0,0 +1,88 @@
+import { StatusCode, type Row } from "../../common/types.js";
+import type { TableScanNode } from "../../planner/nodes/scan.js";
+import { QuereusError } from "../../common/errors.js";
+import type { VirtualTable } from "../../vtab/table.js";
+import type { BaseModuleConfig } from "../../vtab/module.js";
+import type { Instruction, RuntimeContext } from "../types.js";
+import type { EmissionContext } from "../emission-context.js";
+import { createValidatedInstruction } from "../emitters.js";
+import { disconnectVTable } from "../utils.js";
+import { buildRowDescriptor } from "../../util/row-descriptor.js";
+
+export function emitSeqScan(plan: TableScanNode, ctx: EmissionContext): Instruction {
+	const tableSchema = plan.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(tableSchema.vtabModuleName);
+	if (!moduleInfo) {
+		throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' not found`, StatusCode.ERROR);
+	}
+
+	// Capture the module info key for runtime retrieval
+	const moduleKey = `vtab_module:${tableSchema.vtabModuleName}`;
+
+	async function* run(runtimeCtx: RuntimeContext): AsyncIterable<Row> {
+		// Use the captured module info instead of doing a fresh lookup
+		const capturedModuleInfo = ctx.getCapturedSchemaObject<{ module: any, auxData?: unknown }>(moduleKey);
+		if (!capturedModuleInfo) {
+			throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' was not captured during emission`, StatusCode.INTERNAL);
+		}
+
+		const module = capturedModuleInfo.module;
+		if (typeof module.xConnect !== 'function') {
+			throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' does not implement xConnect`, StatusCode.MISUSE);
+		}
+
+		let vtabInstance: VirtualTable;
+		try {
+			const options: BaseModuleConfig = {}; // TODO: Populate options from plan.source.tableSchema.vtabArgs or similar if needed
+			vtabInstance = module.xConnect(
+				runtimeCtx.db,
+				capturedModuleInfo.auxData,
+				tableSchema.vtabModuleName,
+				tableSchema.schemaName,
+				tableSchema.name,
+				options
+			);
+		} catch (e: any) {
+			const message = e instanceof Error ? e.message : String(e);
+			throw new QuereusError(`Module '${tableSchema.vtabModuleName}' xConnect failed for table '${tableSchema.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 '${tableSchema.name}' does not support xQuery.`, StatusCode.UNSUPPORTED);
+		}
+
+		try {
+			// Put cursor row into context using row descriptor
+			let row: Row;
+			runtimeCtx.context.set(rowDescriptor, () => row);
+
+			const asyncRowIterable = vtabInstance.xQuery(plan.filterInfo);
+			for await (row of asyncRowIterable) {
+				yield row;
+			}
+
+			// Remove cursor row from context
+			runtimeCtx.context.delete(rowDescriptor);
+		} catch (e: any) {
+			const message = e instanceof Error ? e.message : String(e);
+			throw new QuereusError(`Error during xQuery on table '${tableSchema.name}': ${message}`, e instanceof QuereusError ? e.code : StatusCode.ERROR, e instanceof Error ? e : undefined);
+		} finally {
+			// Properly disconnect the VirtualTable instance
+			await disconnectVTable(runtimeCtx, vtabInstance);
+		}
+	}
+
+	return createValidatedInstruction(
+		[],
+		run,
+		ctx,
+		`scan(${plan.source.tableSchema.name})`
+	);
+}

package/src/runtime/emit/sequencing.ts

@@ -0,0 +1,24 @@
+import type { SequencingNode } from '../../planner/nodes/sequencing-node.js';
+import type { Instruction, RuntimeContext } 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 any,
+		note: `sequencing(${plan.sequenceColumnName})`
+	};
+}

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

@@ -0,0 +1,111 @@
+import type { SetOperationNode } from '../../planner/nodes/set-operation-node.js';
+import type { Instruction, 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 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> {
+    const seen = new Set<string>();
+    const hash = (row: Row) => JSON.stringify(row);
+    for await (const row of leftRows) {
+      const outputRow = createOutputRow(row);
+      const h = hash(outputRow);
+      if (!seen.has(h)) {
+        seen.add(h);
+        yield outputRow; // Let SortNode handle row context
+      }
+    }
+    for await (const row of rightRows) {
+      const outputRow = createOutputRow(row);
+      const h = hash(outputRow);
+      if (!seen.has(h)) {
+        seen.add(h);
+        yield outputRow; // Let SortNode handle row context
+      }
+    }
+  }
+
+  async function* runIntersect(rctx: RuntimeContext, leftRows: AsyncIterable<Row>, rightRows: AsyncIterable<Row>): AsyncIterable<Row> {
+    const leftSet = new Set<string>();
+    const hash = (row: Row) => JSON.stringify(row);
+    const leftRowsArray: Row[] = [];
+    for await (const row of leftRows) {
+      const outputRow = createOutputRow(row);
+      leftSet.add(hash(outputRow));
+      leftRowsArray.push(outputRow);
+    }
+    for await (const row of rightRows) {
+      const outputRow = createOutputRow(row);
+      const h = hash(outputRow);
+      if (leftSet.has(h)) {
+        yield outputRow; // Let SortNode handle row context
+        leftSet.delete(h);
+      }
+    }
+  }
+
+  async function* runExcept(rctx: RuntimeContext, leftRows: AsyncIterable<Row>, rightRows: AsyncIterable<Row>): AsyncIterable<Row> {
+    const rightSet = new Set<string>();
+    const hash = (row: Row) => JSON.stringify(row);
+    const leftRowsArray: Row[] = [];
+    for await (const row of leftRows) {
+      leftRowsArray.push(createOutputRow(row));
+    }
+    for await (const row of rightRows) {
+      rightSet.add(hash(createOutputRow(row)));
+    }
+    for (const outputRow of leftRowsArray) {
+      const h = hash(outputRow);
+      if (!rightSet.has(h)) {
+        yield outputRow; // Let SortNode handle row context
+      }
+    }
+  }
+
+  let runFunc: any;
+  switch (plan.op) {
+    case 'unionAll':
+      runFunc = runUnionAll;
+      break;
+    case 'union':
+      runFunc = runUnionDistinct;
+      break;
+    case 'intersect':
+      runFunc = runIntersect;
+      break;
+    case 'except':
+      runFunc = runExcept;
+      break;
+  }
+
+  return {
+    params: [leftInst, rightInst],
+    run: runFunc as any,
+    note: plan.op
+  };
+}

package/src/runtime/emit/sink.ts

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,78 @@
+import type { SortNode } from '../../planner/nodes/sort.js';
+import type { Instruction, RuntimeContext } 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';
+
+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) {
+			// Set up context for this row using row descriptor
+			ctx.context.set(sourceRowDescriptor, () => sourceRow);
+
+			try {
+				// Evaluate sort key expressions
+				const keys: SqlValue[] = [];
+				for (const keyFunc of sortKeyFunctions) {
+					keys.push(await keyFunc(ctx));
+				}
+
+				rowsWithKeys.push({ row: sourceRow, keys });
+			} finally {
+				// Clean up context for this row
+				ctx.context.delete(sourceRowDescriptor);
+			}
+		}
+
+		// 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 any,
+		note: `sort(${plan.sortKeys.length} keys)`
+	};
+}

package/src/runtime/emit/subquery.ts

@@ -0,0 +1,143 @@
+import type { Instruction, RuntimeContext } from '../types.js';
+import type { InNode, ScalarSubqueryNode, ExistsNode } from '../../planner/nodes/subquery.js';
+import { emitPlanNode } from '../emitters.js';
+import type { SqlValue, Row } from '../../common/types.js';
+import { compareSqlValuesFast, BINARY_COLLATION } from '../../util/comparison.js';
+import type { EmissionContext } from '../emission-context.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import { BTree } from 'inheritree';
+
+export function emitScalarSubquery(plan: ScalarSubqueryNode, ctx: EmissionContext): Instruction {
+
+	async function run(ctx: 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);
+			}
+			seen = true;
+			result = row[0];
+		}
+
+		return result;
+	}
+
+	const innerInstruction = emitPlanNode(plan.subquery, ctx);
+
+	return {
+		params: [innerInstruction],
+		run,
+		note: 'scalar subquery'
+	};
+}
+
+export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
+	if (plan.source) {
+		// IN subquery: expr IN (SELECT ...)
+		async function runSubquery(ctx: RuntimeContext, input: AsyncIterable<Row>, condition: SqlValue): Promise<SqlValue> {
+			// If condition is NULL, result is NULL
+			if (condition === null) {
+				return null;
+			}
+
+			// Build BTree of all values from subquery
+			const tree = new BTree<SqlValue, SqlValue>(
+				(val: SqlValue) => val,
+				(a: SqlValue, b: SqlValue) => compareSqlValuesFast(a, b, BINARY_COLLATION)
+			);
+
+			let hasNull = false;
+			for await (const row of input) {
+				if (row.length > 0) {
+					const rowValue = row[0];
+					if (rowValue === null) {
+						hasNull = true;
+						continue;
+					}
+					tree.insert(rowValue);
+				}
+			}
+
+			// Check if condition exists in tree
+			const value = tree.get(condition);
+			if (value !== undefined) {
+				return 1; // Found a match
+			}
+
+			// No match found - if any value was NULL, result is NULL
+			return hasNull ? null : 0;
+		}
+
+		const sourceInstruction = emitPlanNode(plan.source, ctx);
+		const conditionExpr = emitPlanNode(plan.condition, ctx);
+
+		return {
+			params: [sourceInstruction, conditionExpr],
+			run: runSubquery as any,
+			note: `IN (subquery)`
+		};
+	} else if (plan.values) {
+		// IN value list: expr IN (value1, value2, ...)
+		function runValues(ctx: RuntimeContext, condition: SqlValue, ...values: SqlValue[]): SqlValue {
+			// If condition is NULL, result is NULL
+			if (condition === null) {
+				return null;
+			}
+
+			// Build BTree of all values
+			const tree = new BTree<SqlValue, SqlValue>(
+				(val: SqlValue) => val,
+				(a: SqlValue, b: SqlValue) => compareSqlValuesFast(a, b, BINARY_COLLATION)
+			);
+
+			let hasNull = false;
+			for (const value of values) {
+				if (value === null) {
+					hasNull = true;
+					continue;
+				}
+				tree.insert(value);
+			}
+
+			// Check if condition exists in tree
+			const path = tree.find(condition);
+			if (path.on) {
+				return 1; // Found a match
+			}
+
+			// No match found - if any value was NULL, result is NULL
+			return hasNull ? null : 0;
+		}
+
+		const conditionExpr = emitPlanNode(plan.condition, ctx);
+		const valueExprs = plan.values.map(val => emitPlanNode(val, ctx));
+
+		return {
+			params: [conditionExpr, ...valueExprs],
+			run: runValues as any,
+			note: `IN (${plan.values.length} 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(ctx: RuntimeContext, input: AsyncIterable<Row>): Promise<SqlValue> {
+		for await (const _row of input) {
+			return 1; // First row => TRUE
+		}
+		return 0; // Empty => FALSE
+	}
+
+	const innerInstruction = emitPlanNode(plan.subquery, ctx);
+
+	return {
+		params: [innerInstruction],
+		run,
+		note: 'EXISTS'
+	};
+}