@quereus/quereus 0.7.3 → 0.7.5

package/src/runtime/emit/unary.ts

@@ -1,101 +0,0 @@
-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";
-import { Temporal } from 'temporal-polyfill';
-
-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;
-
-	// Normalize operator to uppercase for case-insensitive matching
-	const operator = plan.expression.operator.toUpperCase();
-
-	switch (operator) {
-		case 'NOT':
-			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				// SQL NOT: NULL -> NULL, false -> true, true -> false
-				if (operand === null) return null;
-				return !isTruthy(operand);
-			};
-			note = 'NOT';
-			break;
-
-		case 'IS NULL':
-			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				return operand === null;
-			};
-			note = 'IS NULL';
-			break;
-
-		case 'IS NOT NULL':
-			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				return operand !== null;
-			};
-			note = 'IS NOT NULL';
-			break;
-
-		case '-':
-			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				if (operand === null) return null;
-
-				// Check if it's a timespan (ISO 8601 duration string)
-				if (typeof operand === 'string' && (operand.startsWith('P') || operand.startsWith('-P'))) {
-					try {
-						const duration = Temporal.Duration.from(operand);
-						return duration.negated().toString();
-					} catch {
-						// Not a valid duration, fall through to numeric handling
-					}
-				}
-
-				// Numeric negation
-				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

@@ -1,66 +0,0 @@
-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';
-import { withRowContextGenerator } from '../context-helpers.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> {
-		yield* withRowContextGenerator(rctx, sourceRowDescriptor, sourceRowsIterable, async function* (sourceRow) {
-			// 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.update
-			yield flatRow;
-		});
-	}
-
-	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

@@ -1,66 +0,0 @@
-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, InstructionRun } 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 InstructionRun,
-		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

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