@quereus/quereus 0.2.0 → 0.4.0

package/dist/src/core/database.js

@@ -12,15 +12,23 @@ import { Parser, ParseError } from '../parser/parser.js';
 import { buildBlock } from '../planner/building/block.js';
 import { emitPlanNode } from '../runtime/emitters.js';
 import { Scheduler } from '../runtime/scheduler.js';
+import { BlockNode } from '../planner/nodes/block.js';
 import { BuildTimeDependencyTracker } from '../planner/planning-context.js';
 import { ParameterScope } from '../planner/scopes/param.js';
 import { GlobalScope } from '../planner/scopes/global.js';
+import { FilterNode } from '../planner/nodes/filter.js';
+import { BinaryOpNode } from '../planner/nodes/scalar.js';
+import { ParameterReferenceNode, ColumnReferenceNode, TableReferenceNode } from '../planner/nodes/reference.js';
 import { registerEmitters } from '../runtime/register.js';
 import { serializePlanTree, formatPlanTree } from '../planner/debug.js';
 import { EmissionContext } from '../runtime/emission-context.js';
 import { Optimizer, DEFAULT_TUNING } from '../planner/optimizer.js';
 import { registerBuiltinWindowFunctions } from '../func/builtins/builtin-window-functions.js';
 import { DatabaseOptionsManager } from './database-options.js';
+import { isAsyncIterable } from '../runtime/utils.js';
+import { DeclaredSchemaManager } from '../schema/declared-schema-manager.js';
+import { analyzeRowSpecific } from '../planner/analysis/constraint-extractor.js';
+import { DeferredConstraintQueue } from '../runtime/deferred-constraint-queue.js';
 const log = createLogger('core:database');
 const warnLog = log.extend('warn');
 const errorLog = log.extend('error');
@@ -31,6 +39,7 @@ const debugLog = log.extend('debug');
  */
 export class Database {
     schemaManager;
+    declaredSchemaManager;
     isOpen = true;
     statements = new Set();
     isAutocommit = true; // Manages transaction state
@@ -40,8 +49,15 @@ export class Database {
     optimizer;
     options;
     instructionTracer;
+    /** Per-transaction change tracking: base table name → serialized PK tuples */
+    changeLog = new Map();
+    /** Savepoint layers for change tracking */
+    changeLogLayers = [];
+    /** Deferred constraint evaluation queue */
+    deferredConstraints = new DeferredConstraintQueue(this);
     constructor() {
         this.schemaManager = new SchemaManager(this);
+        this.declaredSchemaManager = new DeclaredSchemaManager();
         this.options = new DatabaseOptionsManager();
         log("Database instance created.");
         // Register built-in functions
@@ -85,9 +101,8 @@ export class Database {
                         validatePlan: event.newValue
                     }
                 };
-                // Recreate optimizer with new tuning
-                this.optimizer = new Optimizer(newTuning);
-                log('Optimizer recreated with validate_plan = %s', event.newValue);
+                this.updateOptimizerTuning(newTuning);
+                log('Optimizer tuning updated with validate_plan = %s', event.newValue);
             }
         });
         this.options.registerOption('default_vtab_module', {
@@ -182,7 +197,7 @@ export class Database {
         }
         if (batch.length === 0)
             return;
-        const needsImplicitTransaction = batch.length > 1
+        const needsImplicitTransaction = batch.length >= 1
             && this.isAutocommit
             // has explicit transaction
             && !batch.some(ast => ast.type === 'begin' || ast.type === 'commit' || ast.type === 'rollback' || ast.type === 'savepoint' || ast.type === 'release');
@@ -204,7 +219,7 @@ export class Database {
                     const scheduler = new Scheduler(rootInstruction);
                     const runtimeCtx = {
                         db: this,
-                        stmt: null, // No persistent Statement object for transient exec statements
+                        stmt: undefined,
                         params: params ?? {},
                         context: new Map(),
                         tableContexts: new Map(),
@@ -215,7 +230,8 @@ export class Database {
                     // Nothing to do with the result, this is executed for side effects only
                 }
                 catch (err) {
-                    executionError = err instanceof QuereusError ? err : new QuereusError(err.message, StatusCode.ERROR, err);
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    executionError = error instanceof QuereusError ? error : new QuereusError(error.message, StatusCode.ERROR, error);
                     break; // Stop processing further statements on error
                 }
                 // No explicit finalize for transient plan/scheduler used in exec loop
@@ -223,16 +239,11 @@ export class Database {
         }
         finally {
             if (needsImplicitTransaction) {
-                try {
-                    if (executionError) {
-                        await this.rollbackImplicitTransaction();
-                    }
-                    else {
-                        await this.commitImplicitTransaction();
-                    }
+                if (executionError) {
+                    await this.rollbackImplicitTransaction();
                 }
-                catch (txError) {
-                    errorLog(`Error during implicit transaction ${executionError ? 'rollback' : 'commit'}: %O`, txError);
+                else {
+                    await this.commitImplicitTransaction();
                 }
             }
         }
@@ -359,7 +370,7 @@ export class Database {
      * Registers a user-defined aggregate function.
      *
      * @param name The name of the SQL function.
-     * @param options Configuration: { numArgs: number, flags?: number, initialState?: any }.
+     * @param options Configuration: { numArgs: number, flags?: number, initialState?: unknown }.
      * @param stepFunc The function called for each row (accumulator, ...args) => newAccumulator.
      * @param finalFunc The function called at the end (accumulator) => finalResult.
      */
@@ -438,6 +449,10 @@ export class Database {
         this.checkOpen();
         return this.options.getOption(option);
     }
+    /** Update optimizer tuning in place */
+    updateOptimizerTuning(tuning) {
+        this.optimizer.updateTuning(tuning);
+    }
     /**
      * Registers a user-defined collation sequence.
      * @param name The name of the collation sequence (case-insensitive).
@@ -480,6 +495,125 @@ export class Database {
     _getCollation(name) {
         return getCollation(name);
     }
+    /** Serialize a composite primary key tuple for set storage */
+    serializeKeyTuple(values) {
+        // JSON serialization is sufficient because SqlValue is JSON-safe in this engine
+        return JSON.stringify(values);
+    }
+    /** Add a key tuple to the current change log for a base table */
+    addChange(baseTable, keyTuple) {
+        const target = this.changeLogLayers.length > 0
+            ? this.changeLogLayers[this.changeLogLayers.length - 1]
+            : this.changeLog;
+        const key = baseTable.toLowerCase();
+        if (!target.has(key))
+            target.set(key, new Set());
+        target.get(key).add(this.serializeKeyTuple(keyTuple));
+    }
+    _queueDeferredConstraintRow(baseTable, constraintName, row, descriptor, evaluator, connectionId, contextRow, contextDescriptor) {
+        this.deferredConstraints.enqueue(baseTable, constraintName, row, descriptor, evaluator, connectionId, contextRow, contextDescriptor);
+    }
+    /** @internal Flag to prevent new connections from starting transactions during constraint evaluation */
+    evaluatingDeferredConstraints = false;
+    /** @internal Flag indicating we're in a coordinated multi-connection commit */
+    inCoordinatedCommit = false;
+    async runDeferredRowConstraints() {
+        this.evaluatingDeferredConstraints = true;
+        try {
+            await this.deferredConstraints.runDeferredRows();
+        }
+        finally {
+            this.evaluatingDeferredConstraints = false;
+        }
+    }
+    /** @internal Check if we should skip auto-beginning transactions on newly registered connections */
+    _isEvaluatingDeferredConstraints() {
+        return this.evaluatingDeferredConstraints;
+    }
+    /** @internal Mark start of coordinated multi-connection commit */
+    _beginCoordinatedCommit() {
+        this.inCoordinatedCommit = true;
+    }
+    /** @internal Mark end of coordinated multi-connection commit */
+    _endCoordinatedCommit() {
+        this.inCoordinatedCommit = false;
+    }
+    /** @internal Check if we're in a coordinated commit (allows sibling layer validation) */
+    _inCoordinatedCommit() {
+        return this.inCoordinatedCommit;
+    }
+    /** Public API used by DML emitters to record changes */
+    _recordInsert(baseTable, newKey) {
+        this.addChange(baseTable, newKey);
+    }
+    _recordDelete(baseTable, oldKey) {
+        this.addChange(baseTable, oldKey);
+    }
+    _recordUpdate(baseTable, oldKey, newKey) {
+        this.addChange(baseTable, oldKey);
+        // If the PK changed, also record the new key
+        if (this.serializeKeyTuple(oldKey) !== this.serializeKeyTuple(newKey)) {
+            this.addChange(baseTable, newKey);
+        }
+    }
+    /** Savepoint change tracking */
+    _beginSavepointLayer() {
+        this.changeLogLayers.push(new Map());
+        this.deferredConstraints.beginLayer();
+    }
+    _rollbackSavepointLayer() {
+        // Discard the top layer
+        this.changeLogLayers.pop();
+        this.deferredConstraints.rollbackLayer();
+    }
+    _releaseSavepointLayer() {
+        // Merge the top layer into previous or main log
+        const top = this.changeLogLayers.pop();
+        if (!top)
+            return;
+        const target = this.changeLogLayers.length > 0 ? this.changeLogLayers[this.changeLogLayers.length - 1] : this.changeLog;
+        for (const [table, set] of top) {
+            if (!target.has(table))
+                target.set(table, new Set());
+            const tgt = target.get(table);
+            for (const k of set)
+                tgt.add(k);
+        }
+        this.deferredConstraints.releaseLayer();
+    }
+    getChangedBaseTables() {
+        const result = new Set();
+        const collect = (m) => {
+            for (const [t, s] of m) {
+                if (s.size > 0)
+                    result.add(t);
+            }
+        };
+        collect(this.changeLog);
+        for (const layer of this.changeLogLayers)
+            collect(layer);
+        return result;
+    }
+    _clearChangeLog() {
+        this.changeLog.clear();
+        this.changeLogLayers = [];
+        this.deferredConstraints.clear();
+    }
+    /**
+     * Marks that an explicit SQL BEGIN has started a transaction.
+     * Ensures subsequently registered connections also begin a transaction.
+     */
+    markExplicitTransactionStart() {
+        this.inTransaction = true;
+        this.isAutocommit = false;
+    }
+    /**
+     * Marks that an explicit SQL COMMIT/ROLLBACK has ended the transaction.
+     */
+    markExplicitTransactionEnd() {
+        this.inTransaction = false;
+        this.isAutocommit = true;
+    }
     /**
      * Prepares, binds parameters, executes, and yields result rows for a query.
      * This is a high-level convenience method for iterating over query results.
@@ -537,9 +671,10 @@ export class Database {
             try {
                 ast = parser.parse(originalSqlString);
             }
-            catch (e) {
-                errorLog("Failed to parse SQL for query plan: %O", e);
-                throw new QuereusError(`Parse error: ${e.message}`, StatusCode.ERROR, e);
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                errorLog("Failed to parse SQL for query plan: %O", error);
+                throw error;
             }
         }
         else {
@@ -616,7 +751,8 @@ export class Database {
             cteNodes: new Map(),
             schemaDependencies: new BuildTimeDependencyTracker(),
             schemaCache: new Map(),
-            cteReferenceCache: new Map()
+            cteReferenceCache: new Map(),
+            outputScopes: new Map()
         };
         return buildBlock(ctx, statements);
     }
@@ -628,8 +764,9 @@ export class Database {
         this.activeConnections.set(connection.connectionId, connection);
         debugLog(`Registered connection ${connection.connectionId} for table ${connection.tableName}`);
         // If we're already in a transaction (implicit or explicit),
-        // start a transaction on this new connection
-        if (this.inTransaction) {
+        // start a transaction on this new connection UNLESS we're evaluating deferred constraints
+        // (during which subqueries should read committed state without creating new transaction layers)
+        if (this.inTransaction && !this.evaluatingDeferredConstraints) {
             try {
                 await connection.begin();
                 debugLog(`Started transaction on newly registered connection ${connection.connectionId}`);
@@ -639,6 +776,9 @@ export class Database {
                 // Don't throw here - just log the error to avoid breaking connection registration
             }
         }
+        else if (this.evaluatingDeferredConstraints) {
+            debugLog(`Skipped transaction begin on connection ${connection.connectionId} (evaluating deferred constraints)`);
+        }
     }
     /**
      * @internal Unregisters an active VirtualTable connection.
@@ -670,8 +810,13 @@ export class Database {
      * @returns Array of connections for the table
      */
     getConnectionsForTable(tableName) {
+        const normalized = tableName.toLowerCase();
+        const simpleName = normalized.includes('.') ? normalized.substring(normalized.lastIndexOf('.') + 1) : normalized;
         return Array.from(this.activeConnections.values())
-            .filter(conn => conn.tableName === tableName);
+            .filter(conn => {
+            const connName = conn.tableName.toLowerCase();
+            return connName === normalized || connName === simpleName;
+        });
     }
     /**
      * @internal Gets all active connections.
@@ -702,21 +847,6 @@ export class Database {
         if (!this.isOpen)
             throw new MisuseError("Database is closed");
     }
-    /** Helper to execute simple commands (BEGIN, COMMIT, ROLLBACK) internally
-     * This method is for commands that don't produce rows and don't need complex parameter handling.
-    */
-    async execSimple(sqlCommand) {
-        let stmt = null;
-        try {
-            stmt = this.prepare(sqlCommand);
-            await stmt.run();
-        }
-        finally {
-            if (stmt) {
-                await stmt.finalize();
-            }
-        }
-    }
     /**
      * Begin an implicit transaction and coordinate with virtual table connections
      */
@@ -743,24 +873,318 @@ export class Database {
      */
     async commitImplicitTransaction() {
         debugLog("Database: Committing implicit transaction.");
-        // Commit all active connections first
-        const connections = this.getAllConnections();
-        const commitPromises = connections.map(async (connection) => {
+        try {
+            const connectionsToCommit = this.getAllConnections();
+            // Evaluate global assertions and deferred row constraints BEFORE committing connections. If violated, rollback and abort.
+            await this.runGlobalAssertions();
+            await this.runDeferredRowConstraints();
+            // Mark coordinated commit to relax layer validation for sibling layers
+            this._beginCoordinatedCommit();
             try {
-                await connection.commit();
+                // Commit only the original connections (not any opened during constraint evaluation)
+                // Commit sequentially to avoid race conditions with layer promotion
+                for (const connection of connectionsToCommit) {
+                    try {
+                        await connection.commit();
+                    }
+                    catch (error) {
+                        errorLog(`Error committing transaction on connection ${connection.connectionId}: %O`, error);
+                        throw error;
+                    }
+                }
             }
-            catch (error) {
-                errorLog(`Error committing transaction on connection ${connection.connectionId}: %O`, error);
-                throw error;
+            finally {
+                this._endCoordinatedCommit();
             }
-        });
-        await Promise.all(commitPromises);
-        // Reset database state
-        this.inTransaction = false;
-        this.isAutocommit = true;
-        this.inImplicitTransaction = false;
-        // DON'T disconnect connections after successful commit - leave them for subsequent queries
-        // The data in committed connections should be visible to future operations
+        }
+        catch (e) {
+            // On pre-commit assertion failure (or commit error), rollback all connections
+            const conns = this.getAllConnections();
+            await Promise.allSettled(conns.map(c => c.rollback()));
+            throw e;
+        }
+        finally {
+            this.inTransaction = false;
+            this.isAutocommit = true;
+            this.inImplicitTransaction = false;
+            this._clearChangeLog();
+        }
+    }
+    async runGlobalAssertions() {
+        const assertions = this.schemaManager.getAllAssertions();
+        if (assertions.length === 0)
+            return;
+        // Only evaluate assertions impacted by changed base tables
+        const changedBases = this.getChangedBaseTables();
+        if (changedBases.size === 0)
+            return;
+        for (const assertion of assertions) {
+            const planSql = assertion.violationSql;
+            const parser = new Parser();
+            let ast;
+            try {
+                ast = parser.parse(planSql);
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                throw new QuereusError(`Failed to parse deferred assertion '${assertion.name}': ${error.message}`, StatusCode.INTERNAL, error);
+            }
+            const plan = this._buildPlan([ast]);
+            const analyzed = this.optimizer.optimizeForAnalysis(plan, this);
+            // Collect base tables and relationKeys in this plan
+            const relationKeyToBase = new Map();
+            const baseTablesInPlan = new Set();
+            this.collectTables(analyzed, relationKeyToBase, baseTablesInPlan);
+            // Determine impact: if assertion has no dependencies, treat as global and always impacted.
+            const hasDeps = baseTablesInPlan.size > 0;
+            let impacted = !hasDeps;
+            if (hasDeps) {
+                for (const b of baseTablesInPlan) {
+                    if (changedBases.has(b)) {
+                        impacted = true;
+                        break;
+                    }
+                }
+            }
+            if (!impacted)
+                continue;
+            // Classify instances as row/global
+            const classifications = analyzeRowSpecific(analyzed);
+            // If any changed base appears as a global instance, run full violation query once
+            let requiresGlobal = false;
+            for (const [relKey, klass] of classifications) {
+                if (klass === 'global') {
+                    const base = relationKeyToBase.get(relKey);
+                    if (base && changedBases.has(base)) {
+                        requiresGlobal = true;
+                        break;
+                    }
+                }
+            }
+            if (requiresGlobal) {
+                await this.executeViolationOnce(assertion.name, assertion.violationSql);
+                continue;
+            }
+            // Collect row-specific references that correspond to changed bases
+            const rowSpecificChanged = [];
+            for (const [relKey, klass] of classifications) {
+                if (klass !== 'row')
+                    continue;
+                const base = relationKeyToBase.get(relKey);
+                if (base && changedBases.has(base))
+                    rowSpecificChanged.push({ relKey, base });
+            }
+            if (rowSpecificChanged.length === 0) {
+                // No row-specific changed refs (or no refs at all) → run once globally.
+                await this.executeViolationOnce(assertion.name, assertion.violationSql);
+                continue;
+            }
+            // Execute parameterized variants per changed key for each row-specific reference; early-exit on violation
+            for (const { relKey, base } of rowSpecificChanged) {
+                await this.executeViolationPerChangedKeys(assertion.name, assertion.violationSql, analyzed, relKey, base);
+            }
+        }
+    }
+    async executeViolationOnce(assertionName, sql) {
+        const stmt = await this.prepare(sql);
+        try {
+            for await (const _ of stmt.all()) {
+                throw new QuereusError(`Integrity assertion failed: ${assertionName}`, StatusCode.CONSTRAINT);
+            }
+        }
+        finally {
+            await stmt.finalize();
+        }
+    }
+    async executeViolationOnceFromPlan(assertionName, plan) {
+        const optimizedPlan = this.optimizer.optimize(plan, this);
+        const emissionContext = new EmissionContext(this);
+        const rootInstruction = emitPlanNode(optimizedPlan, emissionContext);
+        const scheduler = new Scheduler(rootInstruction);
+        const runtimeCtx = {
+            db: this,
+            stmt: undefined,
+            params: {},
+            context: new Map(),
+            tableContexts: new Map(),
+            tracer: this.instructionTracer,
+            enableMetrics: this.options.getBooleanOption('runtime_stats'),
+        };
+        const result = await scheduler.run(runtimeCtx);
+        if (isAsyncIterable(result)) {
+            for await (const _ of result) {
+                throw new QuereusError(`CHECK constraint failed: ${assertionName}`, StatusCode.CONSTRAINT);
+            }
+        }
+    }
+    async executeViolationPerChangedKeysFromPlan(assertionName, analyzed, targetRelationKey, base) {
+        const changedKeyTuples = this.getChangedKeyTuples(base);
+        if (changedKeyTuples.length === 0)
+            return;
+        // Find PK indices for the base table
+        const [schemaName, tableName] = base.split('.');
+        const table = this._findTable(tableName, schemaName);
+        if (!table) {
+            throw new QuereusError(`Constraint references unknown table ${base}`, StatusCode.INTERNAL);
+        }
+        const pkIndices = table.primaryKeyDefinition.map(def => def.index);
+        // Prepare a rewritten plan with an injected Filter on the target relationKey
+        const rewritten = this.injectPkFilter(analyzed, targetRelationKey, base, pkIndices);
+        const optimizedPlan = this.optimizer.optimize(rewritten, this);
+        // Emit and execute for each changed PK tuple; stop on first violation row.
+        const emissionContext = new EmissionContext(this);
+        const rootInstruction = emitPlanNode(optimizedPlan, emissionContext);
+        const scheduler = new Scheduler(rootInstruction);
+        for (const tuple of changedKeyTuples) {
+            const params = {};
+            for (let i = 0; i < pkIndices.length; i++) {
+                params[`pk${i}`] = tuple[i];
+            }
+            const runtimeCtx = {
+                db: this,
+                stmt: undefined,
+                params,
+                context: new Map(),
+                tableContexts: new Map(),
+                tracer: this.instructionTracer,
+                enableMetrics: this.options.getBooleanOption('runtime_stats'),
+            };
+            // Run and detect first output row (violation)
+            const result = await scheduler.run(runtimeCtx);
+            if (isAsyncIterable(result)) {
+                for await (const _ of result) {
+                    throw new QuereusError(`CHECK constraint failed: ${assertionName}`, StatusCode.CONSTRAINT);
+                }
+            }
+        }
+    }
+    /** Execute a parameterized variant of the assertion once per changed key for a specific row-specific relationKey. */
+    async executeViolationPerChangedKeys(assertionName, violationSql, analyzed, targetRelationKey, base) {
+        const changedKeyTuples = this.getChangedKeyTuples(base);
+        if (changedKeyTuples.length === 0)
+            return;
+        // Find PK indices for the base table
+        const [schemaName, tableName] = base.split('.');
+        const table = this._findTable(tableName, schemaName);
+        if (!table) {
+            throw new QuereusError(`Assertion references unknown table ${base}`, StatusCode.INTERNAL);
+        }
+        const pkIndices = table.primaryKeyDefinition.map(def => def.index);
+        // Prepare a rewritten plan with an injected Filter on the target relationKey
+        const rewritten = this.injectPkFilter(analyzed, targetRelationKey, base, pkIndices);
+        const optimizedPlan = this.optimizer.optimize(rewritten, this);
+        // Emit and execute for each changed PK tuple; stop on first violation row.
+        const emissionContext = new EmissionContext(this);
+        const rootInstruction = emitPlanNode(optimizedPlan, emissionContext);
+        const scheduler = new Scheduler(rootInstruction);
+        for (const tuple of changedKeyTuples) {
+            const params = {};
+            for (let i = 0; i < pkIndices.length; i++) {
+                params[`pk${i}`] = tuple[i];
+            }
+            const runtimeCtx = {
+                db: this,
+                stmt: undefined,
+                params,
+                context: new Map(),
+                tableContexts: new Map(),
+                tracer: this.instructionTracer,
+                enableMetrics: this.options.getBooleanOption('runtime_stats'),
+            };
+            // Run and detect first output row (violation)
+            const result = await scheduler.run(runtimeCtx);
+            if (isAsyncIterable(result)) {
+                for await (const _ of result) {
+                    throw new QuereusError(`Integrity assertion failed: ${assertionName}`, StatusCode.CONSTRAINT);
+                }
+            }
+        }
+    }
+    /** Gather all changed PK tuples for a base table across layers */
+    getChangedKeyTuples(base) {
+        const lower = base.toLowerCase();
+        const tuples = [];
+        const collect = (m) => {
+            const set = m.get(lower);
+            if (!set)
+                return;
+            for (const s of set)
+                tuples.push(JSON.parse(s));
+        };
+        collect(this.changeLog);
+        for (const layer of this.changeLogLayers)
+            collect(layer);
+        return tuples;
+    }
+    /** Inject an equality Filter with named parameters :pk0, :pk1, ... at the earliest reference of targetRelationKey. */
+    injectPkFilter(block, targetRelationKey, base, pkIndices) {
+        const newStatements = block.getChildren().map(stmt => this.rewriteForPkFilter(stmt, targetRelationKey, base, pkIndices));
+        if (newStatements.every((s, i) => s === block.getChildren()[i]))
+            return block;
+        return this.createBlockWithNewStatements(block, newStatements);
+    }
+    rewriteForPkFilter(node, targetRelationKey, base, pkIndices) {
+        // If this node is the target TableReference instance, wrap with a Filter
+        const maybe = this.tryWrapTableReference(node, targetRelationKey, base, pkIndices);
+        if (maybe)
+            return maybe;
+        const originalChildren = node.getChildren();
+        if (!originalChildren || originalChildren.length === 0)
+            return node;
+        const rewrittenChildren = originalChildren.map(child => this.rewriteForPkFilter(child, targetRelationKey, base, pkIndices));
+        const changed = rewrittenChildren.some((c, i) => c !== originalChildren[i]);
+        return changed ? node.withChildren(rewrittenChildren) : node;
+    }
+    tryWrapTableReference(node, targetRelationKey, base, pkIndices) {
+        if (!(node instanceof TableReferenceNode))
+            return null;
+        const tableSchema = node.tableSchema;
+        const schemaName = tableSchema.schemaName;
+        const tableName = tableSchema.name;
+        const relName = `${schemaName}.${tableName}`.toLowerCase();
+        const relKey = `${relName}#${node.id ?? 'unknown'}`;
+        if (relKey !== targetRelationKey)
+            return null;
+        // Build predicate: AND(col_pk_i = :pk{i}) for all PK columns
+        const relational = node;
+        const scope = relational.scope;
+        const attributes = relational.getAttributes();
+        const makeColumnRef = (colIndex) => {
+            const attr = attributes[colIndex];
+            const expr = { type: 'column', name: attr.name, table: tableName, schema: schemaName };
+            return new ColumnReferenceNode(scope, expr, attr.type, attr.id, colIndex);
+        };
+        const makeParamRef = (i, type) => {
+            const pexpr = { type: 'parameter', name: `pk${i}` };
+            return new ParameterReferenceNode(scope, pexpr, `pk${i}`, type);
+        };
+        let predicate = null;
+        for (let i = 0; i < pkIndices.length; i++) {
+            const colIdx = pkIndices[i];
+            const left = makeColumnRef(colIdx);
+            const right = makeParamRef(i, attributes[colIdx].type);
+            const bexpr = { type: 'binary', operator: '=', left: left.expression, right: right.expression };
+            const eqNode = new BinaryOpNode(scope, bexpr, left, right);
+            predicate = predicate
+                ? new BinaryOpNode(scope, { type: 'binary', operator: 'AND', left: predicate.expression, right: eqNode.expression }, predicate, eqNode)
+                : eqNode;
+        }
+        if (!predicate)
+            return null;
+        // Wrap the table reference with a FilterNode
+        return new FilterNode(scope, relational, predicate);
+    }
+    collectTables(node, relToBase, bases) {
+        for (const child of node.getChildren()) {
+            this.collectTables(child, relToBase, bases);
+        }
+        if (node instanceof TableReferenceNode) {
+            const schema = node.tableSchema;
+            const baseName = `${schema.schemaName}.${schema.name}`.toLowerCase();
+            bases.add(baseName);
+            const relKey = `${baseName}#${node.id ?? 'unknown'}`;
+            relToBase.set(relKey, baseName);
+        }
     }
     /**
      * Rollback an implicit transaction and coordinate with virtual table connections
@@ -775,7 +1199,7 @@ export class Database {
             }
             catch (error) {
                 errorLog(`Error rolling back transaction on connection ${connection.connectionId}: %O`, error);
-                // Don't throw here - we want to rollback as many as possible
+                // Continue attempting rollback for other connections.
             }
         });
         await Promise.allSettled(rollbackPromises);
@@ -784,5 +1208,8 @@ export class Database {
         this.isAutocommit = true;
         this.inImplicitTransaction = false;
     }
+    createBlockWithNewStatements(block, statements) {
+        return new BlockNode(block.scope, statements, block.parameters);
+    }
 }
 //# sourceMappingURL=database.js.map