Method apply_undo_operation

graphlite/src/session/transaction_state.rs:226–529

Apply a single undo operation to rollback changes

(
        &self,
        operation: &crate::txn::UndoOperation,
        storage: &Arc<crate::storage::StorageManager>,
    )

    /// Apply a single undo operation to rollback changes
    fn apply_undo_operation(
        &self,
        operation: &crate::txn::UndoOperation,
        storage: &Arc<crate::storage::StorageManager>,
    ) -> Result<(), ExecutionError> {
        use crate::txn::UndoOperation;

        match operation {
            UndoOperation::Batch { operations } => {
                // Handle batch operations - undo all operations in the batch atomically
                log::info!(
                    "ROLLBACK: Processing batch with {} operations",
                    operations.len()
                );
                for (i, op) in operations.iter().enumerate() {
                    log::debug!(
                        "ROLLBACK: Applying batch operation {}/{}",
                        i + 1,
                        operations.len()
                    );
                    self.apply_undo_operation(op, storage)?;
                }
                log::info!(
                    "ROLLBACK: Successfully processed batch of {} operations",
                    operations.len()
                );
            }
            UndoOperation::InsertNode {
                graph_path,
                node_id,
            } => {
                log::info!(
                    "ROLLBACK: Undoing InsertNode: graph={}, node={}",
                    graph_path,
                    node_id
                );

                // Load the graph
                let mut graph = storage
                    .get_graph(graph_path)
                    .map_err(|e| {
                        ExecutionError::StorageError(format!(
                            "Failed to load graph for rollback: {}",
                            e
                        ))
                    })?
                    .ok_or_else(|| {
                        ExecutionError::StorageError(format!(
                            "Graph not found for rollback: {}",
                            graph_path
                        ))
                    })?;

                log::info!(
                    "ROLLBACK: Graph loaded, current node count: {}",
                    graph.node_count().unwrap_or(0)
                );