Struct GraphDB 

pub struct GraphDB { /* private fields */ }

High-performance graph database with concurrent access

Implementations

impl GraphDB

pub fn new() -> Self

Create a new in-memory graph database

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

Create a new graph database with persistent storage

pub fn create_node(&self, node: Node) -> Result<NodeId>

Create a node

pub fn get_node(&self, id: impl AsRef<str>) -> Option<Node>

Get a node by ID

pub fn with_node<R>(&self, id: &str, f: impl FnOnce(&Node) -> R) -> Option<R>

Borrow a node and apply f without cloning it.

Hot-path accessor for scans that only need to read a node (e.g. vector scoring). Avoids the full Node + embedding clone that get_node incurs. Returns None if the node is absent.

pub fn node_ids_by_label(&self, label: &str) -> Vec<NodeId>

Node ids carrying label, straight from the label index (no node clones).

pub fn delete_node(&self, id: impl AsRef<str>) -> Result<bool>

Delete a node

pub fn update_node<F>(&self, id: impl AsRef<str>, f: F) -> Result<bool>

where F: FnOnce(&mut Node),

Atomically update an existing node.

Applies f to a clone of the current node, persists the new value, and refreshes the label and property indexes. Concurrent updates to the same node are serialized, so one update cannot silently overwrite another. The node ID is immutable and changing it returns a constraint error.

Returns Ok(false) if the node was not found (no error), Ok(true) if updated successfully. This is the counterpart to create_node and enables SUPERSEDES-style versioning where a prior node is marked deprecated without deleting it.

Example

graph.update_node(&node_id, |n| {
    n.set_property("status", PropertyValue::from("deprecated"));
    n.set_property("deprecated_at", PropertyValue::from(now_iso8601));
})?;

The callback runs while the node’s map shard is write-locked. It must not call back into this GraphDB, because doing so may deadlock.

pub fn keyword_search( &self, label: &str, text_field: &str, query: &str, k: usize, ) -> Result<Vec<(NodeId, f32)>>

Keyword (BM25) search over a node text property.

Builds a transient Bm25Index from the text_field property of all nodes carrying label, and returns the top-k node IDs by BM25 score. This is the keyword arm of hybrid search — pair with vector ANN for reciprocal rank fusion.

For large graphs, build the index once and reuse it; this method rebuilds on every call (suitable for small-to-medium graphs or one-shot queries). A cached variant can be added behind a feature flag if needed.

Example

let hits = graph.keyword_search("Memory", "content", "vector search", 10)?;

pub fn get_nodes_by_label(&self, label: &str) -> Vec<Node>

Get nodes by label

pub fn get_nodes_by_property( &self, key: &str, value: &PropertyValue, ) -> Vec<Node>

Get nodes by property

pub fn create_edge(&self, edge: Edge) -> Result<EdgeId>

Create an edge

pub fn get_edge(&self, id: impl AsRef<str>) -> Option<Edge>

Get an edge by ID

pub fn delete_edge(&self, id: impl AsRef<str>) -> Result<bool>

Delete an edge

pub fn delete_edges_batch(&self, ids: &[impl AsRef<str>]) -> Result<usize>

Delete multiple edges (batch)

pub fn get_edges_by_type(&self, edge_type: &str) -> Vec<Edge>

Get edges by type

pub fn get_outgoing_edges(&self, node_id: &NodeId) -> Vec<Edge>

Get outgoing edges from a node

pub fn get_incoming_edges(&self, node_id: &NodeId) -> Vec<Edge>

Get incoming edges to a node

pub fn has_edge(&self, from: &NodeId, to: &NodeId, edge_type: &str) -> bool

Checks whether an edge exists from from → to with type edge_type. Returns true if found, false otherwise.

Fast path: avoids cloning Edge by reading fields through the DashMap reference guard and short-circuits on first match.

pub fn get_edges_for_nodes(&self, node_ids: &[NodeId]) -> Vec<Edge>

Get outgoing edges for multiple nodes in one call (O(k×avg_degree) vs O(E) for full scan).

pub fn create_hyperedge(&self, hyperedge: Hyperedge) -> Result<HyperedgeId>

Create a hyperedge

pub fn get_hyperedge(&self, id: &HyperedgeId) -> Option<Hyperedge>

Get a hyperedge by ID

pub fn get_hyperedges_by_node(&self, node_id: &NodeId) -> Vec<Hyperedge>

Get hyperedges containing a node

pub fn delete_hyperedge(&self, id: &HyperedgeId) -> Result<bool>

Delete a hyperedge by ID

pub fn delete_hyperedges_by_node(&self, node_id: &NodeId) -> Result<usize>

Delete all hyperedges that contain a given node

pub fn node_count(&self) -> usize

Get the number of nodes

pub fn edge_count(&self) -> usize

Get the number of edges

pub fn hyperedge_count(&self) -> usize

Get the number of hyperedges

Trait Implementations

impl Default for GraphDB

fn default() -> Self

Returns the “default value” for a type.