@quereus/quereus 0.7.3 → 0.7.5

package/src/runtime/emit/binary.ts

@@ -1,357 +0,0 @@
-import { StatusCode } from "../../common/types.js";
-import { QuereusError } from "../../common/errors.js";
-import type { SqlValue } from "../../common/types.js";
-import type { Instruction, InstructionRun, RuntimeContext } from "../types.js";
-import type { BinaryOpNode } from "../../planner/nodes/scalar.js";
-import { emitPlanNode } from "../emitters.js";
-import { compareSqlValuesFast, resolveCollation } from "../../util/comparison.js";
-import { coerceForComparison, coerceToNumberForArithmetic } from "../../util/coercion.js";
-import { simpleLike } from "../../util/patterns.js";
-import type { EmissionContext } from "../emission-context.js";
-import { tryTemporalArithmetic, tryTemporalComparison } from "./temporal-arithmetic.js";
-
-export function emitBinaryOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	// Normalize operator to uppercase for case-insensitive matching of keywords
-	const operator = plan.expression.operator.toUpperCase();
-
-	switch (operator) {
-		case '+':
-		case '-':
-		case '*':
-		case '/':
-		case '%':
-			return emitNumericOp(plan, ctx);
-		case '=':
-		case '==':
-		case '!=':
-		case '<>':
-		case '<':
-		case '<=':
-		case '>':
-		case '>=':
-			return emitComparisonOp(plan, ctx);
-		case '||':
-			return emitConcatOp(plan, ctx);
-		case 'AND':
-		case 'OR':
-		case 'XOR':
-			return emitLogicalOp(plan, ctx);
-		case 'LIKE':
-			return emitLikeOp(plan, ctx);
-		// TODO: emitBitwise
-		default:
-			throw new QuereusError(`Unsupported binary operator: ${plan.expression.operator}`, StatusCode.UNSUPPORTED);
-	}
-}
-
-export function emitNumericOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	let inner: (v1: number, v2: number) => number;
-	let innerBigInt: (v1: bigint, v2: bigint) => bigint;
-
-	switch (plan.expression.operator) {
-		case '+':
-			inner = (v1, v2) => v1 + v2;
-			innerBigInt = (v1, v2) => v1 + v2;
-			break;
-		case '-':
-			inner = (v1, v2) => v1 - v2;
-			innerBigInt = (v1, v2) => v1 - v2;
-			break;
-		case '*':
-			inner = (v1, v2) => v1 * v2;
-			innerBigInt = (v1, v2) => v1 * v2;
-			break;
-		case '/':
-			inner = (v1, v2) => v1 / v2;
-			innerBigInt = (v1, v2) => v1 / v2;
-			break;
-		case '%':
-			inner = (v1, v2) => v1 % v2;
-			innerBigInt = (v1, v2) => v1 % v2;
-			break;
-		default:
-			throw new QuereusError(`Unsupported numeric operator: ${plan.expression.operator}`, StatusCode.UNSUPPORTED);
-	}
-
-	function run(ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue {
-		// Try temporal arithmetic first
-		const temporalResult = tryTemporalArithmetic(plan.expression.operator, v1, v2);
-		if (temporalResult !== undefined) {
-			return temporalResult;
-		}
-
-		// Fall back to numeric arithmetic
-		if (v1 !== null && v2 !== null) {
-			if (typeof v1 === 'bigint' || typeof v2 === 'bigint') {
-				try {
-					return innerBigInt(v1 as bigint, v2 as bigint);
-				} catch {
-					return null;
-				}
-			} else {
-				// Use shared coercion function for arithmetic context
-				const n1 = coerceToNumberForArithmetic(v1);
-				const n2 = coerceToNumberForArithmetic(v2);
-
-				try {
-					const result = inner(n1, n2);
-					if (!Number.isFinite(result)) {
-						return null;
-					}
-					return result;
-				} catch {
-					return null;
-				}
-			}
-		}
-		return null;
-	}
-
-	const leftExpr = emitPlanNode(plan.left, ctx);
-	const rightExpr = emitPlanNode(plan.right, ctx);
-
-	return {
-		params: [leftExpr, rightExpr],
-		run: run as InstructionRun,
-		note: `${plan.expression.operator}(numeric)`
-	};
-}
-
-export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	let run: (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue) => SqlValue;
-
-	// Determine collation to use for comparison
-	const leftType = plan.left.getType();
-	const rightType = plan.right.getType();
-	let collationName = 'BINARY';
-
-	// Use collation from either operand (right side takes precedence for COLLATE expressions)
-	if (rightType.collationName) {
-		collationName = rightType.collationName;
-	} else if (leftType.collationName) {
-		collationName = leftType.collationName;
-	}
-
-	// Pre-resolve collation function for optimal performance
-	const collationFunc = resolveCollation(collationName);
-
-	const operator = plan.expression.operator;
-
-	switch (operator) {
-		case '=':
-		case '==':
-			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
-				// SQL comparison: NULL = anything -> NULL
-				if (v1 === null || v2 === null) return null;
-
-				// Try temporal comparison first
-				const temporalResult = tryTemporalComparison(operator, v1, v2);
-				if (temporalResult !== undefined) {
-					return temporalResult;
-				}
-
-				// Apply type coercion before comparison
-				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) === 0;
-			};
-			break;
-		case '!=':
-		case '<>':
-			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
-				// SQL comparison: NULL != anything -> NULL
-				if (v1 === null || v2 === null) return null;
-
-				// Try temporal comparison first
-				const temporalResult = tryTemporalComparison(operator, v1, v2);
-				if (temporalResult !== undefined) {
-					return temporalResult;
-				}
-
-				// Apply type coercion before comparison
-				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) !== 0;
-			};
-			break;
-		case '<':
-			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
-				// SQL comparison: NULL < anything -> NULL
-				if (v1 === null || v2 === null) return null;
-
-				// Try temporal comparison first
-				const temporalResult = tryTemporalComparison(operator, v1, v2);
-				if (temporalResult !== undefined) {
-					return temporalResult;
-				}
-
-				// Apply type coercion before comparison
-				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) < 0;
-			};
-			break;
-		case '<=':
-			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
-				// SQL comparison: NULL <= anything -> NULL
-				if (v1 === null || v2 === null) return null;
-
-				// Try temporal comparison first
-				const temporalResult = tryTemporalComparison(operator, v1, v2);
-				if (temporalResult !== undefined) {
-					return temporalResult;
-				}
-
-				// Apply type coercion before comparison
-				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) <= 0;
-			};
-			break;
-		case '>':
-			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
-				// SQL comparison: NULL > anything -> NULL
-				if (v1 === null || v2 === null) {
-					return null;
-				}
-
-				// Try temporal comparison first
-				const temporalResult = tryTemporalComparison(operator, v1, v2);
-				if (temporalResult !== undefined) {
-					return temporalResult;
-				}
-
-				// Apply type coercion before comparison
-				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) > 0;
-			};
-			break;
-		case '>=':
-			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
-				// SQL comparison: NULL >= anything -> NULL
-				if (v1 === null || v2 === null) return null;
-
-				// Try temporal comparison first
-				const temporalResult = tryTemporalComparison(operator, v1, v2);
-				if (temporalResult !== undefined) {
-					return temporalResult;
-				}
-
-				// Apply type coercion before comparison
-				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) >= 0;
-			};
-			break;
-		default:
-			throw new QuereusError(`Unsupported comparison operator: ${operator}`, StatusCode.UNSUPPORTED);
-	}
-
-	const leftExpr = emitPlanNode(plan.left, ctx);
-	const rightExpr = emitPlanNode(plan.right, ctx);
-
-	return {
-		params: [leftExpr, rightExpr],
-		run: run as InstructionRun,
-		note: `${plan.expression.operator}(compare${collationName !== 'BINARY' ? ` ${collationName}` : ''})`
-	};
-}
-
-export function emitConcatOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	function run(ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue {
-		// SQL concatenation: NULL || anything -> NULL
-		if (v1 === null || v2 === null) return null;
-
-		// Convert both operands to strings
-		const s1 = String(v1);
-		const s2 = String(v2);
-		return s1 + s2;
-	}
-
-	const leftExpr = emitPlanNode(plan.left, ctx);
-	const rightExpr = emitPlanNode(plan.right, ctx);
-
-	return {
-		params: [leftExpr, rightExpr],
-		run: run as InstructionRun,
-		note: '||(concat)'
-	};
-}
-
-export function emitLogicalOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	// Normalize operator to uppercase for case-insensitive matching
-	const operator = plan.expression.operator.toUpperCase();
-
-	function run(ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue {
-		// SQL three-valued logic
-		switch (operator) {
-			case 'AND': {
-				// NULL AND x -> NULL if x is true or NULL, otherwise false
-				// false AND x -> false
-				// true AND x -> x
-				if (v1 === null) {
-					return (v2 === null || v2) ? null : false;
-				}
-				if (!v1) return false;
-				return v2 === null ? null : (v2 ? true : false);
-			}
-
-			case 'OR': {
-				// NULL OR x -> NULL if x is false or NULL, otherwise true
-				// true OR x -> true
-				// false OR x -> x
-				if (v1 === null) {
-					return (v2 === null || !v2) ? null : true;
-				}
-				if (v1) return true;
-				return v2 === null ? null : (v2 ? true : false);
-			}
-
-			case 'XOR': {
-				// NULL XOR x -> NULL
-				// x XOR NULL -> NULL
-				// false XOR false -> false
-				// false XOR true -> true
-				// true XOR false -> true
-				// true XOR true -> false
-				if (v1 === null || v2 === null) return null;
-				const b1 = !!v1;
-				const b2 = !!v2;
-				return b1 !== b2;
-			}
-
-			default:
-				throw new QuereusError(`Unsupported logical operator: ${plan.expression.operator}`, StatusCode.UNSUPPORTED);
-		}
-	}
-
-	const leftExpr = emitPlanNode(plan.left, ctx);
-	const rightExpr = emitPlanNode(plan.right, ctx);
-
-	return {
-		params: [leftExpr, rightExpr],
-		run: run as InstructionRun,
-		note: `${plan.expression.operator}(logical)`
-	};
-}
-
-export function emitLikeOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	function run(ctx: RuntimeContext, text: SqlValue, pattern: SqlValue): SqlValue {
-		// SQL LIKE logic: text LIKE pattern
-		// NULL handling: if either operand is NULL, result is NULL
-		if (text === null || pattern === null) {
-			return null;
-		}
-
-		// Convert both operands to strings and perform LIKE matching
-		const textStr = String(text);
-		const patternStr = String(pattern);
-
-		return simpleLike(patternStr, textStr);
-	}
-
-	const leftExpr = emitPlanNode(plan.left, ctx);
-	const rightExpr = emitPlanNode(plan.right, ctx);
-
-	return {
-		params: [leftExpr, rightExpr],
-		run: run as InstructionRun,
-		note: 'LIKE(like)'
-	};
-}
-

package/src/runtime/emit/block.ts

@@ -1,23 +0,0 @@
-import type { BlockNode } from '../../planner/nodes/block.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { emitPlanNode } from '../emitters.js';
-import type { RuntimeValue, OutputValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { PlanNodeType } from '../../planner/nodes/plan-node-type.js';
-
-export function emitBlock(plan: BlockNode, ctx: EmissionContext): Instruction {
-	// For blocks, our result is the last statement that is not a sink (void)
-	const valueIndex = plan.statements.findLastIndex(stmt => stmt.nodeType !== PlanNodeType.Sink);
-
-	async function run(ctx: RuntimeContext, ...args: RuntimeValue[]): Promise<OutputValue> {
-		return valueIndex === -1 ? null : args[valueIndex];
-	}
-
-	const statements = plan.statements.map(stmt => emitPlanNode(stmt, ctx));
-
-	return {
-		params: statements,
-		run: run as InstructionRun,
-		note: `block(${plan.statements.length} stmts, result idx: ${valueIndex})`
-	};
-}

package/src/runtime/emit/cache.ts

@@ -1,64 +0,0 @@
-import type { CacheNode } from '../../planner/nodes/cache-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 { emitCallFromPlan } from '../emitters.js';
-import { streamWithCache, createCacheState, type SharedCacheConfig } from '../cache/shared-cache.js';
-import { buffered, traced } from '../async-util.js';
-import { isDebugEnabled } from '../../util/environment.js';
-
-/**
- * Usage example for other emitters needing caching (NLJ inner caching, CTE materialization):
- *
- * ```typescript
- * import { streamWithCache, createCacheState } from '../cache/shared-cache.js';
- *
- * // In your emitter:
- * const cacheState = createCacheState();
- * const config = { threshold: 10000, strategy: 'memory', name: 'NLJ-inner' };
- *
- * // In your run function:
- * yield* streamWithCache(sourceIterable, config, cacheState);
- * ```
- */
-
-/**
- * Emits a smart cache instruction that materializes input on first iteration
- * and serves subsequent iterations from cached results.
- *
- * Now uses the shared cache utility to avoid code duplication.
- */
-export function emitCache(plan: CacheNode, ctx: EmissionContext): Instruction {
-	// Create cache state using shared utility
-	const cacheState = createCacheState();
-	const config: SharedCacheConfig = {
-		threshold: plan.threshold,
-		strategy: plan.strategy,
-		name: `CacheNode-${plan.id}`
-	};
-
-	async function* run(rctx: RuntimeContext, sourceCallback: (innerCtx: RuntimeContext) => AsyncIterable<Row>): AsyncIterable<Row> {
-		let sourceIterable = sourceCallback(rctx);
-
-		// Optional: Add buffering for large threshold caches to improve performance
-		if (plan.threshold > 50000) {
-			sourceIterable = buffered(sourceIterable, Math.min(plan.threshold / 10, 5000));
-		}
-
-		// Optional: Add tracing in debug mode
-		if (isDebugEnabled('runtime:cache')) {
-			sourceIterable = traced(sourceIterable, `cache-${plan.id}`,
-				(row, index) => `row ${index}: [${row.length} columns]`);
-		}
-
-		yield* streamWithCache(sourceIterable, config, cacheState);
-	}
-
-	const sourceInstruction = emitCallFromPlan(plan.source, ctx);
-
-	return {
-		params: [sourceInstruction],
-		run: run as InstructionRun,
-		note: `cache(${plan.strategy}, threshold=${plan.threshold})`
-	};
-}

package/src/runtime/emit/case.ts

@@ -1,87 +0,0 @@
-import type { CaseExprNode } from '../../planner/nodes/scalar.js';
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import { emitPlanNode } from '../emitters.js';
-import { type SqlValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { compareSqlValues } from '../../util/comparison.js';
-import { isTruthy } from '../../util/comparison.js';
-
-export function emitCaseExpr(plan: CaseExprNode, ctx: EmissionContext): Instruction {
-	// Simple CASE: CASE base_expr WHEN value1 THEN result1 WHEN value2 THEN result2 ... END
-	async function runSimpleCase(
-		runtimeCtx: RuntimeContext,
-		...args: SqlValue[]
-	): Promise<SqlValue> {
-		let argIndex = 0;
-		const baseValue = args[argIndex++];
-
-		// Evaluate WHEN/THEN clauses
-		for (const _clause of plan.whenThenClauses) {
-			const whenValue = args[argIndex++];
-			const thenValue = args[argIndex++];
-
-			const conditionMet = baseValue !== null && whenValue !== null &&
-				compareSqlValues(baseValue as SqlValue, whenValue) === 0;
-
-			if (conditionMet) {
-				return thenValue;
-			}
-		}
-
-		// No WHEN clause matched, return ELSE value or NULL
-		if (plan.elseExpr) {
-			return args[argIndex]; // ELSE value
-		} else {
-			return null; // No ELSE clause, return NULL
-		}
-	}
-
-	// Searched CASE: CASE WHEN condition1 THEN result1 WHEN condition2 THEN result2 ... END
-	async function runSearchedCase(
-		runtimeCtx: RuntimeContext,
-		...args: SqlValue[]
-	): Promise<SqlValue> {
-		let argIndex = 0;
-
-		// Evaluate WHEN/THEN clauses
-		for (const _clause of plan.whenThenClauses) {
-			const whenValue = args[argIndex++];
-			const thenValue = args[argIndex++];
-
-			if (isTruthy(whenValue)) {
-				return thenValue;
-			}
-		}
-
-		// No WHEN clause matched, return ELSE value or NULL
-		if (plan.elseExpr) {
-			return args[argIndex]; // ELSE value
-		} else {
-			return null; // No ELSE clause, return NULL
-		}
-	}
-
-	// Emit instructions for all sub-expressions
-	const paramInstructions: Instruction[] = [];
-
-	if (plan.baseExpr) {
-		paramInstructions.push(emitPlanNode(plan.baseExpr, ctx));
-	}
-
-	// TODO: consider making all of these calls for short-circuiting
-
-	for (const clause of plan.whenThenClauses) {
-		paramInstructions.push(emitPlanNode(clause.when, ctx));
-		paramInstructions.push(emitPlanNode(clause.then, ctx));
-	}
-
-	if (plan.elseExpr) {
-		paramInstructions.push(emitPlanNode(plan.elseExpr, ctx));
-	}
-
-	return {
-		params: paramInstructions,
-		run: (plan.baseExpr ? runSimpleCase : runSearchedCase) as InstructionRun,
-		note: `case(${plan.whenThenClauses.length} when clauses${plan.elseExpr ? ', else' : ''})`
-	};
-}

package/src/runtime/emit/cast.ts

@@ -1,151 +0,0 @@
-import type { CastNode } from '../../planner/nodes/scalar.js';
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import { emitPlanNode } from '../emitters.js';
-import { type SqlValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-
-export function emitCast(plan: CastNode, ctx: EmissionContext): Instruction {
-	async function run(
-		runtimeCtx: RuntimeContext,
-		operandValue: SqlValue
-	): Promise<SqlValue> {
-		const targetType = plan.expression.targetType.toUpperCase();
-
-		// Handle NULL values - CAST(NULL AS anything) = NULL
-		if (operandValue === null) {
-			return null;
-		}
-
-		// Perform the cast based on target type
-		switch (targetType) {
-			case 'INTEGER':
-			case 'INT':
-			case 'TINYINT':
-			case 'SMALLINT':
-			case 'MEDIUMINT':
-			case 'BIGINT':
-			case 'UNSIGNED BIG INT':
-			case 'INT2':
-			case 'INT8':
-				return castToInteger(operandValue);
-
-			case 'REAL':
-			case 'DOUBLE':
-			case 'DOUBLE PRECISION':
-			case 'FLOAT':
-				return castToReal(operandValue);
-
-			case 'TEXT':
-			case 'CHARACTER':
-			case 'VARCHAR':
-			case 'VARYING CHARACTER':
-			case 'NCHAR':
-			case 'NATIVE CHARACTER':
-			case 'NVARCHAR':
-			case 'CLOB':
-				return castToText(operandValue);
-
-			case 'BLOB':
-				return castToBlob(operandValue);
-
-			case 'NUMERIC':
-			case 'DECIMAL':
-			case 'BOOLEAN':
-			case 'DATE':
-			case 'DATETIME':
-				return castToNumeric(operandValue);
-
-			default:
-				// For unknown types, return as-is (BLOB affinity)
-				return operandValue;
-		}
-	}
-
-	return {
-		params: [emitPlanNode(plan.operand, ctx)],
-		run: run as InstructionRun,
-		note: `cast(${plan.expression.targetType})`
-	};
-}
-
-function castToInteger(value: SqlValue): SqlValue {
-	if (typeof value === 'number') {
-		return Math.trunc(value);
-	}
-	if (typeof value === 'bigint') {
-		return value;
-	}
-	if (typeof value === 'string') {
-		const num = Number(value);
-		return isNaN(num) ? 0 : Math.trunc(num);
-	}
-	if (typeof value === 'boolean') {
-		return value ? 1 : 0;
-	}
-	return 0;
-}
-
-function castToReal(value: SqlValue): SqlValue {
-	if (typeof value === 'number') {
-		return value;
-	}
-	if (typeof value === 'bigint') {
-		return Number(value);
-	}
-	if (typeof value === 'string') {
-		const num = Number(value);
-		return isNaN(num) ? 0.0 : num;
-	}
-	if (typeof value === 'boolean') {
-		return value ? 1.0 : 0.0;
-	}
-	return 0.0;
-}
-
-function castToText(value: SqlValue): SqlValue {
-	if (typeof value === 'string') {
-		return value;
-	}
-	if (typeof value === 'number' || typeof value === 'bigint') {
-		return String(value);
-	}
-	if (typeof value === 'boolean') {
-		return value ? '1' : '0';
-	}
-	if (value instanceof Uint8Array) {
-		// Convert blob to hex string
-		return Array.from(value, byte => byte.toString(16).padStart(2, '0')).join('').toUpperCase();
-	}
-	return String(value);
-}
-
-function castToBlob(value: SqlValue): SqlValue {
-	if (value instanceof Uint8Array) {
-		return value;
-	}
-	if (typeof value === 'string') {
-		// Convert string to UTF-8 bytes
-		return new TextEncoder().encode(value);
-	}
-	// For other types, convert to string first then to bytes
-	return new TextEncoder().encode(String(value));
-}
-
-function castToNumeric(value: SqlValue): SqlValue {
-	// NUMERIC affinity: prefer integer if possible, otherwise real
-	if (typeof value === 'number') {
-		return Number.isInteger(value) ? Math.trunc(value) : value;
-	}
-	if (typeof value === 'bigint') {
-		return value;
-	}
-	if (typeof value === 'string') {
-		const num = Number(value);
-		if (isNaN(num)) return 0;
-		return Number.isInteger(num) ? Math.trunc(num) : num;
-	}
-	if (typeof value === 'boolean') {
-		return value ? 1 : 0;
-	}
-	return 0;
-}

package/src/runtime/emit/collate.ts

@@ -1,9 +0,0 @@
-import type { CollateNode } from '../../planner/nodes/scalar.js';
-import type { Instruction } from '../types.js';
-import { emitPlanNode } from '../emitters.js';
-import type { EmissionContext } from '../emission-context.js';
-
-export function emitCollate(plan: CollateNode, ctx: EmissionContext): Instruction {
-	// No runtime effect
-	return emitPlanNode(plan.operand, ctx);
-}