@quereus/quereus 0.1.0

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

@@ -0,0 +1,50 @@
+import type { ColumnReferenceNode } from '../../planner/nodes/reference.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode, type SqlValue } from '../../common/types.js';
+import type { EmissionContext } from '../emission-context.js';
+import { createLogger } from '../../common/logger.js';
+
+const log = createLogger('runtime:context:lookup');
+
+export function emitColumnReference(plan: ColumnReferenceNode, _ctx: EmissionContext): Instruction {
+	function run(rctx: RuntimeContext): SqlValue {
+		log('Looking up column %s (attr#%d)', plan.expression.name, plan.attributeId);
+
+		// Log available contexts for debugging
+		const availableContexts: string[] = [];
+		for (const [descriptor] of rctx.context.entries()) {
+			const attrs = Object.keys(descriptor).filter(k => descriptor[parseInt(k)] !== undefined);
+			availableContexts.push(`[attrs: ${attrs.join(',')}]`);
+		}
+		log('Available contexts: %O', availableContexts);
+
+		// Use deterministic lookup based on attribute ID
+		for (const [descriptor, rowGetter] of rctx.context.entries()) {
+			const columnIndex = descriptor[plan.attributeId];
+			if (columnIndex !== undefined) {
+				const row = rowGetter();
+				if (Array.isArray(row) && columnIndex < row.length) {
+					const value = row[columnIndex];
+					log('Successfully resolved %s (attr#%d) to value: %O from row: %O at index %d', plan.expression.name, plan.attributeId, value, row, columnIndex);
+					return value;
+				}
+			}
+		}
+
+		log('Failed to resolve %s (attr#%d) - no matching context found', plan.expression.name, plan.attributeId);
+		throw new QuereusError(
+			`No row context found for column ${plan.expression.name} (attr#${plan.attributeId}). The column reference must be evaluated within the context of its source relation.`,
+			StatusCode.ERROR,
+			undefined,
+			plan.expression.loc?.start.line,
+			plan.expression.loc?.start.column
+		);
+	}
+
+	return {
+		params: [],
+		run,
+		note: `column(${plan.expression.name})`
+	};
+}

package/src/runtime/emit/constraint-check.ts

@@ -0,0 +1,285 @@
+import type { ConstraintCheckNode } from '../../planner/nodes/constraint-check-node.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import type { Row } from '../../common/types.js';
+import type { EmissionContext } from '../emission-context.js';
+import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode, type SqlValue, type OutputValue } from '../../common/types.js';
+import type { RowConstraintSchema, TableSchema } from '../../schema/table.js';
+import type { ColumnSchema } from '../../schema/column.js';
+import type { RowDescriptor } from '../../planner/nodes/plan-node.js';
+import { RowOp } from '../../schema/table.js';
+import { buildExpression } from '../../planner/building/expression.js';
+import { GlobalScope } from '../../planner/scopes/global.js';
+import { RegisteredScope } from '../../planner/scopes/registered.js';
+import { ColumnReferenceNode } from '../../planner/nodes/reference.js';
+import * as AST from '../../parser/ast.js';
+import { BuildTimeDependencyTracker } from '../../planner/planning-context.js';
+
+export function emitConstraintCheck(plan: ConstraintCheckNode, ctx: EmissionContext): Instruction {
+	// Get the table schema to access constraints
+	const tableSchema = plan.table.tableSchema;
+
+	// Create flat row descriptor that includes both OLD and NEW attributes
+	const flatRowDescriptor: RowDescriptor = [];
+
+	// OLD attributes are at indices 0..n-1, NEW attributes at n..2n-1
+	if (plan.oldRowDescriptor) {
+		for (const attrIdStr in plan.oldRowDescriptor) {
+			const attrId = parseInt(attrIdStr);
+			const columnIndex = plan.oldRowDescriptor[attrId];
+			if (columnIndex !== undefined) {
+				flatRowDescriptor[attrId] = columnIndex; // OLD section: 0..n-1
+			}
+		}
+	}
+
+	if (plan.newRowDescriptor) {
+		for (const attrIdStr in plan.newRowDescriptor) {
+			const attrId = parseInt(attrIdStr);
+			const columnIndex = plan.newRowDescriptor[attrId];
+			if (columnIndex !== undefined) {
+				flatRowDescriptor[attrId] = tableSchema.columns.length + columnIndex; // NEW section: n..2n-1
+			}
+		}
+	}
+
+	// Discover attribute mappings for constraint building
+	const newAttrIdByCol: Record<string, number> = {};
+	const oldAttrIdByCol: Record<string, number> = {};
+
+	if (plan.newRowDescriptor) {
+		for (const attrIdStr in plan.newRowDescriptor) {
+			const attrId = parseInt(attrIdStr);
+			const columnIndex = plan.newRowDescriptor[attrId];
+			if (columnIndex !== undefined && columnIndex < tableSchema.columns.length) {
+				const column = tableSchema.columns[columnIndex];
+				newAttrIdByCol[column.name.toLowerCase()] = attrId;
+			}
+		}
+	}
+
+	if (plan.oldRowDescriptor) {
+		for (const attrIdStr in plan.oldRowDescriptor) {
+			const attrId = parseInt(attrIdStr);
+			const columnIndex = plan.oldRowDescriptor[attrId];
+			if (columnIndex !== undefined && columnIndex < tableSchema.columns.length) {
+				const column = tableSchema.columns[columnIndex];
+				oldAttrIdByCol[column.name.toLowerCase()] = attrId;
+			}
+		}
+	}
+
+	const checkConstraintData = tableSchema.checkConstraints
+		.filter((constraint: RowConstraintSchema) => shouldCheckConstraint(constraint, plan.operation))
+		.map((constraint: RowConstraintSchema) => {
+			// Build a PlanNode from the AST expression
+			// Create a scope that has access to the table columns for constraint evaluation
+			const scope = new RegisteredScope(new GlobalScope(ctx.db.schemaManager));
+
+			// Register table columns for constraint evaluation using flat row attributes
+			tableSchema.columns.forEach((tableColumn: ColumnSchema, tableColIndex: number) => {
+				const colNameLower = tableColumn.name.toLowerCase();
+
+				// Register NEW.<col> (defaults to NEW for unqualified references)
+				const newAttrId = newAttrIdByCol[colNameLower];
+				if (newAttrId !== undefined) {
+					// Unqualified column name (defaults to NEW)
+					scope.registerSymbol(colNameLower, (exp, s) =>
+						new ColumnReferenceNode(s, exp as AST.ColumnExpr, {
+							typeClass: 'scalar',
+							affinity: tableColumn.affinity,
+							nullable: !tableColumn.notNull,
+							isReadOnly: false
+						}, newAttrId, tableColIndex));
+
+					// NEW.<col>
+					scope.registerSymbol(`new.${colNameLower}`, (exp, s) =>
+						new ColumnReferenceNode(s, exp as AST.ColumnExpr, {
+							typeClass: 'scalar',
+							affinity: tableColumn.affinity,
+							nullable: !tableColumn.notNull,
+							isReadOnly: false
+						}, newAttrId, tableColIndex));
+				}
+
+				// Register OLD.<col>
+				const oldAttrId = oldAttrIdByCol[colNameLower];
+				if (oldAttrId !== undefined) {
+					scope.registerSymbol(`old.${colNameLower}`, (exp, s) =>
+						new ColumnReferenceNode(s, exp as AST.ColumnExpr, {
+							typeClass: 'scalar',
+							affinity: tableColumn.affinity,
+							nullable: true, // OLD values can be NULL
+							isReadOnly: false
+						}, oldAttrId, tableColIndex));
+				}
+			});
+
+			const exprPlanNode = buildExpression(
+								{
+					scope,
+					db: ctx.db,
+					parameters: {},
+					schemaManager: ctx.db.schemaManager,
+					schemaDependencies: new BuildTimeDependencyTracker(), // Not used in constraint evaluation
+					schemaCache: new Map() // Not used in constraint evaluation
+				},
+				constraint.expr
+			);
+
+			return {
+				constraint,
+				evaluator: emitCallFromPlan(exprPlanNode, ctx)
+			};
+		});
+
+	// Extract just the constraint metadata and evaluator functions
+	const constraintMetadata = checkConstraintData.map(item => item.constraint);
+	const checkEvaluators = checkConstraintData.map(item => item.evaluator);
+
+	async function* run(rctx: RuntimeContext, inputRows: AsyncIterable<Row>, ...evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>): AsyncIterable<Row> {
+		if (!inputRows) {
+			return;
+		}
+
+		for await (const inputRow of inputRows) {
+			const flatRow = inputRow;
+
+			// Set up single flat context
+			rctx.context.set(flatRowDescriptor, () => flatRow);
+
+			try {
+				// Check all constraints that apply to this operation
+				await checkConstraints(rctx, plan, tableSchema, flatRow, constraintMetadata, evaluatorFunctions);
+
+				// If all constraints pass, yield the flat row for downstream processing
+				// All downstream operations (INSERT executor, DELETE executor, RETURNING) expect flat rows
+				yield flatRow;
+			} finally {
+				// Clean up flat context
+				rctx.context.delete(flatRowDescriptor);
+			}
+		}
+	}
+
+	// Emit the source instruction
+	const sourceInstruction = emitPlanNode(plan.source, ctx);
+
+	return {
+		params: [sourceInstruction, ...checkEvaluators],
+		run: run as any,
+		note: `constraintCheck(${plan.operation})`
+	};
+}
+
+async function checkConstraints(
+	rctx: RuntimeContext,
+	plan: ConstraintCheckNode,
+	tableSchema: TableSchema,
+	row: Row,
+	constraintMetadata: Array<RowConstraintSchema>,
+	evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>
+): Promise<void> {
+	// Check PRIMARY KEY constraints (UNIQUE constraints on PK columns)
+	await checkPrimaryKeyConstraints(rctx, plan, tableSchema, row);
+
+	// Check NOT NULL constraints on individual columns
+	await checkNotNullConstraints(rctx, plan, tableSchema, row);
+
+	// Check CHECK constraints (both column-level and table-level)
+	await checkCheckConstraints(rctx, plan, tableSchema, constraintMetadata, evaluatorFunctions);
+}
+
+async function checkNotNullConstraints(
+	rctx: RuntimeContext,
+	plan: ConstraintCheckNode,
+	tableSchema: TableSchema,
+	flatRow: Row
+): Promise<void> {
+	// For INSERT operations, check NOT NULL on NEW values
+	// For UPDATE operations, check NOT NULL on NEW values
+	// DELETE operations don't need NOT NULL checks
+	if (plan.operation === RowOp.DELETE) {
+		return;
+	}
+
+	// Check each column for NOT NULL constraint using NEW values
+	if (plan.newRowDescriptor) {
+		for (let i = 0; i < tableSchema.columns.length; i++) {
+			const column = tableSchema.columns[i];
+			if (column.notNull) {
+				// Find the NEW value for this column in the flat row
+				const newValueIndex = tableSchema.columns.length + i; // NEW section: n..2n-1
+				const value = flatRow[newValueIndex];
+
+				if (value === null || value === undefined) {
+					throw new QuereusError(
+						`NOT NULL constraint failed: ${tableSchema.name}.${column.name}`,
+						StatusCode.CONSTRAINT
+					);
+				}
+			}
+		}
+	}
+}
+
+async function checkPrimaryKeyConstraints(
+	_rctx: RuntimeContext,
+	_plan: ConstraintCheckNode,
+	_tableSchema: TableSchema,
+	_row: Row
+): Promise<void> {
+	// Primary Key constraints are enforced at the VTable level for now
+	// This is simpler and more efficient than trying to implement it at the engine level
+	// since the VTable has direct access to the current table state
+	return;
+}
+
+async function checkCheckConstraints(
+	rctx: RuntimeContext,
+	plan: ConstraintCheckNode,
+	tableSchema: TableSchema,
+	constraintMetadata: Array<RowConstraintSchema>,
+	evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>
+): Promise<void> {
+	// Evaluate each CHECK constraint
+	for (let i = 0; i < constraintMetadata.length; i++) {
+		const constraint = constraintMetadata[i];
+		const evaluator = evaluatorFunctions[i];
+
+		try {
+			// Use the evaluator function to get the constraint result
+			const result = evaluator(rctx) as SqlValue;
+
+			// CHECK constraint passes if result is truthy or NULL
+			// It fails only if result is false or 0 (SQLite-style numeric boolean)
+			if (result === false || result === 0) {
+				// Generate a proper constraint name if none was provided
+				// IMPORTANT: Use the original index from the full tableSchema.checkConstraints array
+				// not the filtered index, to get the correct constraint name
+				const constraintName = constraint.name || generateDefaultConstraintName(tableSchema, constraint);
+				throw new QuereusError(
+					`CHECK constraint failed: ${constraintName}`,
+					StatusCode.CONSTRAINT
+				);
+			}
+		} catch (error) {
+			if (error instanceof QuereusError && error.message.includes('CHECK constraint failed')) {
+				throw error;
+			}
+			throw error;
+		}
+	}
+}
+
+function shouldCheckConstraint(constraint: RowConstraintSchema, operation: RowOp): boolean {
+	// Check if the current operation is in the constraint's operations bitmask
+	return (constraint.operations & operation) !== 0;
+}
+
+function generateDefaultConstraintName(tableSchema: TableSchema, constraint: RowConstraintSchema): string {
+	// Find the index of this constraint in the original array to get the correct constraint number
+	const originalIndex = tableSchema.checkConstraints.findIndex((c: RowConstraintSchema) => c === constraint);
+	return `check_${originalIndex >= 0 ? originalIndex : 'unknown'}`;
+}

package/src/runtime/emit/create-index.ts

@@ -0,0 +1,15 @@
+import type { CreateIndexNode } from '../../planner/nodes/create-index-node.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
+import { type SqlValue } from '../../common/types.js';
+import type { EmissionContext } from '../emission-context.js';
+
+export function emitCreateIndex(plan: CreateIndexNode, _ctx: EmissionContext): Instruction {
+	async function run(rctx: RuntimeContext): Promise<SqlValue | undefined> {
+		await rctx.db.schemaManager.createIndex(plan.statementAst);
+		// The specific error handling for IF NOT EXISTS is within SchemaManager.createIndex.
+
+		return null; // Explicitly return null for successful void operations
+	}
+
+	return { params: [], run: run as InstructionRun };
+}

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

@@ -0,0 +1,15 @@
+import type { CreateTableNode } from '../../planner/nodes/create-table-node.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
+import { type SqlValue } from '../../common/types.js';
+import type { EmissionContext } from '../emission-context.js';
+
+export function emitCreateTable(plan: CreateTableNode, _ctx: EmissionContext): Instruction {
+	async function run(rctx: RuntimeContext): Promise<SqlValue | undefined> {
+		await rctx.db.schemaManager.createTable(plan.statementAst);
+		// The specific error handling for IF NOT EXISTS is within SchemaManager.defineTable.
+
+		return null; // Explicitly return null for successful void operations
+	}
+
+	return { params: [], run: run as InstructionRun };
+}

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

@@ -0,0 +1,52 @@
+import type { CreateViewNode } from '../../planner/nodes/create-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';
+import type { ViewSchema } from '../../schema/view.js';
+
+export function emitCreateView(plan: CreateViewNode, _ctx: EmissionContext): Instruction {
+	async function run(rctx: RuntimeContext): Promise<SqlValue> {
+		// Check if view already exists
+		const existingView = rctx.db.schemaManager.getView(plan.schemaName, plan.viewName);
+
+		if (existingView && !plan.ifNotExists) {
+			throw new QuereusError(
+				`View '${plan.schemaName}.${plan.viewName}' already exists`,
+				StatusCode.ERROR
+			);
+		}
+
+		if (existingView && plan.ifNotExists) {
+			// View exists but IF NOT EXISTS was specified, so this is a no-op
+			return null;
+		}
+
+		// Create the view schema
+		const viewSchema: ViewSchema = {
+			name: plan.viewName,
+			schemaName: plan.schemaName,
+			sql: plan.sql,
+			selectAst: plan.selectStmt,
+			columns: plan.columns
+		};
+
+		// Add the view to the schema manager
+		const schema = rctx.db.schemaManager.getSchema(plan.schemaName);
+		if (!schema) {
+			throw new QuereusError(
+				`Schema '${plan.schemaName}' does not exist`,
+				StatusCode.ERROR
+			);
+		}
+
+		schema.addView(viewSchema);
+		return null; // Explicitly return null for successful void operations
+	}
+
+	return {
+		params: [],
+		run,
+		note: `createView(${plan.schemaName}.${plan.viewName})`
+	};
+}

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

@@ -0,0 +1,75 @@
+import type { Row } from '../../common/types.js';
+import type { CTEReferenceNode } from '../../planner/nodes/cte-reference-node.js';
+import type { EmissionContext } from '../emission-context.js';
+import { emitPlanNode, createValidatedInstruction } from '../emitters.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import { PlanNodeType } from '../../planner/nodes/plan-node-type.js';
+import { buildRowDescriptor } from '../../util/row-descriptor.js';
+
+export function emitCTEReference(plan: CTEReferenceNode, ctx: EmissionContext): Instruction {
+	// Create row descriptor for output attributes
+	const rowDescriptor = buildRowDescriptor(plan.getAttributes());
+
+	// Check if this is an internal recursive reference (inside the recursive case)
+	// These use table context to access the working table
+	const isInternalRecursiveRef = plan.source.nodeType === PlanNodeType.CTE && plan.source.isRecursive;
+
+	if (isInternalRecursiveRef) {
+		// Internal recursive CTE reference: Look up the working table from table contexts
+		async function* run(rctx: RuntimeContext): AsyncIterable<Row> {
+			const tableGetter = rctx.tableContexts.get(plan.source.tableDescriptor);
+			if (!tableGetter) {
+				throw new QuereusError(
+					`Recursive CTE '${plan.source.cteName}' not found in table context`,
+					StatusCode.INTERNAL
+				);
+			}
+
+			// Execute the working table and yield each row
+			for await (const row of tableGetter()) {
+				// Set up context for this row using row descriptor
+				rctx.context.set(rowDescriptor, () => row);
+				try {
+					yield row;
+				} finally {
+					// Clean up context
+					rctx.context.delete(rowDescriptor);
+				}
+			}
+		}
+
+		return createValidatedInstruction(
+			[], // No instruction parameters - data comes from table context
+			run as any,
+			ctx,
+			`cte_ref(internal_recursive ${plan.source.cteName}${plan.alias ? ` AS ${plan.alias}` : ''})`
+		);
+	} else {
+		// External CTE reference (or non-recursive): Use normal instruction parameter approach
+		async function* run(rctx: RuntimeContext, cteResult: AsyncIterable<Row>): AsyncIterable<Row> {
+			// Execute the CTE and yield each row
+			for await (const row of cteResult) {
+				// Set up context for this row using row descriptor
+				rctx.context.set(rowDescriptor, () => row);
+				try {
+					yield row;
+				} finally {
+					// Clean up context
+					rctx.context.delete(rowDescriptor);
+				}
+			}
+		}
+
+		// Emit the underlying CTE
+		const cteInstruction = emitPlanNode(plan.source, ctx);
+
+		return createValidatedInstruction(
+			[cteInstruction],
+			run as any,
+			ctx,
+			`cte_ref(${plan.source.isRecursive ? 'external_recursive' : 'non_recursive'} ${plan.source.cteName}${plan.alias ? ` AS ${plan.alias}` : ''})`
+		);
+	}
+}

package/src/runtime/emit/cte.ts

@@ -0,0 +1,39 @@
+import type { CTENode } from '../../planner/nodes/cte-node.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import type { EmissionContext } from '../emission-context.js';
+import { emitPlanNode } from '../emitters.js';
+import type { Row } from '../../common/types.js';
+
+export function emitCTE(plan: CTENode, ctx: EmissionContext): Instruction {
+	// Emit the underlying query
+	const queryInstruction = emitPlanNode(plan.source, ctx);
+
+	// For now, we'll implement CTEs as simply executing the underlying query
+	// In a full implementation, this would handle materialization based on the hint
+	async function* run(rctx: RuntimeContext, queryResult: AsyncIterable<Row>): AsyncIterable<Row> {
+		// If materialization is explicitly requested or beneficial,
+		// we could materialize the result here
+		if (plan.materializationHint === 'materialized') {
+			// Materialize the CTE result
+			const materializedRows: Row[] = [];
+			for await (const row of queryResult) {
+				materializedRows.push(row);
+			}
+			// Yield all materialized rows
+			for (const row of materializedRows) {
+				yield row;
+			}
+		} else {
+			// Stream the results directly
+			for await (const row of queryResult) {
+				yield row;
+			}
+		}
+	}
+
+	return {
+		params: [queryInstruction],
+		run: run as any,
+		note: `cte(${plan.cteName})`
+	};
+}

package/src/runtime/emit/delete.ts

@@ -0,0 +1,24 @@
+import type { DeleteNode } from '../../planner/nodes/delete-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 emitDelete(plan: DeleteNode, ctx: EmissionContext): Instruction {
+	// DELETE node now only handles data transformations and passes flat rows through.
+	// The actual database delete operations are handled by DmlExecutorNode.
+	async function* run(ctx: RuntimeContext, flatRowsIterable: AsyncIterable<Row>): AsyncIterable<Row> {
+		// Simply yield all flat rows from the source (which has already applied filtering, etc.)
+		for await (const flatRow of flatRowsIterable) {
+			yield flatRow;
+		}
+	}
+
+	const sourceInstruction = emitPlanNode(plan.source, ctx);
+
+	return {
+		params: [sourceInstruction],
+		run: run as InstructionRun,
+		note: `deletePrep(${plan.table.tableSchema.name})`
+	};
+}

package/src/runtime/emit/distinct.ts

@@ -0,0 +1,45 @@
+import type { DistinctNode } from '../../planner/nodes/distinct-node.js';
+import type { Instruction, RuntimeContext } from '../types.js';
+import { emitPlanNode } from '../emitters.js';
+import { type Row } from '../../common/types.js';
+import type { EmissionContext } from '../emission-context.js';
+import { compareRows } from '../../util/comparison.js';
+import { BTree } from 'inheritree';
+import { buildRowDescriptor } from '../../util/row-descriptor.js';
+
+export function emitDistinct(plan: DistinctNode, ctx: EmissionContext): Instruction {
+	// Create row descriptor for output attributes (same as source since DISTINCT preserves attributes)
+	const outputRowDescriptor = buildRowDescriptor(plan.getAttributes());
+
+	async function* run(ctx: RuntimeContext, source: AsyncIterable<Row>): AsyncIterable<Row> {
+		// Create BTree to efficiently track distinct rows
+		const distinctTree = new BTree<Row, Row>(
+			(row: Row) => row, // Identity function - use row as its own key
+			compareRows
+		);
+
+		for await (const sourceRow of source) {
+			// Check if we've seen this row before using BTree lookup
+			const newPath = distinctTree.insert(sourceRow);
+
+			if (newPath.on) {
+				// This is a new distinct row - set up context and yield it
+				ctx.context.set(outputRowDescriptor, () => sourceRow);
+				try {
+					yield sourceRow;
+				} finally {
+					// Clean up context for this row
+					ctx.context.delete(outputRowDescriptor);
+				}
+			}
+		}
+	}
+
+	const sourceInstruction = emitPlanNode(plan.source, ctx);
+
+	return {
+		params: [sourceInstruction],
+		run: run as any,
+		note: 'distinct (btree-optimized)'
+	};
+}