@quereus/quereus 0.1.0

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

@@ -0,0 +1,92 @@
+import type { TableReferenceNode } from '../../planner/nodes/reference.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import type { EmissionContext } from '../emission-context.js';
+import type { Row } from '../../common/types.js';
+import { disconnectVTable } from '../utils.js';
+import { createValidatedInstruction } from '../emitters.js';
+import type { FilterInfo } from '../../vtab/filter-info.js';
+import type { IndexInfo, IndexConstraintUsage } from '../../vtab/index-info.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import { buildRowDescriptor } from '../../util/row-descriptor.js';
+
+export function emitTableReference(plan: TableReferenceNode, ctx: EmissionContext): Instruction {
+	// Create row descriptor for output attributes
+	const rowDescriptor = buildRowDescriptor(plan.getAttributes());
+
+	async function* run(rctx: RuntimeContext): AsyncIterable<Row> {
+		// Get the table schema and pre-resolved vtab module
+		const tableSchema = plan.tableSchema;
+		const vtabModule = plan.vtabModule;
+		const vtabAuxData = plan.vtabAuxData;
+
+		// Create vtab instance using pre-resolved module
+		if (typeof vtabModule.xConnect !== 'function') {
+			throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' does not implement xConnect`, StatusCode.MISUSE);
+		}
+
+		const vtabArgs = tableSchema.vtabArgs || {};
+		const vtab = vtabModule.xConnect(
+			rctx.db,
+			vtabAuxData,
+			tableSchema.vtabModuleName,
+			tableSchema.schemaName,
+			tableSchema.name,
+			vtabArgs
+		);
+
+		try {
+			// Set up context for each row using row descriptor
+			let row: Row;
+			rctx.context.set(rowDescriptor, () => row);
+
+			// Check if the virtual table supports xQuery
+			if (typeof vtab.xQuery === 'function') {
+				// Create a minimal FilterInfo for full table scan
+				const defaultIndexInfo: IndexInfo = {
+					nConstraint: 0,
+					aConstraint: [],
+					nOrderBy: 0,
+					aOrderBy: [],
+					aConstraintUsage: [] as IndexConstraintUsage[],
+					idxNum: 0,
+					idxStr: 'fullscan',
+					orderByConsumed: false,
+					estimatedCost: 1000,
+					estimatedRows: BigInt(100),
+					idxFlags: 0,
+					colUsed: 0n,
+				};
+
+				const filterInfo: FilterInfo = {
+					idxNum: 0,
+					idxStr: 'fullscan',
+					constraints: [],
+					args: [],
+					indexInfoOutput: defaultIndexInfo,
+				};
+
+				// Use xQuery with the filter info
+				const asyncRowIterable = vtab.xQuery(filterInfo);
+				for await (row of asyncRowIterable) {
+					yield row;
+				}
+			} else {
+				throw new QuereusError(`Virtual table '${tableSchema.name}' does not support xQuery.`, StatusCode.UNSUPPORTED);
+			}
+
+			// Clean up context
+			rctx.context.delete(rowDescriptor);
+		} finally {
+			// Properly disconnect the VirtualTable instance
+			await disconnectVTable(rctx, vtab);
+		}
+	}
+
+	return createValidatedInstruction(
+		[],
+		run,
+		ctx,
+		`table_ref(${plan.tableSchema.schemaName}.${plan.tableSchema.name})`
+	);
+}

package/src/runtime/emit/table-valued-function.ts

@@ -0,0 +1,119 @@
+import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
+import { emitPlanNode, createValidatedInstruction } from '../emitters.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode, type SqlValue, type Row } from '../../common/types.js';
+import type { FunctionSchema, IntegratedTableValuedFunc, TableValuedFunc } from '../../schema/function.js';
+import { isTableValuedFunctionSchema } from '../../schema/function.js';
+import type { EmissionContext } from '../emission-context.js';
+import type { TableFunctionCallNode } from '../../planner/nodes/table-function-call.js';
+import { buildRowDescriptor } from '../../util/row-descriptor.js';
+
+export function emitTableValuedFunctionCall(plan: TableFunctionCallNode, ctx: EmissionContext): Instruction {
+	const functionName = plan.functionName.toLowerCase();
+	const numArgs = plan.operands.length;
+
+	// Create row descriptor for function output attributes
+	const rowDescriptor = buildRowDescriptor(plan.getAttributes());
+
+	// Look up the function during emission and record the dependency
+	// First try exact argument count, then try variable argument function
+	let functionSchema = ctx.findFunction(functionName, numArgs);
+	if (!functionSchema) {
+		functionSchema = ctx.findFunction(functionName, -1); // Try variable argument function
+	}
+	if (!functionSchema) {
+		throw new QuereusError(`Unknown function: ${functionName}/${numArgs}`, StatusCode.ERROR);
+	}
+	if (!isTableValuedFunctionSchema(functionSchema)) {
+		throw new QuereusError(`Function ${functionName}/${numArgs} is not a table-valued function`, StatusCode.ERROR);
+	}
+
+	// Capture the function key for runtime retrieval (use the actual function's numArgs)
+	const functionKey = `function:${functionName}/${functionSchema.numArgs}`;
+
+	async function* runIntegrated(innerCtx: RuntimeContext, ...args: Array<SqlValue>): AsyncIterable<Row> {
+		// Use the captured function schema instead of doing a fresh lookup
+		const capturedFunction = ctx.getCapturedSchemaObject<FunctionSchema>(functionKey);
+		if (!capturedFunction) {
+			throw new QuereusError(`Function ${functionName}/${numArgs} was not captured during emission`, StatusCode.INTERNAL);
+		}
+
+		if (!isTableValuedFunctionSchema(capturedFunction)) {
+			throw new QuereusError(`Function ${functionName}/${numArgs} is not a table-valued function at runtime`, StatusCode.INTERNAL);
+		}
+
+		try {
+			// Check if this is a database-aware function
+			const result = (capturedFunction.implementation as IntegratedTableValuedFunc)!(innerCtx.db, ...args);
+
+			// Handle both direct AsyncIterable and Promise<AsyncIterable>
+			const iterable = result instanceof Promise ? await result : result;
+
+			for await (const row of iterable) {
+				// Set up row context for column references
+				innerCtx.context.set(rowDescriptor, () => row);
+				try {
+					yield row;
+				} finally {
+					// Clean up row context
+					innerCtx.context.delete(rowDescriptor);
+				}
+			}
+		} catch (error: any) {
+			throw new QuereusError(`Table-valued function ${functionName} failed: ${error.message}`, StatusCode.ERROR, error);
+		}
+	}
+
+	async function* run(innerCtx: RuntimeContext, ...args: Array<SqlValue>): AsyncIterable<Row> {
+		// Use the captured function schema instead of doing a fresh lookup
+		const capturedFunction = ctx.getCapturedSchemaObject<FunctionSchema>(functionKey);
+		if (!capturedFunction) {
+			throw new QuereusError(`Function ${functionName}/${functionSchema!.numArgs} was not captured during emission`, StatusCode.INTERNAL);
+		}
+
+		if (!isTableValuedFunctionSchema(capturedFunction)) {
+			throw new QuereusError(`Function ${functionName}/${numArgs} is not a table-valued function at runtime`, StatusCode.INTERNAL);
+		}
+
+		// Validate argument count for variable argument functions
+		if (capturedFunction.numArgs === -1) {
+			// Special validation for known variable argument functions
+			if (functionName === 'json_each' || functionName === 'json_tree') {
+				if (args.length < 1 || args.length > 2) {
+					throw new QuereusError(`${functionName} requires 1 or 2 arguments (jsonSource, [rootPath])`, StatusCode.ERROR);
+				}
+			}
+		}
+
+		try {
+			// Check if this is a database-aware function
+			const result = (capturedFunction.implementation as TableValuedFunc)!(...args);
+
+			// Handle both direct AsyncIterable and Promise<AsyncIterable>
+			const iterable = result instanceof Promise ? await result : result;
+
+			for await (const row of iterable) {
+				// Set up row context for column references
+				innerCtx.context.set(rowDescriptor, () => row);
+				try {
+					yield row;
+				} finally {
+					// Clean up row context
+					innerCtx.context.delete(rowDescriptor);
+				}
+			}
+		} catch (error: any) {
+			throw new QuereusError(`Table-valued function ${functionName} failed: ${error.message}`, StatusCode.ERROR, error);
+		}
+	}
+
+	const operandExprs = plan.operands.map(operand => emitPlanNode(operand, ctx));
+	const runFunction = functionSchema.isIntegrated ? runIntegrated : run;
+
+	return createValidatedInstruction(
+		[...operandExprs],
+		runFunction as InstructionRun,
+		ctx,
+		`TVF:${plan.functionName}(${plan.operands.length})`
+	);
+}

package/src/runtime/emit/transaction.ts

@@ -0,0 +1,167 @@
+import type { EmissionContext } from '../emission-context.js';
+import type { TransactionNode } from '../../planner/nodes/transaction-node.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
+import type { SqlValue } 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:transaction');
+
+// Simple hash function to convert savepoint names to indices
+function hashSavepointName(name: string): number {
+	let hash = 0;
+	for (let i = 0; i < name.length; i++) {
+		const char = name.charCodeAt(i);
+		hash = ((hash << 5) - hash) + char;
+		hash = hash & hash; // Convert to 32-bit integer
+	}
+	return Math.abs(hash);
+}
+
+export function emitTransaction(plan: TransactionNode, _ctx: EmissionContext): Instruction {
+	// Select the operation function at emit time
+	let run: (ctx: RuntimeContext) => Promise<SqlValue | undefined>;
+	let note: string;
+
+	switch (plan.operation) {
+		case 'begin': {
+			run = async (rctx: RuntimeContext) => {
+				const connections = rctx.db.getAllConnections();
+				log(`BEGIN: Found ${connections.length} active connections`);
+
+				for (const connection of connections) {
+					try {
+						await connection.begin();
+						log(`BEGIN: Successfully called on connection ${connection.connectionId}`);
+					} catch (error) {
+						log(`BEGIN: Error on connection ${connection.connectionId}: %O`, error);
+						throw error;
+					}
+				}
+				return null;
+			};
+			note = `BEGIN ${plan.mode || 'DEFERRED'}`;
+			break;
+		}
+		case 'commit': {
+			run = async (rctx: RuntimeContext) => {
+				const connections = rctx.db.getAllConnections();
+				log(`COMMIT: Found ${connections.length} active connections`);
+
+				for (const connection of connections) {
+					try {
+						await connection.commit();
+						log(`COMMIT: Successfully called on connection ${connection.connectionId}`);
+					} catch (error) {
+						log(`COMMIT: Error on connection ${connection.connectionId}: %O`, error);
+						throw error;
+					}
+				}
+				return null;
+			};
+			note = 'COMMIT';
+			break;
+		}
+
+		case 'rollback': {
+			if (plan.savepoint) {
+				const savepointIndex = hashSavepointName(plan.savepoint); // Convert name to index
+				run = async (rctx: RuntimeContext) => {
+					const connections = rctx.db.getAllConnections();
+					log(`ROLLBACK TO SAVEPOINT ${savepointIndex}: Found ${connections.length} active connections`);
+
+					for (const connection of connections) {
+						try {
+							await connection.rollbackToSavepoint(savepointIndex);
+							log(`ROLLBACK TO SAVEPOINT ${savepointIndex}: Successfully called on connection ${connection.connectionId}`);
+						} catch (error) {
+							log(`ROLLBACK TO SAVEPOINT ${savepointIndex}: Error on connection ${connection.connectionId}: %O`, error);
+							throw error;
+						}
+					}
+					return null;
+				};
+				note = `ROLLBACK TO SAVEPOINT ${plan.savepoint}`;
+			} else {
+				run = async (rctx: RuntimeContext) => {
+					const connections = rctx.db.getAllConnections();
+					log(`ROLLBACK: Found ${connections.length} active connections`);
+
+					for (const connection of connections) {
+						try {
+							await connection.rollback();
+							log(`ROLLBACK: Successfully called on connection ${connection.connectionId}`);
+						} catch (error) {
+							log(`ROLLBACK: Error on connection ${connection.connectionId}: %O`, error);
+							throw error;
+						}
+					}
+					return null;
+				};
+				note = 'ROLLBACK';
+			}
+			break;
+		}
+
+		case 'savepoint': {
+			if (!plan.savepoint) {
+				quereusError('Savepoint name is required for SAVEPOINT operation', StatusCode.MISUSE);
+			}
+			const savepointIndex = hashSavepointName(plan.savepoint); // Convert name to index
+			run = async (rctx: RuntimeContext) => {
+				const connections = rctx.db.getAllConnections();
+				log(`SAVEPOINT ${savepointIndex}: Found ${connections.length} active connections`);
+
+				for (const connection of connections) {
+					try {
+						await connection.createSavepoint(savepointIndex);
+						log(`SAVEPOINT ${savepointIndex}: Successfully called on connection ${connection.connectionId}`);
+					} catch (error) {
+						log(`SAVEPOINT ${savepointIndex}: Error on connection ${connection.connectionId}: %O`, error);
+						throw error;
+					}
+				}
+				return null;
+			};
+			note = `SAVEPOINT ${plan.savepoint}`;
+			break;
+		}
+
+		case 'release': {
+			if (!plan.savepoint) {
+				quereusError('Savepoint name is required for RELEASE operation', StatusCode.MISUSE);
+			}
+			const releaseSavepointIndex = hashSavepointName(plan.savepoint); // Convert name to index
+			run = async (rctx: RuntimeContext) => {
+				const connections = rctx.db.getAllConnections();
+				log(`RELEASE SAVEPOINT ${releaseSavepointIndex}: Found ${connections.length} active connections`);
+
+				for (const connection of connections) {
+					try {
+						await connection.releaseSavepoint(releaseSavepointIndex);
+						log(`RELEASE SAVEPOINT ${releaseSavepointIndex}: Successfully called on connection ${connection.connectionId}`);
+					} catch (error) {
+						log(`RELEASE SAVEPOINT ${releaseSavepointIndex}: Error on connection ${connection.connectionId}: %O`, error);
+						throw error;
+					}
+				}
+				return null;
+			};
+			note = `RELEASE SAVEPOINT ${plan.savepoint}`;
+			break;
+		}
+
+		default:
+			quereusError(
+				`Unsupported transaction operation: ${plan.operation}`,
+				StatusCode.UNSUPPORTED
+			);
+	}
+
+	return {
+		params: [],
+		run: run as InstructionRun,
+		note
+	};
+}

package/src/runtime/emit/unary.ts

@@ -0,0 +1,85 @@
+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 { UnaryOpNode } from "../../planner/nodes/scalar.js";
+import { emitPlanNode } from "../emitters.js";
+import type { EmissionContext } from "../emission-context.js";
+import { isTruthy } from "../../util/comparison.js";
+
+export function emitUnaryOp(plan: UnaryOpNode, ctx: EmissionContext): Instruction {
+	// Select the operation function at emit time
+	let run: (ctx: RuntimeContext, operand: SqlValue) => SqlValue;
+	let note: string;
+
+	switch (plan.expression.operator) {
+		case 'NOT':
+			run = (ctx: RuntimeContext, operand: SqlValue) => {
+				// SQL NOT: NULL -> NULL, 0 -> 1, anything else -> 0
+				if (operand === null) return null;
+				return isTruthy(operand) ? 0 : 1;
+			};
+			note = 'NOT';
+			break;
+
+		case 'IS NULL':
+			run = (ctx: RuntimeContext, operand: SqlValue) => {
+				return operand === null ? 1 : 0;
+			};
+			note = 'IS NULL';
+			break;
+
+		case 'IS NOT NULL':
+			run = (ctx: RuntimeContext, operand: SqlValue) => {
+				return operand !== null ? 1 : 0;
+			};
+			note = 'IS NOT NULL';
+			break;
+
+		case '-':
+			run = (ctx: RuntimeContext, operand: SqlValue) => {
+				if (operand === null) return null;
+				if (typeof operand === 'number') return -operand;
+				if (typeof operand === 'bigint') return -operand;
+				// Try to convert to number
+				const num = Number(operand);
+				return isNaN(num) ? null : -num;
+			};
+			note = 'unary -';
+			break;
+
+		case '+':
+			run = (ctx: RuntimeContext, operand: SqlValue) => {
+				// Unary plus - convert to number if possible
+				if (operand === null) return null;
+				if (typeof operand === 'number' || typeof operand === 'bigint') return operand;
+				const plusNum = Number(operand);
+				return isNaN(plusNum) ? null : plusNum;
+			};
+			note = 'unary +';
+			break;
+
+		case '~':
+			run = (ctx: RuntimeContext, operand: SqlValue) => {
+				if (operand === null) return null;
+				if (typeof operand === 'bigint') return ~operand;
+				// Convert to integer and apply bitwise NOT
+				const num = Number(operand);
+				if (isNaN(num)) return null;
+				return ~Math.trunc(num);
+			};
+			note = 'bitwise ~';
+			break;
+
+		default:
+			throw new QuereusError(`Unsupported unary operator: ${plan.expression.operator}`, StatusCode.UNSUPPORTED);
+	}
+
+	const operandExpr = emitPlanNode(plan.operand, ctx);
+
+	return {
+		params: [operandExpr],
+		run: run as InstructionRun,
+		note
+	};
+}

package/src/runtime/emit/update.ts

@@ -0,0 +1,73 @@
+import type { UpdateNode } from '../../planner/nodes/update-node.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
+import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode, type SqlValue, type Row } from '../../common/types.js';
+import type { EmissionContext } from '../emission-context.js';
+import { buildRowDescriptor, composeOldNewRow } from '../../util/row-descriptor.js';
+
+export function emitUpdate(plan: UpdateNode, ctx: EmissionContext): Instruction {
+	const tableSchema = plan.table.tableSchema;
+
+	// Create row descriptor for the source rows (needed for assignment expression evaluation)
+	const sourceRowDescriptor = buildRowDescriptor(plan.source.getAttributes());
+
+	// Pre-calculate assignment column indices
+	const assignmentTargetIndices = plan.assignments.map(assign => {
+		const colNameLower = assign.targetColumn.name.toLowerCase();
+		const tableColIdx = tableSchema.columnIndexMap.get(colNameLower);
+		if (tableColIdx === undefined) {
+			throw new QuereusError(`Column '${assign.targetColumn.name}' not found in table '${tableSchema.name}' during emitUpdate.`, StatusCode.INTERNAL);
+		}
+		return tableColIdx;
+	});
+
+	// Emit assignment value expressions as callbacks
+	const assignmentEvaluators = plan.assignments.map(assign =>
+		emitCallFromPlan(assign.value, ctx)
+	);
+
+	async function* run(rctx: RuntimeContext, sourceRowsIterable: AsyncIterable<Row>, ...assignmentEvaluators: Array<(ctx: RuntimeContext) => SqlValue>): AsyncIterable<Row> {
+		for await (const sourceRow of sourceRowsIterable) {
+			// Set up row context for evaluating assignment expressions
+			rctx.context.set(sourceRowDescriptor, () => sourceRow);
+
+			try {
+				// Evaluate assignment expressions in the context of this row
+				const assignmentValues: SqlValue[] = [];
+				for (const evaluator of assignmentEvaluators) {
+					const value = evaluator(rctx) as SqlValue;
+					assignmentValues.push(value);
+				}
+
+				// Create a new row with updated values
+				const updatedRow = [...sourceRow]; // Copy the original row
+
+				// Apply assignment values to the row
+				for (let i = 0; i < assignmentValues.length; i++) {
+					const targetColIdx = assignmentTargetIndices[i];
+					updatedRow[targetColIdx] = assignmentValues[i];
+				}
+
+				// Create flat row with OLD (source) and NEW (updated) values for constraint checking
+				const flatRow = composeOldNewRow(sourceRow, updatedRow, tableSchema.columns.length);
+
+				// Yield the flat row for constraint checking
+				// NOTE: UpdateNode only transforms rows - it does NOT execute the actual update
+				// The UpdateExecutorNode is responsible for calling vtab.xUpdate
+				yield flatRow;
+			} finally {
+				// Clean up row context
+				rctx.context.delete(sourceRowDescriptor);
+			}
+		}
+	}
+
+	const sourceInstruction = emitPlanNode(plan.source, ctx);
+
+	return {
+		params: [sourceInstruction, ...assignmentEvaluators],
+		run: run as InstructionRun,
+		note: `transformUpdateRows(${plan.table.tableSchema.name}, ${plan.assignments.length} cols)`
+	};
+}

package/src/runtime/emit/values.ts

@@ -0,0 +1,66 @@
+import type { ValuesNode } from '../../planner/nodes/values-node.js';
+import type { SingleRowNode } from '../../planner/nodes/single-row.js';
+import type { TableLiteralNode } from '../../planner/nodes/values-node.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import { emitPlanNode } from '../emitters.js';
+import { type SqlValue, type Row, StatusCode } from '../../common/types.js';
+import { QuereusError } from '../../common/errors.js';
+import type { EmissionContext } from '../emission-context.js';
+
+export function emitSingleRow(_plan: SingleRowNode, _ctx: EmissionContext): Instruction {
+	async function* run(_rctx: RuntimeContext): AsyncIterable<Row> {
+		yield []; // Yield one empty row
+	}
+
+	return {
+		params: [],
+		run,
+		note: 'single_row'
+	};
+}
+
+export function emitValues(plan: ValuesNode, ctx: EmissionContext): Instruction {
+	const nCols = plan.getType().columns.length;
+
+	async function* run(ctx: RuntimeContext, ...values: Array<SqlValue>): AsyncIterable<Row> {
+		for (let i = 0; i < values.length; i += nCols) {
+			const row = values.slice(i, i + nCols);
+			yield row;
+		}
+	}
+
+	// Flatten all rows into a single array of expressions
+	const rowExprs = plan.rows.flatMap(row => {
+		if (row.length !== nCols) {
+			throw new QuereusError('All rows must have the same number of columns', StatusCode.SYNTAX, undefined, row[0]?.expression.loc?.start.line, row.at(-1)?.expression.loc?.start.column);
+		}
+		return row.map(expr => emitPlanNode(expr, ctx));
+	});
+
+	return {
+		params: rowExprs,
+		run: run as any,
+		note: `values(${plan.rows.length} rows, ${plan.rows[0]?.length || 0} cols)`
+	};
+}
+
+export function emitTableLiteral(plan: TableLiteralNode, _ctx: EmissionContext): Instruction {
+	async function* runArray(_rctx: RuntimeContext): AsyncIterable<Row> {
+		for (const row of plan.rows as ReadonlyArray<Row>) {
+			yield row;
+		}
+	}
+
+	async function* runAsyncIterable(_rctx: RuntimeContext): AsyncIterable<Row> {
+		yield* plan.rows as AsyncIterable<Row>;
+	}
+
+	const run = plan.rows instanceof Array ? runArray : runAsyncIterable;
+
+	return {
+		params: [],
+		run,
+		note: `tableLiteral(${plan.rowCount ?? '?'} rows, ${plan.getType().columns.length} cols)`
+	};
+}
+

package/src/runtime/emit/window-function.ts

@@ -0,0 +1,42 @@
+import type { WindowFunctionCallNode } from '../../planner/nodes/window-function.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import type { SqlValue } from '../../common/types.js';
+import type { EmissionContext } from '../emission-context.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+
+export function emitWindowFunctionCall(plan: WindowFunctionCallNode, _ctx: EmissionContext): Instruction {
+	const functionName = plan.functionName.toLowerCase();
+
+	if (functionName === 'row_number') {
+		// For ROW_NUMBER(), use a simple counter that resets for each query execution
+		let rowCounter = 0;
+
+		function run(_rctx: RuntimeContext): SqlValue {
+			return ++rowCounter;
+		}
+
+		return {
+			params: [],
+			run,
+			note: `windowFunctionCall(${plan.functionName})`
+		};
+	}
+
+	if (functionName === 'rank' || functionName === 'dense_rank') {
+		// For RANK() and DENSE_RANK(), use simple counter for now
+		let rowCounter = 0;
+
+		function run(_rctx: RuntimeContext): SqlValue {
+			return ++rowCounter;
+		}
+
+		return {
+			params: [],
+			run,
+			note: `windowFunctionCall(${plan.functionName})`
+		};
+	}
+
+	throw new QuereusError(`Window function '${plan.functionName}' not yet implemented`, StatusCode.UNSUPPORTED);
+}