Trait GraphStore 

pub trait GraphStore: Send + Sync {
    // Required methods
    fn put_node<'life0, 'life1, 'async_trait>(
        &'life0 self,
        node: &'life1 Node,
    ) -> Pin<Box<dyn Future<Output = Result<PutOutcome>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn put_edge<'life0, 'life1, 'async_trait>(
        &'life0 self,
        edge: &'life1 Edge,
    ) -> Pin<Box<dyn Future<Output = Result<PutOutcome>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    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;
    fn get_edges<'life0, 'async_trait>(
        &'life0 self,
        query: EdgeQuery,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn traverse<'life0, 'async_trait>(
        &'life0 self,
        traversal: Traversal,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Node>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided methods
    fn apply_schema<'life0, 'life1, 'async_trait>(
        &'life0 self,
        _schema: &'life1 GraphSchema,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn put_graph<'life0, 'life1, 'async_trait>(
        &'life0 self,
        graph: &'life1 Graph,
    ) -> Pin<Box<dyn Future<Output = Result<LoadReport>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn put_typed_graph<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        schema: &'life1 GraphSchema,
        graph: &'life2 Graph,
    ) -> Pin<Box<dyn Future<Output = Result<LoadReport>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn get_nodes<'life0, 'life1, 'async_trait>(
        &'life0 self,
        ids: &'life1 [NodeId],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Node>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
}

Required Methods

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

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

Writes one node.

The returned PutOutcome reports the most precise result the backend can provide. Remote upsert backends generally return PutOutcome::Upserted for both inserts and updates.

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

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

Writes one edge.

The returned PutOutcome reports the most precise result the backend can provide. Remote upsert backends generally return PutOutcome::Upserted for both inserts and updates.

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,

fn get_edges<'life0, 'async_trait>( &'life0 self, query: EdgeQuery, ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>

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

fn traverse<'life0, 'async_trait>( &'life0 self, traversal: Traversal, ) -> Pin<Box<dyn Future<Output = Result<Vec<Node>>> + Send + 'async_trait>>

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

Provided Methods

fn apply_schema<'life0, 'life1, 'async_trait>( &'life0 self, _schema: &'life1 GraphSchema, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Applies backend schema metadata.

GraphSchema is a portable declaration of expected node labels, edge labels, fields, endpoint labels, direction, and uniqueness. The default implementation is a no-op for schemaless stores. Backend implementations may use the schema for validation, typed native tables, views, indexes, generated query shapes, or database-native schema definitions.

Applying a schema does not imply the same enforcement guarantee on every backend. Callers that need portable preflight validation should call GraphSchema::validate_graph before writing, or use GraphStore::put_typed_graph, which does that validation before applying the backend schema and writing the graph. Individual backends document whether they also validate each subsequent write at runtime.

fn put_graph<'life0, 'life1, 'async_trait>( &'life0 self, graph: &'life1 Graph, ) -> Pin<Box<dyn Future<Output = Result<LoadReport>> + Send + 'async_trait>>

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

fn put_typed_graph<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, schema: &'life1 GraphSchema, graph: &'life2 Graph, ) -> Pin<Box<dyn Future<Output = Result<LoadReport>> + Send + 'async_trait>>

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

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

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

Reads multiple nodes by ID.

The default implementation preserves the input order and calls GraphStore::get_node once per ID. Backends with a native batch-read path should override this to avoid per-node round trips during traversal and other fan-out reads.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors