@quereus/quereus 0.6.4 → 0.6.5

package/dist/src/vtab/table.js.map

@@ -1 +1 @@
-{"version":3,"file":"table.js","sourceRoot":"","sources":["../../../src/vtab/table.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,MAAM,OAAgB,YAAY;IACjB,MAAM,CAAwB;IAC9B,EAAE,CAAW;IACb,SAAS,CAAS;IAClB,UAAU,CAAS;IAC5B,YAAY,CAAU;IACtB,WAAW,CAAe;IAEjC,YAAY,EAAY,EAAE,MAA6B,EAAE,UAAkB,EAAE,SAAiB;QAC7F,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACO,eAAe,CAAC,OAA2B;QACpD,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;IAC7B,CAAC;CA6HD"}
+{"version":3,"file":"table.js","sourceRoot":"","sources":["../../../src/vtab/table.ts"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,MAAM,OAAgB,YAAY;IACjB,MAAM,CAAwB;IAC9B,EAAE,CAAW;IACb,SAAS,CAAS;IAClB,UAAU,CAAS;IAC5B,YAAY,CAAU;IACtB,WAAW,CAAe;IAEjC;;;;OAIG;IACI,cAAc,CAAW;IAEhC,YAAY,EAAY,EAAE,MAA6B,EAAE,UAAkB,EAAE,SAAiB;QAC7F,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACO,eAAe,CAAC,OAA2B;QACpD,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;IAC7B,CAAC;CAqHD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quereus/quereus",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "type": "module",
   "description": "Federated SQL query processor",
   "publisher": "Got Choices Foundation",

package/src/common/logger.ts

@@ -19,5 +19,79 @@ const BASE_NAMESPACE = 'quereus';
  * @returns A debug instance.
  */
 export function createLogger(subNamespace: string): debug.Debugger {
-  return debug(`${BASE_NAMESPACE}:${subNamespace}`);
+	return debug(`${BASE_NAMESPACE}:${subNamespace}`);
+}
+
+/**
+ * Enable Quereus debug logging programmatically.
+ *
+ * This is particularly useful in environments like React Native where
+ * environment variables are not available at runtime.
+ *
+ * @param pattern - Debug pattern to enable (default: 'quereus:*')
+ *   Examples:
+ *   - 'quereus:*' - all Quereus logs
+ *   - 'quereus:vtab:*' - virtual table operations
+ *   - 'quereus:vtab:memory' - memory table operations only
+ *   - 'quereus:planner' - query planner logs
+ *   - 'quereus:runtime' - VDBE execution (very verbose)
+ *   - 'quereus:*,-quereus:runtime' - all except verbose runtime
+ * @param logFn - Optional custom log function. Defaults to console.log.
+ *   Useful in environments where console.debug may be filtered.
+ *
+ * @example
+ * ```typescript
+ * import { enableLogging } from '@quereus/quereus';
+ *
+ * // Enable all Quereus logs
+ * enableLogging();
+ *
+ * // Enable only memory table logs
+ * enableLogging('quereus:vtab:memory');
+ *
+ * // Enable all logs with custom output (e.g., React Native)
+ * enableLogging('quereus:*', console.log.bind(console));
+ * ```
+ */
+export function enableLogging(
+	pattern: string = `${BASE_NAMESPACE}:*`,
+	logFn?: (...args: unknown[]) => void
+): void {
+	if (logFn) {
+		debug.log = logFn;
+	}
+	debug.enable(pattern);
+}
+
+/**
+ * Disable all Quereus debug logging.
+ *
+ * @example
+ * ```typescript
+ * import { disableLogging } from '@quereus/quereus';
+ *
+ * disableLogging();
+ * ```
+ */
+export function disableLogging(): void {
+	debug.disable();
+}
+
+/**
+ * Check if logging is enabled for a specific namespace.
+ *
+ * @param namespace - The namespace to check (without 'quereus:' prefix)
+ * @returns true if logging is enabled for this namespace
+ *
+ * @example
+ * ```typescript
+ * import { isLoggingEnabled } from '@quereus/quereus';
+ *
+ * if (isLoggingEnabled('vtab:memory')) {
+ *   // Perform expensive debug operations
+ * }
+ * ```
+ */
+export function isLoggingEnabled(namespace: string): boolean {
+	return debug.enabled(`${BASE_NAMESPACE}:${namespace}`);
 }

package/src/func/builtins/datetime.ts

@@ -309,8 +309,9 @@ function processDateTimeArgs(args: ReadonlyArray<SqlValue>): Temporal.ZonedDateT
 // --- Function Implementations --- //
 
 // date(timestring, modifier, ...)
+// NOTE: Marked as non-deterministic because it accepts 'now' as a timestring
 export const dateFunc = createScalarFunction(
-	{ name: 'date', numArgs: -1, deterministic: true },
+	{ name: 'date', numArgs: -1, deterministic: false },
 	(...args: SqlValue[]): SqlValue => {
 		const finalDt = processDateTimeArgs(args);
 		if (!finalDt) return null;
@@ -319,8 +320,9 @@ export const dateFunc = createScalarFunction(
 );
 
 // time(timestring, modifier, ...)
+// NOTE: Marked as non-deterministic because it accepts 'now' as a timestring
 export const timeFunc = createScalarFunction(
-	{ name: 'time', numArgs: -1, deterministic: true },
+	{ name: 'time', numArgs: -1, deterministic: false },
 	(...args: SqlValue[]): SqlValue => {
 		const finalDt = processDateTimeArgs(args);
 		if (!finalDt) return null;
@@ -329,8 +331,9 @@ export const timeFunc = createScalarFunction(
 );
 
 // datetime(timestring, modifier, ...)
+// NOTE: Marked as non-deterministic because it accepts 'now' as a timestring
 export const datetimeFunc = createScalarFunction(
-	{ name: 'datetime', numArgs: -1, deterministic: true },
+	{ name: 'datetime', numArgs: -1, deterministic: false },
 	(...args: SqlValue[]): SqlValue => {
 		const finalDt = processDateTimeArgs(args);
 		if (!finalDt) return null;
@@ -341,8 +344,9 @@ export const datetimeFunc = createScalarFunction(
 );
 
 // julianday(timestring, modifier, ...)
+// NOTE: Marked as non-deterministic because it accepts 'now' as a timestring
 export const juliandayFunc = createScalarFunction(
-	{ name: 'julianday', numArgs: -1, deterministic: true },
+	{ name: 'julianday', numArgs: -1, deterministic: false },
 	(...args: SqlValue[]): SqlValue => {
 		const finalDt = processDateTimeArgs(args);
 		if (!finalDt) return null;
@@ -352,8 +356,9 @@ export const juliandayFunc = createScalarFunction(
 );
 
 // strftime(format, timestring, modifier, ...)
+// NOTE: Marked as non-deterministic because it accepts 'now' as a timestring
 export const strftimeFunc = createScalarFunction(
-	{ name: 'strftime', numArgs: -1, deterministic: true },
+	{ name: 'strftime', numArgs: -1, deterministic: false },
 	(format: SqlValue, ...timeArgs: SqlValue[]): SqlValue => {
 		if (typeof format !== 'string') return null;
 		const finalDt = processDateTimeArgs(timeArgs);

package/src/index.ts

@@ -138,3 +138,6 @@ export type {
 // Debug and development utilities
 export { serializePlanTree, formatPlanTree, formatPlanSummary, serializePlanTreeWithOptions } from './planner/debug.js';
 export type { PlanDisplayOptions } from './planner/debug.js';
+
+// Logging control (for environments like React Native where env vars aren't available)
+export { enableLogging, disableLogging, isLoggingEnabled } from './common/logger.js';

package/src/planner/building/constraint-builder.ts

@@ -9,6 +9,7 @@ import { PlanNodeType } from '../nodes/plan-node-type.js';
 import { ColumnReferenceNode } from '../nodes/reference.js';
 import type { ScalarPlanNode } from '../nodes/plan-node.js';
 import * as AST from '../../parser/ast.js';
+import { validateDeterministicConstraint } from '../validation/determinism-validator.js';
 
 /**
  * Determines if a constraint should be checked for the given operation
@@ -137,6 +138,10 @@ export function buildConstraintChecks(
         constraint.expr
       ) as ScalarPlanNode;
 
+      // Validate that the constraint expression is deterministic
+      const constraintName = constraint.name ?? `_check_${tableSchema.name}`;
+      validateDeterministicConstraint(expression, constraintName, tableSchema.name);
+
       // Heuristic: auto-defer if the expression contains a subquery
       // or references a different relation via attribute bindings (NEW/OLD already localized).
       const needsDeferred = containsSubquery(expression);

package/src/planner/building/delete.ts

@@ -148,7 +148,11 @@ export function buildDeleteStmt(
     deleteCtx.scope,
     deleteNode,
     tableReference,
-    'delete'
+    'delete',
+    undefined, // onConflict not used for DELETE
+    mutationContextValues.size > 0 ? mutationContextValues : undefined,
+    contextAttributes.length > 0 ? contextAttributes : undefined,
+    contextDescriptor
   );
 
   const resultNode: RelationalPlanNode = dmlExecutorNode;

package/src/planner/building/insert.ts

@@ -22,6 +22,7 @@ import { ProjectNode, type Projection } from '../nodes/project-node.js';
 import { buildOldNewRowDescriptors } from '../../util/row-descriptor.js';
 import { DmlExecutorNode } from '../nodes/dml-executor-node.js';
 import { buildConstraintChecks } from './constraint-builder.js';
+import { validateDeterministicDefault } from '../validation/determinism-validator.js';
 
 /**
  * Creates a uniform row expansion projection that maps any relational source
@@ -103,6 +104,9 @@ function createRowExpansionProjection(
 				if (typeof tableColumn.defaultValue === 'object' && tableColumn.defaultValue !== null && 'type' in tableColumn.defaultValue) {
 					// It's an AST.Expression - build it into a plan node with context scope
 					defaultNode = buildExpression(defaultCtx, tableColumn.defaultValue as AST.Expression) as ScalarPlanNode;
+
+					// Validate that the default expression is deterministic
+					validateDeterministicDefault(defaultNode, tableColumn.name, tableSchema.name);
 				} else {
 					// Literal default value
 					defaultNode = buildExpression(defaultCtx, { type: 'literal', value: tableColumn.defaultValue }) as ScalarPlanNode;
@@ -358,7 +362,10 @@ export function buildInsertStmt(
 		constraintCheckNode,
 		tableReference,
 		'insert',
-		stmt.onConflict
+		stmt.onConflict,
+		mutationContextValues.size > 0 ? mutationContextValues : undefined,
+		contextAttributes.length > 0 ? contextAttributes : undefined,
+		contextDescriptor
 	);
 
 	const resultNode: RelationalPlanNode = dmlExecutorNode;

package/src/planner/building/update.ts

@@ -270,7 +270,11 @@ export function buildUpdateStmt(
       updateCtx.scope,
       constraintCheckNode,
       tableReference,
-      'update'
+      'update',
+      undefined, // onConflict not used for UPDATE
+      mutationContextValues.size > 0 ? mutationContextValues : undefined,
+      contextAttributes.length > 0 ? contextAttributes : undefined,
+      contextDescriptor
     );
 
     // Return the RETURNING results from the executed update
@@ -312,7 +316,11 @@ export function buildUpdateStmt(
     updateCtx.scope,
     constraintCheckNode,
     tableReference,
-    'update'
+    'update',
+    undefined, // onConflict not used for UPDATE
+    mutationContextValues.size > 0 ? mutationContextValues : undefined,
+    contextAttributes.length > 0 ? contextAttributes : undefined,
+    contextDescriptor
   );
 
   return new SinkNode(updateCtx.scope, updateExecutorNode, 'update');

package/src/planner/nodes/dml-executor-node.ts

@@ -1,5 +1,5 @@
 import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type RelationalPlanNode, type Attribute, type PhysicalProperties, isRelationalNode } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type Attribute, type PhysicalProperties, type ScalarPlanNode, type RowDescriptor, isRelationalNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { TableReferenceNode } from './reference.js';
 import type { RelationType } from '../../common/datatype.js';
@@ -20,6 +20,9 @@ export class DmlExecutorNode extends PlanNode implements RelationalPlanNode {
     public readonly table: TableReferenceNode,
     public readonly operation: RowOp,
     public readonly onConflict?: ConflictResolution, // Used for INSERT operations
+    public readonly mutationContextValues?: Map<string, ScalarPlanNode>, // Mutation context value expressions
+    public readonly contextAttributes?: Attribute[], // Mutation context attributes
+    public readonly contextDescriptor?: RowDescriptor, // Mutation context row descriptor
   ) {
     super(scope);
   }
@@ -63,7 +66,10 @@ export class DmlExecutorNode extends PlanNode implements RelationalPlanNode {
       newSource as RelationalPlanNode,
       this.table,
       this.operation,
-      this.onConflict
+      this.onConflict,
+      this.mutationContextValues,
+      this.contextAttributes,
+      this.contextDescriptor
     );
   }
 

package/src/planner/validation/determinism-validator.ts

@@ -0,0 +1,76 @@
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import type { ScalarPlanNode } from '../nodes/plan-node.js';
+import { createLogger } from '../../common/logger.js';
+
+const log = createLogger('planner:validation:determinism');
+
+/**
+ * Validates that an expression is deterministic (suitable for constraints and defaults).
+ * Non-deterministic expressions must be passed via mutation context instead.
+ *
+ * @param expr The expression plan node to validate
+ * @param context Description of where the expression is used (e.g., "DEFAULT for column 'created_at'")
+ * @throws QuereusError if the expression is non-deterministic
+ */
+export function validateDeterministicExpression(
+	expr: ScalarPlanNode,
+	context: string
+): void {
+	log('Validating determinism for: %s', context);
+
+	// Check physical properties - this will recursively check all child nodes
+	const physical = expr.physical;
+
+	if (physical.deterministic === false) {
+		log('Non-deterministic expression detected in %s: %s', context, expr.toString());
+
+		throw new QuereusError(
+			`Non-deterministic expression not allowed in ${context}. ` +
+			`Expression: ${expr.toString()}. ` +
+			`Use mutation context to pass non-deterministic values (e.g., WITH CONTEXT (timestamp = datetime('now'))).`,
+			StatusCode.ERROR
+		);
+	}
+
+	log('Expression is deterministic: %s', expr.toString());
+}
+
+/**
+ * Validates that a CHECK constraint expression is deterministic.
+ *
+ * @param expr The constraint expression plan node
+ * @param constraintName The name of the constraint (for error messages)
+ * @param tableName The name of the table (for error messages)
+ * @throws QuereusError if the expression is non-deterministic
+ */
+export function validateDeterministicConstraint(
+	expr: ScalarPlanNode,
+	constraintName: string,
+	tableName: string
+): void {
+	validateDeterministicExpression(
+		expr,
+		`CHECK constraint '${constraintName}' on table '${tableName}'`
+	);
+}
+
+/**
+ * Validates that a DEFAULT expression is deterministic.
+ *
+ * @param expr The default value expression plan node
+ * @param columnName The name of the column (for error messages)
+ * @param tableName The name of the table (for error messages)
+ * @throws QuereusError if the expression is non-deterministic
+ */
+export function validateDeterministicDefault(
+	expr: ScalarPlanNode,
+	columnName: string,
+	tableName: string
+): void {
+	validateDeterministicExpression(
+		expr,
+		`DEFAULT for column '${columnName}' in table '${tableName}'`
+	);
+}
+

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

@@ -31,6 +31,9 @@ export function emitAddConstraint(plan: AddConstraintNode, _ctx: EmissionContext
 		}
 
 		// Create the constraint schema object
+		// Note: We don't validate determinism here because constraints may reference NEW/OLD
+		// which require special scoping. Determinism is validated at INSERT/UPDATE plan time
+		// in constraint-builder.ts when the constraint is actually checked.
 		const constraintSchema: RowConstraintSchema = {
 			name: constraint.name || `check_${tableSchema.checkConstraints.length}`,
 			expr: constraint.expr,

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

@@ -1,12 +1,14 @@
 import type { DmlExecutorNode } from '../../planner/nodes/dml-executor-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import { emitPlanNode } from '../emitters.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;
@@ -14,15 +16,55 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 	// 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>): AsyncIterable<Row> {
+	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);
-				await vtab.update!('insert', newRow, undefined, plan.onConflict ?? ConflictResolution.ABORT);
+
+				// 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);
@@ -34,8 +76,19 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 	}
 
 	// UPDATE ----------------------------------------------------
-	async function* runUpdate(ctx: RuntimeContext, rows: AsyncIterable<Row>): AsyncIterable<Row> {
+	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);
@@ -48,7 +101,23 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 					}
 					return oldRow[pkColIdx];
 				});
-				await vtab.update!('update', newRow, keyValues, ConflictResolution.ABORT);
+
+				// 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);
@@ -60,8 +129,19 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 	}
 
 	// DELETE ----------------------------------------------------
-	async function* runDelete(ctx: RuntimeContext, rows: AsyncIterable<Row>): AsyncIterable<Row> {
+	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);
@@ -72,7 +152,23 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 					}
 					return oldRow[pkColIdx];
 				});
-				await vtab.update!('delete', undefined, keyValues, ConflictResolution.ABORT);
+
+				// 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;
@@ -95,7 +191,7 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 	const sourceInstruction = emitPlanNode(plan.source, ctx);
 
 	return {
-		params: [sourceInstruction],
+		params: [sourceInstruction, ...contextEvaluatorInstructions],
 		run,
 		note: `execute${plan.operation}(${plan.table.tableSchema.name})`
 	};

package/src/runtime/types.ts

@@ -7,6 +7,9 @@ import type { EmissionContext } from "./emission-context.js";
 import type { VirtualTableConnection } from "../vtab/connection.js";
 import type { PlanNode } from '../planner/nodes/plan-node.js';
 
+// Re-export types from common/types.js for convenience
+export type { OutputValue };
+
 export type RuntimeContext = {
 	db: Database;
 	stmt: Statement | undefined; // Undefined for transient exec statements

package/src/schema/manager.ts

@@ -13,6 +13,13 @@ import type { ViewSchema } from './view.js';
 import { createLogger } from '../common/logger.js';
 import type * as AST from '../parser/ast.js';
 import { SchemaChangeNotifier } from './change-events.js';
+import { validateDeterministicDefault, validateDeterministicConstraint } from '../planner/validation/determinism-validator.js';
+import { buildExpression } from '../planner/building/expression.js';
+import type { PlanningContext } from '../planner/planning-context.js';
+import { BuildTimeDependencyTracker } from '../planner/planning-context.js';
+import { GlobalScope } from '../planner/scopes/global.js';
+import { ParameterScope } from '../planner/scopes/param.js';
+import type { ScalarPlanNode } from '../planner/nodes/plan-node.js';
 
 const log = createLogger('schema:manager');
 const warnLog = log.extend('warn');
@@ -651,6 +658,44 @@ export class SchemaManager {
 			? stmt.contextDefinitions.map(varDef => mutationContextVarToSchema(varDef, defaultNotNull))
 			: undefined;
 
+		// Validate that default expressions are deterministic
+		// We need to build them temporarily to check their physical properties
+		// Note: We only validate defaults here, not CHECK constraints, because CHECK constraints
+		// may reference table columns which don't exist yet at CREATE TABLE time.
+		// CHECK constraints are validated at INSERT/UPDATE time in constraint-builder.ts
+		const globalScope = new GlobalScope(this.db.schemaManager);
+		const parameterScope = new ParameterScope(globalScope);
+		const planningCtx: PlanningContext = {
+			db: this.db,
+			schemaManager: this.db.schemaManager,
+			parameters: {},
+			scope: parameterScope,
+			cteNodes: new Map(),
+			schemaDependencies: new BuildTimeDependencyTracker(),
+			schemaCache: new Map(),
+			cteReferenceCache: new Map(),
+			outputScopes: new Map()
+		};
+
+		// Validate default expressions
+		// Note: We can only validate defaults that don't reference table columns,
+		// since the table doesn't exist yet. Defaults that reference columns will be
+		// validated at INSERT time in insert.ts
+		for (const col of finalColumnSchemas) {
+			if (col.defaultValue && typeof col.defaultValue === 'object' && col.defaultValue !== null && 'type' in col.defaultValue) {
+				try {
+					// It's an AST expression - try to build and validate it
+					const defaultExpr = buildExpression(planningCtx, col.defaultValue as AST.Expression) as ScalarPlanNode;
+					validateDeterministicDefault(defaultExpr, col.name, tableName);
+				} catch (e) {
+					// If we can't build the expression (e.g., it references columns that don't exist yet),
+					// skip validation here. It will be validated at INSERT time.
+					log('Skipping determinism validation for default on column %s.%s at CREATE TABLE time (will validate at INSERT time): %s',
+						tableName, col.name, (e as Error).message);
+				}
+			}
+		}
+
 		const baseTableSchema: TableSchema = {
 			name: tableName,
 			schemaName: targetSchemaName,

package/src/util/ast-stringify.ts

@@ -497,6 +497,13 @@ export function insertToString(stmt: AST.InsertStmt): string {
 		parts.push(`(${stmt.columns.map(quoteIdentifierIfNeeded).join(', ')})`);
 	}
 
+	if (stmt.contextValues && stmt.contextValues.length > 0) {
+		const contextAssignments = stmt.contextValues.map(assign =>
+			`${quoteIdentifierIfNeeded(assign.name)} = ${expressionToString(assign.value)}`
+		);
+		parts.push('with context', contextAssignments.join(', '));
+	}
+
 	if (stmt.values) {
 		const valueRows = stmt.values.map(row =>
 			`(${row.map(expressionToString).join(', ')})`
@@ -533,7 +540,16 @@ export function updateToString(stmt: AST.UpdateStmt): string {
 		parts.push(withClauseToString(stmt.withClause));
 	}
 
-	parts.push('update', expressionToString(stmt.table), 'set');
+	parts.push('update', expressionToString(stmt.table));
+
+	if (stmt.contextValues && stmt.contextValues.length > 0) {
+		const contextAssignments = stmt.contextValues.map(assign =>
+			`${quoteIdentifierIfNeeded(assign.name)} = ${expressionToString(assign.value)}`
+		);
+		parts.push('with context', contextAssignments.join(', '));
+	}
+
+	parts.push('set');
 
 	const assignments = stmt.assignments.map(assign =>
 		`${quoteIdentifierIfNeeded(assign.column)} = ${expressionToString(assign.value)}`
@@ -573,6 +589,13 @@ export function deleteToString(stmt: AST.DeleteStmt): string {
 
 	parts.push('delete from', expressionToString(stmt.table));
 
+	if (stmt.contextValues && stmt.contextValues.length > 0) {
+		const contextAssignments = stmt.contextValues.map(assign =>
+			`${quoteIdentifierIfNeeded(assign.name)} = ${expressionToString(assign.value)}`
+		);
+		parts.push('with context', contextAssignments.join(', '));
+	}
+
 	if (stmt.where) {
 		parts.push('where', expressionToString(stmt.where));
 	}