Struct AsyncSledBackend 

pub struct AsyncSledBackend { /* private fields */ }

Async wrapper around Sled-based storage backend

This struct provides async versions of all storage operations by wrapping the synchronous SledBackend and using Tokio’s blocking task pool.

Implementations

impl AsyncSledBackend

pub async fn open<P: AsRef<Path>>(path: P) -> Result<Self>

Open or create a new async Sled backend at the specified path

Examples

use llm_memory_graph::storage::AsyncSledBackend;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let backend = AsyncSledBackend::open("./data/graph.db").await?;
    Ok(())
}

pub async fn open_with_format<P: AsRef<Path>>( path: P, format: SerializationFormat, ) -> Result<Self>

Open with a custom serialization format

Examples

use llm_memory_graph::storage::{AsyncSledBackend, SerializationFormat};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let backend = AsyncSledBackend::open_with_format(
        "./data/graph.db",
        SerializationFormat::Json
    ).await?;
    Ok(())
}

Trait Implementations

impl AsyncStorageBackend for AsyncSledBackend

fn store_node<'life0, 'life1, 'async_trait>( &'life0 self, node: &'life1 Node, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a node in the backend asynchronously

fn get_node<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Node>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve a node by ID asynchronously

fn delete_node<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a node asynchronously

fn store_edge<'life0, 'life1, 'async_trait>( &'life0 self, edge: &'life1 Edge, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store an edge asynchronously

fn get_edge<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 EdgeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Edge>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve an edge by ID asynchronously

fn delete_edge<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 EdgeId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete an edge asynchronously

fn get_session_nodes<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Node>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all nodes in a session asynchronously

fn get_outgoing_edges<'life0, 'life1, 'async_trait>( &'life0 self, node_id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all edges from a node asynchronously

fn get_incoming_edges<'life0, 'life1, 'async_trait>( &'life0 self, node_id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all edges to a node asynchronously

fn flush<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Flush any pending writes asynchronously

fn stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<StorageStats>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get storage statistics asynchronously

fn store_nodes_batch<'life0, 'life1, 'async_trait>( &'life0 self, nodes: &'life1 [Node], ) -> Pin<Box<dyn Future<Output = Result<Vec<NodeId>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Batch store multiple nodes asynchronously for improved performance

fn store_edges_batch<'life0, 'life1, 'async_trait>( &'life0 self, edges: &'life1 [Edge], ) -> Pin<Box<dyn Future<Output = Result<Vec<EdgeId>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Batch store multiple edges asynchronously for improved performance

fn get_session_nodes_stream( &self, session_id: &SessionId, ) -> Pin<Box<dyn Stream<Item = Result<Node>> + Send + '_>>

Stream nodes from a session for memory-efficient iteration over large result sets

fn count_session_nodes<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count nodes in a session without loading them into memory

impl Clone for AsyncSledBackend

fn clone(&self) -> AsyncSledBackend

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.