@quereus/quereus 0.1.0

package/src/runtime/emit/binary.ts

@@ -0,0 +1,335 @@
+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";
+
+export function emitBinaryOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
+	switch (plan.expression.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 'BETWEEN':
+			return emitBetweenOp(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: any, v2: any) => any;
+	switch (plan.expression.operator) {
+		case '+': inner = (v1, v2) => v1 + v2; break;
+		case '-': inner = (v1, v2) => v1 - v2; break;
+		case '*': inner = (v1, v2) => v1 * v2; break;
+		case '/': inner = (v1, v2) => v1 / v2; break;
+		case '%': inner = (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 {
+		if (v1 !== null && v2 !== null) {
+			if (typeof v1 === 'bigint' || typeof v2 === 'bigint') {
+				try {
+					return inner(BigInt(v1 as any), BigInt(v2 as any));
+				} 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);
+
+	switch (plan.expression.operator) {
+		case '=':
+		case '==':
+			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
+				// SQL comparison: NULL = anything -> NULL
+				if (v1 === null || v2 === null) return null;
+
+				// Apply type coercion before comparison
+				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) === 0 ? 1 : 0;
+			};
+			break;
+		case '!=':
+		case '<>':
+			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
+				// SQL comparison: NULL != anything -> NULL
+				if (v1 === null || v2 === null) return null;
+
+				// Apply type coercion before comparison
+				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) !== 0 ? 1 : 0;
+			};
+			break;
+		case '<':
+			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
+				// SQL comparison: NULL < anything -> NULL
+				if (v1 === null || v2 === null) return null;
+
+				// Apply type coercion before comparison
+				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) < 0 ? 1 : 0;
+			};
+			break;
+		case '<=':
+			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
+				// SQL comparison: NULL <= anything -> NULL
+				if (v1 === null || v2 === null) return null;
+
+				// Apply type coercion before comparison
+				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) <= 0 ? 1 : 0;
+			};
+			break;
+		case '>':
+			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
+				// SQL comparison: NULL > anything -> NULL
+				if (v1 === null || v2 === null) {
+					return null;
+				}
+
+				// Apply type coercion before comparison
+				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
+				const comparisonResult = compareSqlValuesFast(coercedV1, coercedV2, collationFunc);
+				const finalResult = comparisonResult > 0 ? 1 : 0;
+				return finalResult;
+			};
+			break;
+		case '>=':
+			run = (ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue => {
+				// SQL comparison: NULL >= anything -> NULL
+				if (v1 === null || v2 === null) return null;
+
+				// Apply type coercion before comparison
+				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) >= 0 ? 1 : 0;
+			};
+			break;
+		default:
+			throw new QuereusError(`Unsupported comparison 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}(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 {
+	function run(ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue {
+		// SQL three-valued logic
+		switch (plan.expression.operator) {
+			case 'AND': {
+				// NULL AND x -> NULL if x is true or NULL, otherwise 0
+				// 0 AND x -> 0
+				// 1 AND x -> x
+				if (v1 === null) {
+					return (v2 === null || v2) ? null : 0;
+				}
+				if (!v1) return 0;
+				return v2 === null ? null : (v2 ? 1 : 0);
+			}
+
+			case 'OR': {
+				// NULL OR x -> NULL if x is false or NULL, otherwise 1
+				// 1 OR x -> 1
+				// 0 OR x -> x
+				if (v1 === null) {
+					return (v2 === null || !v2) ? null : 1;
+				}
+				if (v1) return 1;
+				return v2 === null ? null : (v2 ? 1 : 0);
+			}
+
+			case 'XOR': {
+				// NULL XOR x -> NULL
+				// x XOR NULL -> NULL
+				// 0 XOR 0 -> 0
+				// 0 XOR 1 -> 1
+				// 1 XOR 0 -> 1
+				// 1 XOR 1 -> 0
+				if (v1 === null || v2 === null) return null;
+				const b1 = v1 ? 1 : 0;
+				const b2 = v2 ? 1 : 0;
+				return b1 !== b2 ? 1 : 0;
+			}
+
+			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) ? 1 : 0;
+	}
+
+	const leftExpr = emitPlanNode(plan.left, ctx);
+	const rightExpr = emitPlanNode(plan.right, ctx);
+
+	return {
+		params: [leftExpr, rightExpr],
+		run: run as InstructionRun,
+		note: 'LIKE(like)'
+	};
+}
+
+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/block.ts

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

@@ -0,0 +1,64 @@
+import type { CacheNode } from '../../planner/nodes/cache-node.js';
+import type { Instruction, 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,
+		note: `cache(${plan.strategy}, threshold=${plan.threshold})`
+	};
+}

package/src/runtime/emit/case.ts

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

@@ -0,0 +1,151 @@
+import type { CastNode } from '../../planner/nodes/scalar.js';
+import type { Instruction, 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 any,
+		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

@@ -0,0 +1,9 @@
+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);
+}