Struct GraphStore 

pub struct GraphStore { /* private fields */ }

Implementations

impl GraphStore

pub fn open_file(path: impl AsRef<Path>) -> Result<Self, GraphError>

pub fn open_memory() -> Result<Self, GraphError>

pub fn backup_to(&self, path: impl AsRef<Path>) -> Result<(), GraphError>

pub fn check_integrity(&mut self) -> Result<IntegrityReport, GraphError>

Check physical storage plus MarsDB’s graph invariants. This requires exclusive mutable access because redb may repair physical metadata.

pub fn begin_write(&self) -> Result<WriteTransaction, GraphError>

Open a write transaction spanning multiple graph operations. Callers (e.g. the query executor) drive an entire Cypher statement through the *_in_txn methods below using this one transaction, then call write_txn.commit() themselves — this is the crash-safety boundary from the plan: one statement = one transaction, not one transaction per individual node/edge write.

v1 uses a write transaction even for pure-read statements (rather than a separate read-only path) to keep one code path and guarantee every statement — reads included — sees one consistent snapshot. Trade-off: this serializes concurrent readers behind redb’s single-writer lock instead of allowing true concurrent reads; a read-only transaction path is the natural follow-up if read concurrency becomes a bottleneck.

pub fn begin_read(&self) -> Result<ReadTransaction, GraphError>

Open a read transaction for a statement that never mutates anything (MATCH ... RETURN) — a consistent point-in-time snapshot that runs alongside any concurrent readers or a concurrent writer without contending for redb’s single-writer lock. No commit/abort: a read transaction has nothing to roll back, it just releases on drop.

pub fn commit(write_txn: WriteTransaction) -> Result<(), GraphError>

Commit a transaction obtained from begin_write.

pub fn abort(write_txn: WriteTransaction) -> Result<(), GraphError>

Abort (roll back) a transaction obtained from begin_write, discarding any writes made through it.

pub fn create_node( &self, labels: &[&str], props: BTreeMap<String, PropertyValue>, ) -> Result<NodeId, GraphError>

pub fn create_node_in_txn( write_txn: &WriteTransaction, labels: &[&str], props: BTreeMap<String, PropertyValue>, ) -> Result<NodeId, GraphError>

pub fn get_node(&self, id: NodeId) -> Result<Option<Node>, GraphError>

pub fn get_node_in_txn( txn: Txn<'_>, id: NodeId, ) -> Result<Option<Node>, GraphError>

pub fn create_edge( &self, label: &str, src: NodeId, dst: NodeId, props: BTreeMap<String, PropertyValue>, ) -> Result<EdgeId, GraphError>

pub fn create_edge_in_txn( write_txn: &WriteTransaction, label: &str, src: NodeId, dst: NodeId, props: BTreeMap<String, PropertyValue>, ) -> Result<EdgeId, GraphError>

pub fn get_edge(&self, id: EdgeId) -> Result<Option<Edge>, GraphError>

pub fn get_edge_in_txn( txn: Txn<'_>, id: EdgeId, ) -> Result<Option<Edge>, GraphError>

pub fn neighbors( &self, node: NodeId, dir: Direction, label_filter: Option<&str>, ) -> Result<Vec<AdjEntry>, GraphError>

Neighbors of node in dir, optionally filtered by edge label. Reads directly from the adjacency multimap without touching edges.

pub fn neighbors_in_txn( txn: Txn<'_>, node: NodeId, dir: Direction, label_filter: Option<&str>, ) -> Result<Vec<AdjEntry>, GraphError>

pub fn delete_edge(&self, id: EdgeId) -> Result<bool, GraphError>

pub fn delete_edge_in_txn( write_txn: &WriteTransaction, id: EdgeId, ) -> Result<bool, GraphError>

pub fn delete_node(&self, id: NodeId, detach: bool) -> Result<bool, GraphError>

Delete a node. If detach is false and the node has incident edges, returns GraphError::NodeHasEdges instead of deleting anything.

pub fn delete_node_in_txn( write_txn: &WriteTransaction, id: NodeId, detach: bool, ) -> Result<bool, GraphError>

pub fn create_index( &self, label: &str, prop: &str, unique: bool, ) -> Result<(), GraphError>

Declares an index on (label, prop), backfilling it from every existing node with label — see index::create_index’s own docs for the exact semantics (idempotency, unique-violation behavior).

pub fn create_index_in_txn( write_txn: &WriteTransaction, label: &str, prop: &str, unique: bool, ) -> Result<(), GraphError>

Same as create_index, but against an already-open WriteTransaction — for a caller (CREATE INDEX as a Cypher statement) that’s already inside one transaction and must commit or abort it as a whole, not open a second one (redb allows only one writer at a time; opening a second would deadlock).

pub fn index_def( &self, label: &str, prop: &str, ) -> Result<Option<IndexDef>, GraphError>

None means no index is declared on (label, prop).

pub fn index_def_in_txn( txn: Txn<'_>, label: &str, prop: &str, ) -> Result<Option<IndexDef>, GraphError>

Same as index_def, but against an already-open Txn — for a caller (the query planner/executor) that’s already inside one transaction and needs a consistent view, not a fresh snapshot.

pub fn lookup_by_index_in_txn( txn: Txn<'_>, label: &str, prop: &str, value: &PropertyValue, ) -> Result<Vec<NodeId>, GraphError>

Same as lookup_by_index, but against an already-open Txn.

pub fn lookup_by_index_limited_in_txn( txn: Txn<'_>, label: &str, prop: &str, value: &PropertyValue, limit: usize, ) -> Result<Vec<NodeId>, GraphError>

Same as lookup_by_index_in_txn, but stops once limit nodes are found — the storage-level end of LIMIT push-down through an IndexSeek (see marsdb_query::planner/executor::stream_index_seek).

pub fn index_match_count_in_txn( txn: Txn<'_>, label: &str, prop: &str, value: &PropertyValue, ) -> Result<u64, GraphError>

Cheap, exact count of nodes under (label, prop) = value — for the query planner to compare selectivity between several indexed equality candidates, not for fetching the nodes themselves (see lookup_by_index_in_txn). O(1), same contract as lookup_by_index re: “no index” vs “index, no match” both reading as 0.

pub fn lookup_by_index( &self, label: &str, prop: &str, value: &PropertyValue, ) -> Result<Vec<NodeId>, GraphError>

Every node currently indexed under (label, prop) = value. Empty (not an error) if no such index exists — check index_def first if the caller needs to distinguish “no index” from “index, no match”.

pub fn set_node_prop( &self, id: NodeId, key: &str, value: PropertyValue, ) -> Result<bool, GraphError>

pub fn set_node_prop_in_txn( write_txn: &WriteTransaction, id: NodeId, key: &str, value: PropertyValue, ) -> Result<bool, GraphError>

pub fn set_edge_prop( &self, id: EdgeId, key: &str, value: PropertyValue, ) -> Result<bool, GraphError>

pub fn set_edge_prop_in_txn( write_txn: &WriteTransaction, id: EdgeId, key: &str, value: PropertyValue, ) -> Result<bool, GraphError>

pub fn remove_node_prop_in_txn( write_txn: &WriteTransaction, id: NodeId, key: &str, ) -> Result<bool, GraphError>

pub fn remove_edge_prop_in_txn( write_txn: &WriteTransaction, id: EdgeId, key: &str, ) -> Result<bool, GraphError>

pub fn add_node_label_in_txn( write_txn: &WriteTransaction, id: NodeId, label: &str, ) -> Result<bool, GraphError>

Adds label to id’s label set – a no-op (not an error) if it’s already there, same idempotent-add semantics real Cypher’s SET n:Label has.

pub fn remove_node_label_in_txn( write_txn: &WriteTransaction, id: NodeId, label: &str, ) -> Result<bool, GraphError>

Removes label from id’s label set – a no-op (not an error) if it’s not there (label unknown entirely, or known but not on this node), same as real Cypher’s REMOVE n:Label.

pub fn all_nodes( &self, label_filter: Option<&str>, ) -> Result<Vec<Node>, GraphError>

Full scan of all nodes, optionally filtered by label. v1 has no secondary index on label, so this is a linear scan of the table.

pub fn all_node_ids_limited_in_txn( txn: Txn<'_>, label_filter: Option<&str>, limit: usize, ) -> Result<Vec<NodeId>, GraphError>

Scan only graph identities, without decoding node records. Query pipelines use this to defer record/property loading until a filter or projection actually needs it.

pub fn all_nodes_in_txn( txn: Txn<'_>, label_filter: Option<&str>, ) -> Result<Vec<Node>, GraphError>

pub fn all_nodes_limited_in_txn( txn: Txn<'_>, label_filter: Option<&str>, limit: usize, ) -> Result<Vec<Node>, GraphError>

Same as all_nodes_in_txn, but stops once limit nodes are found – the storage-level end of LIMIT push-down (see the executor’s scan()/eval_plan docs for the query-level half): a query whose entire plan is a bare scan feeding straight into a LIMIT doesn’t need to touch rows past the first limit, whether or not a label filter narrows it first.