@quereus/quereus 0.7.2 → 0.7.4

package/src/runtime/emit/dml-executor.ts

@@ -1,198 +0,0 @@
-import type { DmlExecutorNode } from '../../planner/nodes/dml-executor-node.js';
-import type { Instruction, RuntimeContext, InstructionRun, OutputValue } from '../types.js';
-import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode, type Row, type SqlValue } from '../../common/types.js';
-import { getVTable, disconnectVTable } from '../utils.js';
-import { ConflictResolution } from '../../common/constants.js';
-import type { EmissionContext } from '../emission-context.js';
-import { extractOldRowFromFlat, extractNewRowFromFlat } from '../../util/row-descriptor.js';
-import { buildInsertStatement, buildUpdateStatement, buildDeleteStatement } from '../../util/mutation-statement.js';
-import type { UpdateArgs } from '../../vtab/table.js';
-
-export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): Instruction {
-	const tableSchema = plan.table.tableSchema;
-
-	// Pre-calculate primary key column indices from schema (needed for update/delete)
-	const pkColumnIndicesInSchema = tableSchema.primaryKeyDefinition.map(pkColDef => pkColDef.index);
-
-	// Emit mutation context evaluators if present
-	const contextEvaluatorInstructions: Instruction[] = [];
-	if (plan.mutationContextValues && plan.contextAttributes) {
-		for (const attr of plan.contextAttributes) {
-			const valueNode = plan.mutationContextValues.get(attr.name);
-			if (!valueNode) {
-				throw new QuereusError(`Missing mutation context value for '${attr.name}'`, StatusCode.INTERNAL);
-			}
-			const instruction = emitCallFromPlan(valueNode, ctx);
-			contextEvaluatorInstructions.push(instruction);
-		}
-	}
-
-	// --- Operation-specific run generators ------------------------------------
-
-	// INSERT ----------------------------------------------------
-	async function* runInsert(ctx: RuntimeContext, rows: AsyncIterable<Row>, ...contextEvaluators: Array<(ctx: RuntimeContext) => OutputValue>): AsyncIterable<Row> {
-		const vtab = await getVTable(ctx, tableSchema);
-
-		// Evaluate mutation context once per statement
-		let contextRow: Row | undefined;
-		if (contextEvaluators.length > 0) {
-			contextRow = [];
-			for (const evaluator of contextEvaluators) {
-				const value = await evaluator(ctx) as SqlValue;
-				contextRow.push(value);
-			}
-		}
-
-		try {
-			for await (const flatRow of rows) {
-				const newRow = extractNewRowFromFlat(flatRow, tableSchema.columns.length);
-
-				// Build mutation statement if logging is enabled
-				let mutationStatement: string | undefined;
-				if (vtab.wantStatements) {
-					mutationStatement = buildInsertStatement(tableSchema, newRow, contextRow);
-				}
-
-				const args: UpdateArgs = {
-					operation: 'insert',
-					values: newRow,
-					oldKeyValues: undefined,
-					onConflict: plan.onConflict ?? ConflictResolution.ABORT,
-					mutationStatement
-				};
-
-				await vtab.update!(args);
-
-				// Track change (INSERT): record NEW primary key
-				const pkValues = tableSchema.primaryKeyDefinition.map(def => newRow[def.index]);
-				ctx.db._recordInsert(`${tableSchema.schemaName}.${tableSchema.name}`, pkValues);
-				yield flatRow; // make OLD/NEW available downstream (e.g. RETURNING)
-			}
-		} finally {
-			await disconnectVTable(ctx, vtab);
-		}
-	}
-
-	// UPDATE ----------------------------------------------------
-	async function* runUpdate(ctx: RuntimeContext, rows: AsyncIterable<Row>, ...contextEvaluators: Array<(ctx: RuntimeContext) => OutputValue>): AsyncIterable<Row> {
-		const vtab = await getVTable(ctx, tableSchema);
-
-		// Evaluate mutation context once per statement
-		let contextRow: Row | undefined;
-		if (contextEvaluators.length > 0) {
-			contextRow = [];
-			for (const evaluator of contextEvaluators) {
-				const value = await evaluator(ctx) as SqlValue;
-				contextRow.push(value);
-			}
-		}
-
-		try {
-			for await (const flatRow of rows) {
-				const oldRow = extractOldRowFromFlat(flatRow, tableSchema.columns.length);
-				const newRow = extractNewRowFromFlat(flatRow, tableSchema.columns.length);
-
-				// Extract primary key values from the OLD row (these identify which row to update)
-				const keyValues: SqlValue[] = pkColumnIndicesInSchema.map(pkColIdx => {
-					if (pkColIdx >= oldRow.length) {
-						throw new QuereusError(`PK column index ${pkColIdx} out of bounds for OLD row length ${oldRow.length} in UPDATE on '${tableSchema.name}'.`, StatusCode.INTERNAL);
-					}
-					return oldRow[pkColIdx];
-				});
-
-				// Build mutation statement if logging is enabled
-				let mutationStatement: string | undefined;
-				if (vtab.wantStatements) {
-					mutationStatement = buildUpdateStatement(tableSchema, newRow, keyValues, contextRow);
-				}
-
-				const args: UpdateArgs = {
-					operation: 'update',
-					values: newRow,
-					oldKeyValues: keyValues,
-					onConflict: ConflictResolution.ABORT,
-					mutationStatement
-				};
-
-				await vtab.update!(args);
-
-				// Track change (UPDATE): record OLD and NEW primary keys
-				const newKeyValues: SqlValue[] = tableSchema.primaryKeyDefinition.map(pkColDef => newRow[pkColDef.index]);
-				ctx.db._recordUpdate(`${tableSchema.schemaName}.${tableSchema.name}`, keyValues, newKeyValues);
-				yield flatRow;
-			}
-		} finally {
-			await disconnectVTable(ctx, vtab);
-		}
-	}
-
-	// DELETE ----------------------------------------------------
-	async function* runDelete(ctx: RuntimeContext, rows: AsyncIterable<Row>, ...contextEvaluators: Array<(ctx: RuntimeContext) => OutputValue>): AsyncIterable<Row> {
-		const vtab = await getVTable(ctx, tableSchema);
-
-		// Evaluate mutation context once per statement
-		let contextRow: Row | undefined;
-		if (contextEvaluators.length > 0) {
-			contextRow = [];
-			for (const evaluator of contextEvaluators) {
-				const value = await evaluator(ctx) as SqlValue;
-				contextRow.push(value);
-			}
-		}
-
-		try {
-			for await (const flatRow of rows) {
-				const oldRow = extractOldRowFromFlat(flatRow, tableSchema.columns.length);
-
-				const keyValues: SqlValue[] = pkColumnIndicesInSchema.map(pkColIdx => {
-					if (pkColIdx >= oldRow.length) {
-						throw new QuereusError(`PK column index ${pkColIdx} out of bounds for OLD row length ${oldRow.length} in DELETE on '${tableSchema.name}'.`, StatusCode.INTERNAL);
-					}
-					return oldRow[pkColIdx];
-				});
-
-				// Build mutation statement if logging is enabled
-				let mutationStatement: string | undefined;
-				if (vtab.wantStatements) {
-					mutationStatement = buildDeleteStatement(tableSchema, keyValues, contextRow);
-				}
-
-				const args: UpdateArgs = {
-					operation: 'delete',
-					values: undefined,
-					oldKeyValues: keyValues,
-					onConflict: ConflictResolution.ABORT,
-					mutationStatement
-				};
-
-				await vtab.update!(args);
-
-				// Track change (DELETE): record OLD primary key
-				ctx.db._recordDelete(`${tableSchema.schemaName}.${tableSchema.name}`, keyValues);
-				yield flatRow;
-			}
-		} finally {
-			await disconnectVTable(ctx, vtab);
-		}
-	}
-
-	// Select the correct generator based on operation
-	let run: InstructionRun;
-	switch (plan.operation) {
-		case 'insert': run = runInsert as InstructionRun; break;
-		case 'update': run = runUpdate as InstructionRun; break;
-		case 'delete': run = runDelete as InstructionRun; break;
-		default:
-			throw new QuereusError(`Unknown DML operation: ${plan.operation}`, StatusCode.INTERNAL);
-	}
-
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-
-	return {
-		params: [sourceInstruction, ...contextEvaluatorInstructions],
-		run,
-		note: `execute${plan.operation}(${plan.table.tableSchema.name})`
-	};
-}

package/src/runtime/emit/drop-assertion.ts

@@ -1,45 +0,0 @@
-import type { DropAssertionNode } from '../../planner/nodes/drop-assertion-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { QuereusError } from '../../common/errors.js';
-import { SqlValue, StatusCode } from '../../common/types.js';
-import { createLogger } from '../../common/logger.js';
-
-const log = createLogger('runtime:emit:drop-assertion');
-
-export function emitDropAssertion(plan: DropAssertionNode, _ctx: EmissionContext): Instruction {
-
-	async function run(rctx: RuntimeContext): Promise<SqlValue> {
-		const schemaManager = rctx.db.schemaManager;
-		const schema = schemaManager.getMainSchema(); // Look in main schema for now
-
-		const existing = schema.getAssertion(plan.name);
-		if (!existing) {
-			if (plan.ifExists) {
-				log('Assertion %s not found, but IF EXISTS specified', plan.name);
-				return null;
-			}
-			throw new QuereusError(
-				`Assertion ${plan.name} not found`,
-				StatusCode.NOTFOUND
-			);
-		}
-
-		const removed = schema.removeAssertion(plan.name);
-		if (!removed && !plan.ifExists) {
-			throw new QuereusError(
-				`Failed to remove assertion ${plan.name}`,
-				StatusCode.INTERNAL
-			);
-		}
-
-		log('Dropped assertion %s', plan.name);
-		return null;
-	}
-
-	return {
-		params: [],
-		run: run as InstructionRun,
-		note: `dropAssertion(${plan.name})`
-	};
-}

package/src/runtime/emit/drop-table.ts

@@ -1,27 +0,0 @@
-import type { DropTableNode } from '../../planner/nodes/drop-table-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode, type SqlValue } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-
-export function emitDropTable(plan: DropTableNode, ctx: EmissionContext): Instruction {
-	const schemaManager = ctx.db.schemaManager;
-	const stmt = plan.statementAst; // AST.DropStmt
-
-	const targetSchemaName = stmt.name.schema || schemaManager.getCurrentSchemaName();
-	const objectName = stmt.name.name;
-
-	if (stmt.objectType !== 'table') {
-		// This emitter is specifically for DROP TABLE.
-		// DROP VIEW, DROP INDEX would need their own PlanNodes and emitters, or a more generic DDL DropNode.
-		throw new QuereusError(`DROP for object type '${stmt.objectType}' is not supported by emitDropTable.`, StatusCode.UNSUPPORTED);
-	}
-
-	async function run(rctx: RuntimeContext): Promise<SqlValue | undefined> {
-		await rctx.db.schemaManager.dropTable(targetSchemaName, objectName, stmt.ifExists);
-
-		return null;
-  }
-
-  return { params: [], run: run as InstructionRun };
-}

package/src/runtime/emit/drop-view.ts

@@ -1,49 +0,0 @@
-import type { DropViewNode } from '../../planner/nodes/drop-view-node.js';
-import type { Instruction, RuntimeContext } from '../types.js';
-import type { EmissionContext } from '../emission-context.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode, type SqlValue } from '../../common/types.js';
-
-export function emitDropView(plan: DropViewNode, _ctx: EmissionContext): Instruction {
-	async function run(rctx: RuntimeContext): Promise<SqlValue> {
-		// Check if view exists
-		const existingView = rctx.db.schemaManager.getView(plan.schemaName, plan.viewName);
-
-		if (!existingView && !plan.ifExists) {
-			throw new QuereusError(
-				`View '${plan.schemaName}.${plan.viewName}' does not exist`,
-				StatusCode.ERROR
-			);
-		}
-
-		if (!existingView && plan.ifExists) {
-			// View doesn't exist but IF EXISTS was specified, so this is a no-op
-			return null;
-		}
-
-		// Remove the view from the schema manager
-		const schema = rctx.db.schemaManager.getSchema(plan.schemaName);
-		if (!schema) {
-			throw new QuereusError(
-				`Schema '${plan.schemaName}' does not exist`,
-				StatusCode.ERROR
-			);
-		}
-
-		const removed = schema.removeView(plan.viewName);
-		if (!removed && !plan.ifExists) {
-			throw new QuereusError(
-				`View '${plan.schemaName}.${plan.viewName}' does not exist`,
-				StatusCode.ERROR
-			);
-		}
-
-		return null; // Explicitly return null for successful void operations
-	}
-
-	return {
-		params: [],
-		run,
-		note: `dropView(${plan.schemaName}.${plan.viewName})`
-	};
-}

package/src/runtime/emit/filter.ts

@@ -1,30 +0,0 @@
-import type { FilterNode } from '../../planner/nodes/filter.js';
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
-import { OutputValue, 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);
-	const predicateFunc = emitCallFromPlan(plan.predicate, ctx);
-
-	// Create row descriptor for source attributes
-	const sourceRowDescriptor = buildRowDescriptor(plan.source.getAttributes());
-
-	async function* run(ctx: RuntimeContext, source: AsyncIterable<Row>, predicate: (ctx: RuntimeContext) => OutputValue): AsyncIterable<Row> {
-		yield* withRowContextGenerator(ctx, sourceRowDescriptor, source, async function* (sourceRow) {
-			const result = await predicate(ctx);
-			if (result) {
-				yield sourceRow;
-			}
-		});
-	}
-
-	return {
-		params: [sourceInstruction, predicateFunc],
-		run: run as InstructionRun,
-		note: `filter(${plan.predicate.toString()})`
-	};
-}

package/src/runtime/emit/insert.ts

@@ -1,42 +0,0 @@
-import type { InsertNode } from '../../planner/nodes/insert-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { emitPlanNode } from '../emitters.js';
-import type { Row } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-
-export function emitInsert(plan: InsertNode, ctx: EmissionContext): Instruction {
-	// INSERT node now only handles data transformations and passes flat rows through.
-	// The actual database insert operations are handled by DmlExecutorNode.
-	// Type conversion is handled by the table manager's validateAndParse in performInsert.
-	async function* run(_ctx: RuntimeContext, sourceValue: AsyncIterable<Row>): AsyncIterable<Row> {
-		const tableSchema = plan.table.tableSchema;
-		const colCount = tableSchema.columns.length;
-
-		for await (const sourceRow of sourceValue) {
-			// Convert source row to flat OLD/NEW format
-			// For INSERT: OLD values are all NULL, NEW values are from source
-			const flatRow: Row = new Array(colCount * 2);
-
-			// Fill OLD section with NULLs (indices 0..n-1)
-			for (let i = 0; i < colCount; i++) {
-				flatRow[i] = null;
-			}
-
-			// Fill NEW section with source values (indices n..2n-1)
-			// No affinity conversion here - let the type system handle it
-			for (let colIdx = 0; colIdx < colCount; colIdx++) {
-				flatRow[colCount + colIdx] = sourceRow[colIdx];
-			}
-
-			yield flatRow;
-		}
-	}
-
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-
-	return {
-		params: [sourceInstruction],
-		run: run as InstructionRun,
-		note: `insertPrep(${plan.table.tableSchema.name})`
-	};
-}

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

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

@@ -1,148 +0,0 @@
-import type { JoinNode } from '../../planner/nodes/join-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { emitCallFromPlan, emitPlanNode } from '../emitters.js';
-import type { Row, OutputValue } from '../../common/types.js';
-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';
-import type { Attribute } from '../../planner/nodes/plan-node.js';
-
-const log = createLogger('runtime:emit:join');
-
-/**
- * Emits a nested loop join instruction.
- * This is a simple nested loop implementation that can handle all join types.
- */
-export function emitLoopJoin(plan: JoinNode, ctx: EmissionContext): Instruction {
-	// Create row descriptors for left and right inputs
-	const leftAttributes = plan.left.getAttributes();
-	const leftRowDescriptor = buildRowDescriptor(leftAttributes);
-
-	const rightAttributes = plan.right.getAttributes();
-	const rightRowDescriptor = buildRowDescriptor(rightAttributes);
-
-	// NOTE: rightSource must be re-startable (optimizer facilitates through cache node)
-	async function* run(rctx: RuntimeContext, leftSource: AsyncIterable<Row>, rightCallback: (ctx: RuntimeContext) => AsyncIterable<Row>, conditionCallback?: (ctx: RuntimeContext) => OutputValue): AsyncIterable<Row> {
-		const joinType = plan.joinType;
-
-		log('Starting %s join between %d left attrs and %d right attrs',
-			joinType.toUpperCase(), leftAttributes.length, rightAttributes.length);
-
-		// 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);
-
-				let leftMatched = false;
-
-				// Stream through right side for each left row
-				for await (const rightRow of rightCallback(rctx)) {
-					// Set up right context
-					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;
-					}
-				}
-
-				// Handle outer join semantics - null padding for unmatched left rows
-				if (!leftMatched && (joinType === 'left' || joinType === 'full')) {
-					// Create null-padded row for left outer join
-					const nullPadding = new Array(rightAttributes.length).fill(null);
-					const outputRow = [...leftRow, ...nullPadding] as Row;
-					yield outputRow;
-				}
-			}
-
-			// 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();
-		}
-	}
-
-	const leftInstruction = emitPlanNode(plan.left, ctx);
-	const rightInstruction = emitCallFromPlan(plan.right, ctx);
-
-	// Build the params array - include condition callback if present
-	const params = [leftInstruction, rightInstruction];
-	if (plan.condition) {
-		const conditionInstruction = emitCallFromPlan(plan.condition, ctx);
-		params.push(conditionInstruction);
-	}
-
-	return {
-		params,
-		run: run as InstructionRun,
-		note: `${plan.joinType} join (nested loop)`
-	};
-}
-
-/**
- * Evaluates USING condition by comparing specified columns from left and right rows
- */
-function evaluateUsingCondition(
-	leftRow: Row,
-	rightRow: Row,
-	usingColumns: readonly string[],
-	leftAttributes: readonly Attribute[],
-	rightAttributes: readonly Attribute[]
-): boolean {
-	for (const columnName of usingColumns) {
-		const leftColName = columnName.toLowerCase();
-		const rightColName = columnName.toLowerCase();
-
-		// Find column indices in left and right
-		const leftIndex = leftAttributes.findIndex(attr => attr.name.toLowerCase() === leftColName);
-		const rightIndex = rightAttributes.findIndex(attr => attr.name.toLowerCase() === rightColName);
-
-		if (leftIndex === -1 || rightIndex === -1) {
-			// Column not found - should not happen if planner is correct
-			return false;
-		}
-
-		const leftValue = leftRow[leftIndex];
-		const rightValue = rightRow[rightIndex];
-
-		// Compare using SQL semantics
-		if (compareSqlValues(leftValue, rightValue) !== 0) {
-			return false;
-		}
-	}
-
-	return true; // All USING columns match
-}

package/src/runtime/emit/limit-offset.ts

@@ -1,73 +0,0 @@
-import type { LimitOffsetNode } from '../../planner/nodes/limit-offset.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
-import { type SqlValue, type Row, MaybePromise } from '../../common/types.js';
-import type { EmissionContext } from '../emission-context.js';
-
-export function emitLimitOffset(plan: LimitOffsetNode, ctx: EmissionContext): Instruction {
-	async function* run(
-		ctx: RuntimeContext,
-		sourceRows: AsyncIterable<Row>,
-		...args: Array<(ctx: RuntimeContext) => MaybePromise<SqlValue>>
-	): AsyncIterable<Row> {
-		// Determine which args we have
-		let limitFn: ((ctx: RuntimeContext) => MaybePromise<SqlValue>) | undefined;
-		let offsetFn: ((ctx: RuntimeContext) => MaybePromise<SqlValue>) | undefined;
-
-		let argIndex = 0;
-		if (plan.limit) {
-			limitFn = args[argIndex++];
-		}
-		if (plan.offset) {
-			offsetFn = args[argIndex++];
-		}
-
-		// Evaluate limit and offset
-		const limitValue = limitFn ? await limitFn(ctx) : null;
-		const offsetValue = offsetFn ? await offsetFn(ctx) : null;
-
-		// Convert to numbers, with defaults
-		let limit = limitValue !== null ? Number(limitValue) : Infinity;
-		let offset = offsetValue !== null ? Number(offsetValue) : 0;
-
-		// Validate values
-		if (limit < 0 || !Number.isFinite(limit)) {
-			limit = 0; // No rows if limit is negative or invalid
-		}
-		if (offset < 0 || !Number.isFinite(offset)) {
-			offset = 0; // No offset if negative or invalid
-		}
-
-		// Skip offset rows
-		let skipped = 0;
-		let emitted = 0;
-
-		for await (const row of sourceRows) {
-			if (skipped < offset) {
-				skipped++;
-				continue;
-			}
-
-			if (emitted >= limit) {
-				break;
-			}
-
-			yield row;
-			emitted++;
-		}
-	}
-
-	const sourceInstruction = emitPlanNode(plan.source, ctx);
-	const limitInstruction = plan.limit ? emitCallFromPlan(plan.limit, ctx) : undefined;
-	const offsetInstruction = plan.offset ? emitCallFromPlan(plan.offset, ctx) : undefined;
-
-	const params: Instruction[] = [sourceInstruction];
-	if (limitInstruction) params.push(limitInstruction);
-	if (offsetInstruction) params.push(offsetInstruction);
-
-	return {
-		params,
-		run: run as InstructionRun,
-		note: `limit_offset(${plan.limit ? 'LIMIT' : ''}${plan.limit && plan.offset ? ',' : ''}${plan.offset ? 'OFFSET' : ''})`
-	};
-}

package/src/runtime/emit/literal.ts

@@ -1,17 +0,0 @@
-import type { MaybePromise, SqlValue } from "../../common/types.js";
-import type { Instruction, InstructionRun, RuntimeContext } from "../types.js";
-import type { LiteralNode } from "../../planner/nodes/scalar.js";
-import { safeJsonStringify } from "../../util/serialization.js";
-import type { EmissionContext } from "../emission-context.js";
-
-export function emitLiteral(plan: LiteralNode, _ctx: EmissionContext): Instruction {
-	function run(_rctx: RuntimeContext): MaybePromise<SqlValue> {
-		return plan.expression.value;
-	}
-
-	return {
-		params: [],
-		run: run as InstructionRun,
-		note: `literal(${safeJsonStringify(plan.expression.value)})`
-	};
-}