Struct GraphWriteTxn 

pub struct GraphWriteTxn<'a> { /* private fields */ }

RAII transaction wrapper for graph writes.

GraphWriteTxn provides a safe interface for plugins to add nodes and edges to the unified graph. Changes are buffered and applied atomically when commit() is called.

Design

• RAII semantics: Transaction must be explicitly committed or changes are lost
• Buffered writes: Changes accumulate in memory until commit
• Atomic application: All changes applied together or none at all
• Error recovery: Failed commits leave graph unchanged

Example

use sqry_core::graph::unified::txn::GraphWriteTxn;
use sqry_core::graph::unified::CodeGraph;

let mut graph = CodeGraph::new();
let mut txn = GraphWriteTxn::new(&mut graph);

// Add nodes
let node_id = txn.add_node(
    Language::Rust,
    "main.rs",
    "main",
    NodeKind::Function,
    Some("fn main() { ... }"),
)?;

// Add edges
txn.add_edge(caller_id, callee_id, EdgeKind::Call)?;

// Commit changes
txn.commit()?;

Implementations

impl<'a> GraphWriteTxn<'a>

pub fn new(graph: &'a mut CodeGraph) -> Self

Creates a new write transaction.

The transaction holds a mutable reference to the graph for its lifetime. Changes are not visible until commit() is called.

Example

let mut graph = CodeGraph::new();
let mut txn = GraphWriteTxn::new(&mut graph);

pub fn add_node( &mut self, language: Language, file: impl Into<String>, symbol: impl Into<String>, kind: NodeKind, signature: Option<String>, ) -> Result<NodeId>

Adds a node to the transaction.

The node is not added to the graph until commit() is called.

Arguments

• language - Programming language of the node
• file - Source file path
• symbol - Node name (e.g., “main”, “MyClass::method”)
• kind - Node kind (Function, Class, etc.)
• signature - Optional signature string

Returns

Temporary NodeId that will be valid after commit. This ID is a placeholder and should not be used until after commit() succeeds.

Errors

Returns GraphResult error if node creation fails (e.g., invalid parameters).

Panics

Panics if the pending node count exceeds u32::MAX.

Example

let node_id = txn.add_node(
    Language::Rust,
    "src/main.rs",
    "main",
    NodeKind::Function,
    Some("fn main()"),
)?;

pub fn add_edge( &mut self, source: NodeId, target: NodeId, kind: EdgeKind, ) -> Result<EdgeId>

Adds an edge to the transaction.

The edge is not added to the graph until commit() is called.

Arguments

• source - Source node ID (must exist after commit)
• target - Target node ID (must exist after commit)
• kind - Edge kind (Call, Import, etc.)

Returns

Temporary EdgeId that will be valid after commit.

Errors

Returns GraphResult error if edge creation fails or nodes don’t exist.

Panics

Panics if the pending edge count exceeds u32::MAX.

Example

txn.add_edge(caller_id, callee_id, EdgeKind::Call)?;

pub fn commit(self) -> Result<()>

Commits all buffered changes to the graph.

This method applies all pending nodes and edges atomically. If any operation fails, the entire transaction is rolled back and the graph remains unchanged.

Returns

Ok(()) if all changes were successfully applied.

Errors

Returns GraphResult error if any node or edge addition fails. On error, all changes are rolled back.

Panics

Panics if called twice on the same transaction.

Example

txn.commit()?;

pub fn pending_nodes(&self) -> usize

Returns the number of pending nodes.

Example

assert_eq!(txn.pending_nodes(), 5);

pub fn pending_edges(&self) -> usize

Returns the number of pending edges.

Example

assert_eq!(txn.pending_edges(), 3);

Trait Implementations

impl Drop for GraphWriteTxn<'_>

fn drop(&mut self)

Executes the destructor for this type.