@quereus/quereus 0.1.0 → 0.2.0

package/src/runtime/emit/binary.ts

@@ -32,8 +32,6 @@ export function emitBinaryOp(plan: BinaryOpNode, ctx: EmissionContext): Instruct
 		case 'OR':
 		case 'XOR':
 			return emitLogicalOp(plan, ctx);
-		case 'BETWEEN':
-			return emitBetweenOp(plan, ctx);
 		case 'LIKE':
 			return emitLikeOp(plan, ctx);
 		// TODO: emitBitwise
@@ -289,47 +287,3 @@ export function emitLikeOp(plan: BinaryOpNode, ctx: EmissionContext): Instructio
 	};
 }
 
-export function emitBetweenOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	// Pre-resolve collation function for optimal performance (using BINARY as default for BETWEEN)
-	const collationFunc = resolveCollation('BINARY');
-
-	function run(ctx: RuntimeContext, value: SqlValue, lowerBound: SqlValue, upperBound: SqlValue): SqlValue {
-		// SQL BETWEEN logic: value BETWEEN lower AND upper
-		// Equivalent to: value >= lower AND value <= upper
-		// NULL handling: if any operand is NULL, result is NULL
-		if (value === null || lowerBound === null || upperBound === null) {
-			return null;
-		}
-
-		// Use pre-resolved collation function for optimal performance
-		const lowerResult = compareSqlValuesFast(value, lowerBound, collationFunc);
-		const upperResult = compareSqlValuesFast(value, upperBound, collationFunc);
-
-		// value >= lowerBound AND value <= upperBound
-		return (lowerResult >= 0 && upperResult <= 0) ? 1 : 0;
-	}
-
-	const valueExpr = emitPlanNode(plan.left, ctx);
-
-	// The right side should be an AND expression with lower and upper bounds
-	const rightNode = plan.right;
-	if (rightNode.nodeType !== 'BinaryOp') {
-		throw new QuereusError(`Expected binary AND expression for BETWEEN bounds`, StatusCode.INTERNAL);
-	}
-	const rightBinaryNode = rightNode as BinaryOpNode;
-	if (rightBinaryNode.expression.operator !== 'AND') {
-		throw new QuereusError(`Expected AND operator for BETWEEN bounds, got ${rightBinaryNode.expression.operator}`, StatusCode.INTERNAL);
-	}
-
-	const lowerExpr = emitPlanNode(rightBinaryNode.left, ctx);
-	const upperExpr = emitPlanNode(rightBinaryNode.right, ctx);
-
-	return {
-		params: [valueExpr, lowerExpr, upperExpr],
-		run: run as InstructionRun,
-		note: 'BETWEEN(between)'
-	};
-}
-
-
-

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

@@ -1,45 +1,12 @@
 import type { ColumnReferenceNode } from '../../planner/nodes/reference.js';
 import type { Instruction, RuntimeContext } from '../types.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode, type SqlValue } from '../../common/types.js';
+import type { SqlValue } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
-import { createLogger } from '../../common/logger.js';
-
-const log = createLogger('runtime:context:lookup');
+import { resolveAttribute } from '../context-helpers.js';
 
 export function emitColumnReference(plan: ColumnReferenceNode, _ctx: EmissionContext): Instruction {
 	function run(rctx: RuntimeContext): SqlValue {
-		log('Looking up column %s (attr#%d)', plan.expression.name, plan.attributeId);
-
-		// Log available contexts for debugging
-		const availableContexts: string[] = [];
-		for (const [descriptor] of rctx.context.entries()) {
-			const attrs = Object.keys(descriptor).filter(k => descriptor[parseInt(k)] !== undefined);
-			availableContexts.push(`[attrs: ${attrs.join(',')}]`);
-		}
-		log('Available contexts: %O', availableContexts);
-
-		// Use deterministic lookup based on attribute ID
-		for (const [descriptor, rowGetter] of rctx.context.entries()) {
-			const columnIndex = descriptor[plan.attributeId];
-			if (columnIndex !== undefined) {
-				const row = rowGetter();
-				if (Array.isArray(row) && columnIndex < row.length) {
-					const value = row[columnIndex];
-					log('Successfully resolved %s (attr#%d) to value: %O from row: %O at index %d', plan.expression.name, plan.attributeId, value, row, columnIndex);
-					return value;
-				}
-			}
-		}
-
-		log('Failed to resolve %s (attr#%d) - no matching context found', plan.expression.name, plan.attributeId);
-		throw new QuereusError(
-			`No row context found for column ${plan.expression.name} (attr#${plan.attributeId}). The column reference must be evaluated within the context of its source relation.`,
-			StatusCode.ERROR,
-			undefined,
-			plan.expression.loc?.start.line,
-			plan.expression.loc?.start.column
-		);
+		return resolveAttribute(rctx, plan.attributeId, plan.expression.name);
 	}
 
 	return {

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

@@ -6,137 +6,23 @@ 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 { ColumnSchema } from '../../schema/column.js';
-import type { RowDescriptor } from '../../planner/nodes/plan-node.js';
 import { RowOp } from '../../schema/table.js';
-import { buildExpression } from '../../planner/building/expression.js';
-import { GlobalScope } from '../../planner/scopes/global.js';
-import { RegisteredScope } from '../../planner/scopes/registered.js';
-import { ColumnReferenceNode } from '../../planner/nodes/reference.js';
-import * as AST from '../../parser/ast.js';
-import { BuildTimeDependencyTracker } from '../../planner/planning-context.js';
+import { withAsyncRowContext } from '../context-helpers.js';
 
 export function emitConstraintCheck(plan: ConstraintCheckNode, ctx: EmissionContext): Instruction {
 	// Get the table schema to access constraints
 	const tableSchema = plan.table.tableSchema;
 
-	// Create flat row descriptor that includes both OLD and NEW attributes
-	const flatRowDescriptor: RowDescriptor = [];
+	// Use the pre-built flat row descriptor from the plan
+	const flatRowDescriptor = plan.flatRowDescriptor;
 
-	// OLD attributes are at indices 0..n-1, NEW attributes at n..2n-1
-	if (plan.oldRowDescriptor) {
-		for (const attrIdStr in plan.oldRowDescriptor) {
-			const attrId = parseInt(attrIdStr);
-			const columnIndex = plan.oldRowDescriptor[attrId];
-			if (columnIndex !== undefined) {
-				flatRowDescriptor[attrId] = columnIndex; // OLD section: 0..n-1
-			}
-		}
-	}
-
-	if (plan.newRowDescriptor) {
-		for (const attrIdStr in plan.newRowDescriptor) {
-			const attrId = parseInt(attrIdStr);
-			const columnIndex = plan.newRowDescriptor[attrId];
-			if (columnIndex !== undefined) {
-				flatRowDescriptor[attrId] = tableSchema.columns.length + columnIndex; // NEW section: n..2n-1
-			}
-		}
-	}
-
-	// Discover attribute mappings for constraint building
-	const newAttrIdByCol: Record<string, number> = {};
-	const oldAttrIdByCol: Record<string, number> = {};
-
-	if (plan.newRowDescriptor) {
-		for (const attrIdStr in plan.newRowDescriptor) {
-			const attrId = parseInt(attrIdStr);
-			const columnIndex = plan.newRowDescriptor[attrId];
-			if (columnIndex !== undefined && columnIndex < tableSchema.columns.length) {
-				const column = tableSchema.columns[columnIndex];
-				newAttrIdByCol[column.name.toLowerCase()] = attrId;
-			}
-		}
-	}
-
-	if (plan.oldRowDescriptor) {
-		for (const attrIdStr in plan.oldRowDescriptor) {
-			const attrId = parseInt(attrIdStr);
-			const columnIndex = plan.oldRowDescriptor[attrId];
-			if (columnIndex !== undefined && columnIndex < tableSchema.columns.length) {
-				const column = tableSchema.columns[columnIndex];
-				oldAttrIdByCol[column.name.toLowerCase()] = attrId;
-			}
-		}
-	}
-
-	const checkConstraintData = tableSchema.checkConstraints
-		.filter((constraint: RowConstraintSchema) => shouldCheckConstraint(constraint, plan.operation))
-		.map((constraint: RowConstraintSchema) => {
-			// Build a PlanNode from the AST expression
-			// Create a scope that has access to the table columns for constraint evaluation
-			const scope = new RegisteredScope(new GlobalScope(ctx.db.schemaManager));
-
-			// Register table columns for constraint evaluation using flat row attributes
-			tableSchema.columns.forEach((tableColumn: ColumnSchema, tableColIndex: number) => {
-				const colNameLower = tableColumn.name.toLowerCase();
-
-				// Register NEW.<col> (defaults to NEW for unqualified references)
-				const newAttrId = newAttrIdByCol[colNameLower];
-				if (newAttrId !== undefined) {
-					// Unqualified column name (defaults to NEW)
-					scope.registerSymbol(colNameLower, (exp, s) =>
-						new ColumnReferenceNode(s, exp as AST.ColumnExpr, {
-							typeClass: 'scalar',
-							affinity: tableColumn.affinity,
-							nullable: !tableColumn.notNull,
-							isReadOnly: false
-						}, newAttrId, tableColIndex));
-
-					// NEW.<col>
-					scope.registerSymbol(`new.${colNameLower}`, (exp, s) =>
-						new ColumnReferenceNode(s, exp as AST.ColumnExpr, {
-							typeClass: 'scalar',
-							affinity: tableColumn.affinity,
-							nullable: !tableColumn.notNull,
-							isReadOnly: false
-						}, newAttrId, tableColIndex));
-				}
-
-				// Register OLD.<col>
-				const oldAttrId = oldAttrIdByCol[colNameLower];
-				if (oldAttrId !== undefined) {
-					scope.registerSymbol(`old.${colNameLower}`, (exp, s) =>
-						new ColumnReferenceNode(s, exp as AST.ColumnExpr, {
-							typeClass: 'scalar',
-							affinity: tableColumn.affinity,
-							nullable: true, // OLD values can be NULL
-							isReadOnly: false
-						}, oldAttrId, tableColIndex));
-				}
-			});
+	// Emit evaluator instructions for each pre-built constraint expression
+	const checkEvaluators = plan.constraintChecks.map(check =>
+		emitCallFromPlan(check.expression, ctx)
+	);
 
-			const exprPlanNode = buildExpression(
-								{
-					scope,
-					db: ctx.db,
-					parameters: {},
-					schemaManager: ctx.db.schemaManager,
-					schemaDependencies: new BuildTimeDependencyTracker(), // Not used in constraint evaluation
-					schemaCache: new Map() // Not used in constraint evaluation
-				},
-				constraint.expr
-			);
-
-			return {
-				constraint,
-				evaluator: emitCallFromPlan(exprPlanNode, ctx)
-			};
-		});
-
-	// Extract just the constraint metadata and evaluator functions
-	const constraintMetadata = checkConstraintData.map(item => item.constraint);
-	const checkEvaluators = checkConstraintData.map(item => item.evaluator);
+	// Extract just the constraint metadata for the runtime checker
+	const constraintMetadata = plan.constraintChecks.map(c => c.constraint);
 
 	async function* run(rctx: RuntimeContext, inputRows: AsyncIterable<Row>, ...evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>): AsyncIterable<Row> {
 		if (!inputRows) {
@@ -146,20 +32,16 @@ export function emitConstraintCheck(plan: ConstraintCheckNode, ctx: EmissionCont
 		for await (const inputRow of inputRows) {
 			const flatRow = inputRow;
 
-			// Set up single flat context
-			rctx.context.set(flatRowDescriptor, () => flatRow);
-
-			try {
+			const result = await withAsyncRowContext(rctx, flatRowDescriptor, () => flatRow, 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
-				yield flatRow;
-			} finally {
-				// Clean up flat context
-				rctx.context.delete(flatRowDescriptor);
-			}
+				return flatRow;
+			});
+
+			yield result;
 		}
 	}
 
@@ -169,7 +51,7 @@ export function emitConstraintCheck(plan: ConstraintCheckNode, ctx: EmissionCont
 	return {
 		params: [sourceInstruction, ...checkEvaluators],
 		run: run as any,
-		note: `constraintCheck(${plan.operation})`
+		note: `constraintCheck(${plan.operation}, ${plan.constraintChecks.length} checks)`
 	};
 }
 
@@ -243,7 +125,7 @@ async function checkCheckConstraints(
 	constraintMetadata: Array<RowConstraintSchema>,
 	evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>
 ): Promise<void> {
-	// Evaluate each CHECK constraint
+	// Evaluate each CHECK constraint using pre-built evaluators
 	for (let i = 0; i < constraintMetadata.length; i++) {
 		const constraint = constraintMetadata[i];
 		const evaluator = evaluatorFunctions[i];
@@ -256,8 +138,6 @@ async function checkCheckConstraints(
 			// It fails only if result is false or 0 (SQLite-style numeric boolean)
 			if (result === false || result === 0) {
 				// Generate a proper constraint name if none was provided
-				// IMPORTANT: Use the original index from the full tableSchema.checkConstraints array
-				// not the filtered index, to get the correct constraint name
 				const constraintName = constraint.name || generateDefaultConstraintName(tableSchema, constraint);
 				throw new QuereusError(
 					`CHECK constraint failed: ${constraintName}`,
@@ -273,13 +153,8 @@ async function checkCheckConstraints(
 	}
 }
 
-function shouldCheckConstraint(constraint: RowConstraintSchema, operation: RowOp): boolean {
-	// Check if the current operation is in the constraint's operations bitmask
-	return (constraint.operations & operation) !== 0;
-}
-
 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'}`;
+	return `_check_${originalIndex >= 0 ? originalIndex : 'unknown'}`;
 }

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

@@ -3,73 +3,36 @@ 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, RuntimeContext } from '../types.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { PlanNodeType } from '../../planner/nodes/plan-node-type.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;
 
-	// Check if this is an internal recursive reference (inside the recursive case)
-	// These use table context to access the working table
-	const isInternalRecursiveRef = plan.source.nodeType === PlanNodeType.CTE && plan.source.isRecursive;
-
-	if (isInternalRecursiveRef) {
-		// Internal recursive CTE reference: Look up the working table from table contexts
-		async function* run(rctx: RuntimeContext): AsyncIterable<Row> {
-			const tableGetter = rctx.tableContexts.get(plan.source.tableDescriptor);
-			if (!tableGetter) {
-				throw new QuereusError(
-					`Recursive CTE '${plan.source.cteName}' not found in table context`,
-					StatusCode.INTERNAL
-				);
-			}
-
-			// Execute the working table and yield each row
-			for await (const row of tableGetter()) {
-				// Set up context for this row using row descriptor
-				rctx.context.set(rowDescriptor, () => row);
-				try {
-					yield row;
-				} finally {
-					// Clean up context
-					rctx.context.delete(rowDescriptor);
-				}
-			}
-		}
+	logger(`Emitting CTE reference ${cteAlias} with attrs=[${attrs.map(a => a.id).join(',')}]`);
 
-		return createValidatedInstruction(
-			[], // No instruction parameters - data comes from table context
-			run as any,
-			ctx,
-			`cte_ref(internal_recursive ${plan.source.cteName}${plan.alias ? ` AS ${plan.alias}` : ''})`
-		);
-	} else {
-		// External CTE reference (or non-recursive): Use normal instruction parameter approach
-		async function* run(rctx: RuntimeContext, cteResult: AsyncIterable<Row>): AsyncIterable<Row> {
-			// Execute the CTE and yield each row
-			for await (const row of cteResult) {
-				// Set up context for this row using row descriptor
-				rctx.context.set(rowDescriptor, () => row);
-				try {
-					yield row;
-				} finally {
-					// Clean up context
-					rctx.context.delete(rowDescriptor);
-				}
-			}
-		}
+	// 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);
+	// Emit the underlying CTE
+	const cteInstruction = emitPlanNode(plan.source, ctx);
 
-		return createValidatedInstruction(
-			[cteInstruction],
-			run as any,
-			ctx,
-			`cte_ref(${plan.source.isRecursive ? 'external_recursive' : 'non_recursive'} ${plan.source.cteName}${plan.alias ? ` AS ${plan.alias}` : ''})`
-		);
-	}
+	return createValidatedInstruction(
+		[cteInstruction],
+		run as any,
+		ctx,
+		`cte_ref(${plan.source.cteName}${plan.alias ? ` AS ${plan.alias}` : ''})`
+	);
 }

package/src/runtime/emit/distinct.ts

@@ -6,6 +6,7 @@ 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)
@@ -24,13 +25,7 @@ export function emitDistinct(plan: DistinctNode, ctx: EmissionContext): Instruct
 
 			if (newPath.on) {
 				// This is a new distinct row - set up context and yield it
-				ctx.context.set(outputRowDescriptor, () => sourceRow);
-				try {
-					yield sourceRow;
-				} finally {
-					// Clean up context for this row
-					ctx.context.delete(outputRowDescriptor);
-				}
+				yield await withRowContext(ctx, outputRowDescriptor, () => sourceRow, () => sourceRow);
 			}
 		}
 	}

package/src/runtime/emit/filter.ts

@@ -4,6 +4,7 @@ import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
 import { type Row } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
 import { buildRowDescriptor } from '../../util/row-descriptor.js';
+import { withRowContextGenerator } from '../context-helpers.js';
 
 export function emitFilter(plan: FilterNode, ctx: EmissionContext): Instruction {
 	const sourceInstruction = emitPlanNode(plan.source, ctx);
@@ -13,20 +14,12 @@ export function emitFilter(plan: FilterNode, ctx: EmissionContext): Instruction
 	const sourceRowDescriptor = buildRowDescriptor(plan.source.getAttributes());
 
 	async function* run(ctx: RuntimeContext, source: AsyncIterable<Row>, predicate: (ctx: RuntimeContext) => any): AsyncIterable<Row> {
-		for await (const sourceRow of source) {
-			// Set up context for this row using row descriptor
-			ctx.context.set(sourceRowDescriptor, () => sourceRow);
-
-			try {
-				const result = await predicate(ctx);
-				if (result) {
-					yield sourceRow;
-				}
-			} finally {
-				// Clean up context for this row
-				ctx.context.delete(sourceRowDescriptor);
+		yield* withRowContextGenerator(ctx, sourceRowDescriptor, source, async function* (sourceRow) {
+			const result = await predicate(ctx);
+			if (result) {
+				yield sourceRow;
 			}
-		}
+		});
 	}
 
 	return {

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

@@ -0,0 +1,37 @@
+import type { Row } from '../../common/types.js';
+import type { InternalRecursiveCTERefNode } from '../../planner/nodes/internal-recursive-cte-ref-node.js';
+import type { EmissionContext } from '../emission-context.js';
+import { createValidatedInstruction } from '../emitters.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import { buildRowDescriptor } from '../../util/row-descriptor.js';
+import { withRowContextGenerator } from '../context-helpers.js';
+
+export function emitInternalRecursiveCTERef(plan: InternalRecursiveCTERefNode, ctx: EmissionContext): Instruction {
+	// Create row descriptor for output attributes
+	const rowDescriptor = buildRowDescriptor(plan.getAttributes());
+
+	async function* run(rctx: RuntimeContext): AsyncIterable<Row> {
+		// Look up the working table from runtime context using the tableDescriptor
+		const tableGetter = rctx.tableContexts.get(plan.workingTableDescriptor);
+		if (!tableGetter) {
+			throw new QuereusError(
+				`Internal recursive CTE '${plan.cteName}' working table not found in context`,
+				StatusCode.INTERNAL
+			);
+		}
+
+		// Execute the working table and yield each row
+		yield* withRowContextGenerator(rctx, rowDescriptor, tableGetter(), async function* (row) {
+			yield row;
+		});
+	}
+
+	return createValidatedInstruction(
+		[], // No instruction parameters - data comes from table context
+		run,
+		ctx,
+		`internal_recursive_ref(${plan.cteName}${plan.alias ? ` AS ${plan.alias}` : ''})`
+	);
+}

package/src/runtime/emit/join.ts

@@ -6,6 +6,7 @@ import type { EmissionContext } from '../emission-context.js';
 import { createLogger } from '../../common/logger.js';
 import { compareSqlValues } from '../../util/comparison.js';
 import { buildRowDescriptor } from '../../util/row-descriptor.js';
+import { createRowSlot } from '../context-helpers.js';
 
 const log = createLogger('runtime:emit:join');
 
@@ -28,41 +29,41 @@ export function emitLoopJoin(plan: JoinNode, ctx: EmissionContext): Instruction
 		log('Starting %s join between %d left attrs and %d right attrs',
 			joinType.toUpperCase(), leftAttributes.length, rightAttributes.length);
 
-		// Process left side and join with right (pure streaming)
-		for await (const leftRow of leftSource) {
-			// Set up left context
-			rctx.context.set(leftRowDescriptor, () => leftRow);
+		// Create row slots for efficient context management
+		const leftSlot = createRowSlot(rctx, leftRowDescriptor);
+		const rightSlot = createRowSlot(rctx, rightRowDescriptor);
+
+		try {
+			// Process left side and join with right (pure streaming)
+			for await (const leftRow of leftSource) {
+				// Set up left context
+				leftSlot.set(leftRow);
 
-			try {
 				let leftMatched = false;
 
 				// Stream through right side for each left row
 				for await (const rightRow of rightCallback(rctx)) {
 					// Set up right context
-					rctx.context.set(rightRowDescriptor, () => rightRow);
-
-					try {
-						// Evaluate join condition
-						let conditionMet = true;
-
-						if (conditionCallback) {
-							// Evaluate the join condition using the callback provided by scheduler
-							const conditionResult = await conditionCallback(rctx);
-							conditionMet = !!conditionResult; // Convert to boolean
-						} else if (plan.usingColumns) {
-							// Handle USING condition: check equality of specified columns
-							conditionMet = evaluateUsingCondition(leftRow, rightRow, plan.usingColumns, leftAttributes, rightAttributes);
-						} else if (joinType === 'cross') {
-							// Cross join - always true
-							conditionMet = true;
-						}
-
-						if (conditionMet) {
-							leftMatched = true;
-							yield [...leftRow, ...rightRow] as Row;
-						}
-					} finally {
-						rctx.context.delete(rightRowDescriptor);
+					rightSlot.set(rightRow);
+
+					// Evaluate join condition
+					let conditionMet = true;
+
+					if (conditionCallback) {
+						// Evaluate the join condition using the callback provided by scheduler
+						const conditionResult = await conditionCallback(rctx);
+						conditionMet = !!conditionResult; // Convert to boolean
+					} else if (plan.usingColumns) {
+						// Handle USING condition: check equality of specified columns
+						conditionMet = evaluateUsingCondition(leftRow, rightRow, plan.usingColumns, leftAttributes, rightAttributes);
+					} else if (joinType === 'cross') {
+						// Cross join - always true
+						conditionMet = true;
+					}
+
+					if (conditionMet) {
+						leftMatched = true;
+						yield [...leftRow, ...rightRow] as Row;
 					}
 				}
 
@@ -73,22 +74,23 @@ export function emitLoopJoin(plan: JoinNode, ctx: EmissionContext): Instruction
 					const outputRow = [...leftRow, ...nullPadding] as Row;
 					yield outputRow;
 				}
-			} finally {
-				rctx.context.delete(leftRowDescriptor);
 			}
-		}
 
-		// Handle right outer join semantics - we need to track which right rows were matched
-		// For now, we'll handle this in a simpler way by iterating again for right/full outer joins
-		if (joinType === 'right' || joinType === 'full') {
-			// For right outer joins, we need to find unmatched right rows
-			// This is more complex and less efficient - a real implementation would track matches
-			// For now, we'll implement a simplified version
-			log('Right/full outer join - checking for unmatched right rows');
-
-			// We'd need to track which right rows were matched during the main loop
-			// For now, we'll skip this implementation detail
-			// TODO: Implement proper right outer join semantics
+			// Handle right outer join semantics - we need to track which right rows were matched
+			// For now, we'll handle this in a simpler way by iterating again for right/full outer joins
+			if (joinType === 'right' || joinType === 'full') {
+				// For right outer joins, we need to find unmatched right rows
+				// This is more complex and less efficient - a real implementation would track matches
+				// For now, we'll implement a simplified version
+				log('Right/full outer join - checking for unmatched right rows');
+
+				// We'd need to track which right rows were matched during the main loop
+				// For now, we'll skip this implementation detail
+				// TODO: Implement proper right outer join semantics
+			}
+		} finally {
+			leftSlot.close();
+			rightSlot.close();
 		}
 	}