@quereus/quereus 0.1.0

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

@@ -0,0 +1,94 @@
+import type { DmlExecutorNode } from '../../planner/nodes/dml-executor-node.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
+import { emitPlanNode } from '../emitters.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode, type Row } from '../../common/types.js';
+import { getVTable, disconnectVTable } from '../utils.js';
+import type { EmissionContext } from '../emission-context.js';
+import { extractOldRowFromFlat, extractNewRowFromFlat } from '../../util/row-descriptor.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);
+
+	// --- Operation-specific run generators ------------------------------------
+
+	// INSERT ----------------------------------------------------
+	async function* runInsert(ctx: RuntimeContext, rows: AsyncIterable<Row>): AsyncIterable<Row> {
+		const vtab = await getVTable(ctx, tableSchema);
+		try {
+			for await (const flatRow of rows) {
+				const newRow = extractNewRowFromFlat(flatRow, tableSchema.columns.length);
+				(newRow as any)._onConflict = plan.onConflict || 'abort';
+				await vtab.xUpdate!('insert', newRow);
+				yield flatRow; // make OLD/NEW available downstream (e.g. RETURNING)
+			}
+		} finally {
+			await disconnectVTable(ctx, vtab);
+		}
+	}
+
+	// UPDATE ----------------------------------------------------
+	async function* runUpdate(ctx: RuntimeContext, rows: AsyncIterable<Row>): AsyncIterable<Row> {
+		const vtab = await getVTable(ctx, tableSchema);
+		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 = 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];
+				});
+				await vtab.xUpdate!('update', newRow, keyValues);
+				yield flatRow;
+			}
+		} finally {
+			await disconnectVTable(ctx, vtab);
+		}
+	}
+
+	// DELETE ----------------------------------------------------
+	async function* runDelete(ctx: RuntimeContext, rows: AsyncIterable<Row>): AsyncIterable<Row> {
+		const vtab = await getVTable(ctx, tableSchema);
+		try {
+			for await (const flatRow of rows) {
+				const oldRow = extractOldRowFromFlat(flatRow, tableSchema.columns.length);
+
+				const keyValues = 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];
+				});
+				await vtab.xUpdate!('delete', undefined, keyValues);
+				yield flatRow;
+			}
+		} finally {
+			await disconnectVTable(ctx, vtab);
+		}
+	}
+
+	// Select the correct generator based on operation
+	let runFunc: InstructionRun;
+	switch (plan.operation) {
+		case 'insert': runFunc = runInsert; break;
+		case 'update': runFunc = runUpdate; break;
+		case 'delete': runFunc = runDelete; break;
+		default:
+			throw new QuereusError(`Unknown DML operation: ${plan.operation}`, StatusCode.INTERNAL);
+	}
+
+	const sourceInstruction = emitPlanNode(plan.source, ctx);
+
+	return {
+		params: [sourceInstruction],
+		run: runFunc,
+		note: `execute${plan.operation}(${plan.table.tableSchema.name})`
+	};
+}

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

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

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

@@ -0,0 +1,37 @@
+import type { FilterNode } from '../../planner/nodes/filter.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+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';
+
+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) => 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);
+			}
+		}
+	}
+
+	return {
+		params: [sourceInstruction, predicateFunc],
+		run: run as any,
+		note: `filter(${plan.predicate.toString()})`
+	};
+}

package/src/runtime/emit/insert.ts

@@ -0,0 +1,54 @@
+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';
+import { SqlDataType, type SqlValue } from '../../common/types.js';
+import { applyIntegerAffinity, applyRealAffinity, applyNumericAffinity, applyTextAffinity, applyBlobAffinity } from '../../util/affinity.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.
+	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 and apply type affinity (indices n..2n-1)
+			for (let colIdx = 0; colIdx < colCount; colIdx++) {
+				const sourceValue: SqlValue = sourceRow[colIdx];
+
+				let converted: SqlValue;
+				switch (tableSchema.columns[colIdx].affinity) {
+					case SqlDataType.INTEGER: converted = applyIntegerAffinity(sourceValue); break;
+					case SqlDataType.REAL: converted = applyRealAffinity(sourceValue); break;
+					case SqlDataType.NUMERIC: converted = applyNumericAffinity(sourceValue); break;
+					case SqlDataType.TEXT: converted = applyTextAffinity(sourceValue); break;
+					case SqlDataType.BLOB: converted = applyBlobAffinity(sourceValue); break;
+					default: converted = sourceValue;
+				}
+
+				flatRow[colCount + colIdx] = converted;
+			}
+
+			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/join.ts

@@ -0,0 +1,145 @@
+import type { JoinNode } from '../../planner/nodes/join-node.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import { emitCallFromPlan, emitPlanNode } from '../emitters.js';
+import type { Row } 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';
+
+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) => any): AsyncIterable<Row> {
+		const joinType = plan.joinType;
+
+		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);
+
+			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);
+					}
+				}
+
+				// 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;
+				}
+			} 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
+		}
+	}
+
+	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 any,
+		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: string[],
+	leftAttributes: any[],
+	rightAttributes: any[]
+): 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

@@ -0,0 +1,73 @@
+import type { LimitOffsetNode } from '../../planner/nodes/limit-offset.js';
+import type { Instruction, RuntimeContext } 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 any,
+		note: `limit_offset(${plan.limit ? 'LIMIT' : ''}${plan.limit && plan.offset ? ',' : ''}${plan.offset ? 'OFFSET' : ''})`
+	};
+}

package/src/runtime/emit/literal.ts

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

package/src/runtime/emit/parameter.ts

@@ -0,0 +1,59 @@
+import type { ParameterReferenceNode } from '../../planner/nodes/reference.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import type { SqlValue } from '../../common/types.js';
+import type { EmissionContext } from '../emission-context.js';
+
+export function emitParameterReference(plan: ParameterReferenceNode, _ctx: EmissionContext): Instruction {
+	function run(ctx: RuntimeContext): SqlValue {
+		const identifier = plan.nameOrIndex; // This comes from the ParameterReferenceNode instance
+
+		if (ctx.params === undefined) {
+			throw new QuereusError('Query executed with parameters, but no parameter values were provided.', StatusCode.MISUSE);
+		}
+
+		if (typeof identifier === 'number') {
+			// For ? (anonymous) parameters, identifier is a 1-based index.
+			// SqlParameters can be an array or an object.
+			if (Array.isArray(ctx.params)) {
+				if (identifier < 1 || identifier > ctx.params.length) {
+					throw new QuereusError(`Parameter index ${identifier} is out of bounds.`, StatusCode.RANGE);
+				}
+				return ctx.params[identifier - 1];
+			} else if (typeof ctx.params === 'object' && ctx.params !== null) {
+				// Support numbered parameters like :1, :2 in an object (e.g., { "1": value })
+				const key = String(identifier);
+				if (!(key in ctx.params)) {
+					throw new QuereusError(`Parameter with index ${identifier} not found in provided object.`, StatusCode.NOTFOUND);
+				}
+				return ctx.params[key as keyof typeof ctx.params];
+			} else {
+				throw new QuereusError('Parameters provided in an unsupported format for indexed access.', StatusCode.MISUSE);
+			}
+		} else if (typeof identifier === 'string') {
+			// For named parameters like :name.
+			if (Array.isArray(ctx.params)) {
+				throw new QuereusError('Named parameter found in query, but parameters provided as an array.', StatusCode.MISUSE);
+			}
+			if (typeof ctx.params === 'object' && ctx.params !== null) {
+				const key = identifier.startsWith(':') ? identifier.substring(1) : identifier;
+				if (!(key in ctx.params)) {
+					throw new QuereusError(`Parameter with name '${key}' not found.`, StatusCode.NOTFOUND);
+				}
+				return ctx.params[key as keyof typeof ctx.params];
+			} else {
+				throw new QuereusError('Parameters provided in an unsupported format for named access.', StatusCode.MISUSE);
+			}
+		} else {
+			// Should not happen given ParameterReferenceNode structure
+			throw new QuereusError('Invalid parameter identifier type.', StatusCode.INTERNAL);
+		}
+	}
+
+	return {
+		params: [],
+		run,
+		note: `param(${typeof plan.nameOrIndex === 'string' ? plan.nameOrIndex : '#' + plan.nameOrIndex})`
+	};
+}

package/src/runtime/emit/pragma.ts

@@ -0,0 +1,56 @@
+import type { EmissionContext } from '../emission-context.js';
+import type { PragmaPlanNode } from '../../planner/nodes/pragma.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
+import type { Row } from '../../common/types.js';
+import { createLogger } from '../../common/logger.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+
+const log = createLogger('runtime:emit:pragma');
+
+export function emitPragma(plan: PragmaPlanNode, _ctx: EmissionContext): Instruction {
+	const run = async function* (rctx: RuntimeContext): AsyncIterable<Row> {
+		const pragmaName = plan.pragmaName;
+		const value = plan.value;
+
+
+
+		if (value !== undefined) {
+			// Writing mode: set the pragma value
+			log(`PRAGMA ${pragmaName} = ${value}`);
+
+			// Try to set as a database option first
+			try {
+				rctx.db.setOption(pragmaName, value);
+				log(`Set option ${pragmaName} = ${value}`);
+			} catch {
+				// Treat unknown pragmas as no-ops for now, like SQLite often does
+				log(`Ignoring unrecognized PRAGMA: ${pragmaName}`);
+			}
+		} else {
+			// Reading mode: get the pragma value
+			log(`PRAGMA ${pragmaName} (reading)`);
+
+			try {
+				const currentValue = rctx.db.getOption(pragmaName);
+				log(`Read option ${pragmaName} = ${currentValue}`);
+				// Return as a single-row result with the pragma name as column
+				yield [pragmaName, currentValue];
+			} catch (error) {
+				// If the pragma is unknown, return null or throw error depending on behavior needed
+				log(`Unknown PRAGMA: ${pragmaName}`);
+				throw new QuereusError(
+					`Unknown pragma: ${pragmaName}`,
+					StatusCode.ERROR,
+					error instanceof Error ? error : undefined
+				);
+			}
+		}
+	};
+
+	return {
+		params: [],
+		run: run as InstructionRun,
+		note: `PRAGMA ${plan.pragmaName}${plan.value !== undefined ? ` = ${plan.value}` : ''}`
+	};
+}

package/src/runtime/emit/project.ts

@@ -0,0 +1,40 @@
+import type { ProjectNode } from '../../planner/nodes/project-node.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
+import { type Row } from '../../common/types.js';
+import { type OutputValue } from '../../common/types.js';
+import type { EmissionContext } from '../emission-context.js';
+import { buildRowDescriptor } from '../../util/row-descriptor.js';
+
+export function emitProject(plan: ProjectNode, ctx: EmissionContext): Instruction {
+	const sourceInstruction = emitPlanNode(plan.source, ctx);
+	const projectionFuncs = plan.projections.map((projection) => {
+		return emitCallFromPlan(projection.node, ctx);
+	});
+
+	// Create row descriptor for source attributes
+	const sourceRowDescriptor = buildRowDescriptor(plan.source.getAttributes());
+
+	async function* run(rctx: RuntimeContext, source: AsyncIterable<Row>, ...projectionFunctions: Array<(ctx: RuntimeContext) => OutputValue>): AsyncIterable<Row> {
+		for await (const sourceRow of source) {
+			// Set up context for this row using row descriptor
+			rctx.context.set(sourceRowDescriptor, () => sourceRow);
+
+			try {
+				const outputs = projectionFunctions.map(func => func(rctx));
+				const resolved = await Promise.all(outputs);
+				// Assume we have ensured that these are all scalar values
+				yield resolved as Row;
+			} finally {
+				// Clean up context for this row
+				rctx.context.delete(sourceRowDescriptor);
+			}
+		}
+	}
+
+	return {
+		params: [sourceInstruction, ...projectionFuncs],
+		run: run as any,
+		note: `project(${plan.projections.length} cols)`
+	};
+}