Struct Database 

pub struct Database<S> { /* private fields */ }

Owns the graph store and orchestrates parse → analyze → compile → execute.

Implementations

impl Database<InMemoryGraph>

pub fn in_memory() -> Self

Convenience constructor: a fresh, empty in-memory graph database.

impl<S> Database<S>

where S: GraphStorage + GraphStorageMut,

pub fn new(store: Arc<Mutex<S>>) -> Self

Build a database from a pre-wrapped, shared store.

pub fn from_graph(graph: S) -> Self

Build a database by taking ownership of a bare graph store.

pub fn store(&self) -> &Arc<Mutex<S>>

Handle to the underlying shared store — useful for callers that need to snapshot or share the graph across multiple databases.

pub fn parse(&self, query: &str) -> Result<Document>

Parse a query string into an AST without executing it.

pub fn execute( &self, query: &str, options: Option<ExecuteOptions>, ) -> Result<QueryResult>

Execute a query and return its result.

pub fn execute_with_params( &self, query: &str, options: Option<ExecuteOptions>, params: BTreeMap<String, LoraValue>, ) -> Result<QueryResult>

Execute a query with bound parameters.

pub fn clear(&self)

Drop every node and relationship.

pub fn node_count(&self) -> usize

Number of nodes currently in the graph.

pub fn relationship_count(&self) -> usize

Number of relationships currently in the graph.

pub fn with_store<R>(&self, f: impl FnOnce(&S) -> R) -> R

Run a closure with a shared borrow of the underlying store. Used by bindings to answer ad-hoc queries without locking the mutex themselves.

pub fn with_store_mut<R>(&self, f: impl FnOnce(&mut S) -> R) -> R

Run a closure with an exclusive borrow of the underlying store. Reserved for admin paths (restore, bulk load); regular mutation goes through execute_with_params.

impl<S> Database<S>

where S: GraphStorage + GraphStorageMut + Snapshotable,

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

Serialize the current graph state to the given path. Writes are atomic: the payload goes to <path>.tmp, is fsync’d, and then renamed over the target; a torn write can never leave a half-written file at path. If any step before the rename fails, the stale <path>.tmp is removed so a crashed save never leaks scratch files.

Holds the store mutex for the duration of the save so concurrent queries see a consistent point-in-time snapshot.

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

Replace the current graph state with a snapshot loaded from path. Holds the store mutex for the duration of the load; concurrent queries block until restore completes.

impl Database<InMemoryGraph>

pub fn in_memory_from_snapshot(path: impl AsRef<Path>) -> Result<Self>

Convenience constructor: open (or create) an empty in-memory database and immediately restore it from path. Errors if the file cannot be opened or the snapshot is malformed.

Trait Implementations

impl<S> QueryRunner for Database<S>

where S: GraphStorage + GraphStorageMut + Send + 'static,

fn execute( &self, query: &str, options: Option<ExecuteOptions>, ) -> Result<QueryResult>

impl<S> SnapshotAdmin for Database<S>

where S: GraphStorage + GraphStorageMut + Snapshotable + Send + 'static,

fn save_snapshot(&self, path: &Path) -> Result<SnapshotMeta>

fn load_snapshot(&self, path: &Path) -> Result<SnapshotMeta>