Struct SqliteGraphStore 

pub struct SqliteGraphStore { /* private fields */ }

SQLite-backed graph store.

Temp-table invariant

Several methods — replace_projection_with_version, upsert_projection, edges_between_nodes, and breadth_first_search — create connection-scoped TEMP TABLE staging areas inside the underlying SQLite connection. Two concurrent calls on the same SqliteGraphStore (or sharing the same connection through SqliteReadOnlyConnection) would collide on those temp table names and produce incorrect results or errors.

Only one temp-table-using method may be active at a time per connection.

Implementations

impl SqliteGraphStore

pub fn open(db_path: &Path) -> Result<Self>

pub fn in_memory() -> Result<Self>

pub fn open_read_only(db_path: &Path) -> Result<Self>

pub fn open_read_only_resilient(db_path: &Path) -> Result<Self>

pub fn read_only_recovery(&self) -> Option<ReadOnlyRecovery>

pub fn has_user_triggers(&self) -> Result<bool>

pub fn replace_projection(&mut self, projection: &GraphProjection) -> Result<()>

pub fn replace_projection_with_version( &mut self, scope: impl Into<String>, projection: &GraphProjection, projection_version: Option<&str>, source_watermark: Option<String>, ) -> Result<SqliteProjectionRefresh>

pub fn derive_ontology(&self) -> Result<GraphProjection>

Derive a Semantic Ontology Graph (#memgraphrag-ont, MemGraphRAG arxiv 2606.00610 third layer) from the instance graph: one ontology_type node per distinct node kind, and one ontology_relation:<edge_kind> edge per observed (from_kind, edge_kind, to_kind) triple, each carrying an instance_count. This data-driven schema lets retrieval start from abstract types and prune by permitted inter-type relations. Existing ontology rows are excluded so the derivation is idempotent and never folds the ontology layer into itself.

pub fn upsert_projection(&mut self, projection: &GraphProjection) -> Result<()>

pub fn projection_version( &self, scope: &str, ) -> Result<Option<SqliteProjectionVersion>>

pub fn update_projection_source_watermark( &mut self, scope: &str, source_watermark: Option<String>, ) -> Result<()>

pub fn compact_storage( &mut self, scope: &str, prune_tombstones: bool, ) -> Result<usize>

Trait Implementations

impl GraphStore for SqliteGraphStore

fn upsert_node(&self, node: &GraphNode) -> Result<()>

fn upsert_edge(&self, edge: &GraphEdge) -> Result<()>

fn delete_node(&self, id: &str) -> Result<usize>

fn delete_edge(&self, from_id: &str, to_id: &str, kind: &str) -> Result<usize>

fn node(&self, id: &str) -> Result<Option<GraphNode>>

fn all_nodes(&self) -> Result<Vec<GraphNode>>

fn all_edges(&self) -> Result<Vec<GraphEdge>>

fn edge(&self, edge_id: &str) -> Result<Option<GraphEdge>>

fn graph_counts(&self) -> Result<(usize, usize)>

fn sample_edge(&self, kind: Option<&str>) -> Result<Option<GraphEdge>>

fn sample_edge_with_property( &self, ) -> Result<Option<(GraphEdge, GraphPropertyFilter)>>

fn nodes_by_kind(&self, kind: &str) -> Result<Vec<GraphNode>>

fn paged_nodes_by_kind( &self, kind: &str, options: GraphQueryOptions, ) -> Result<GraphPagedSubgraph>

fn outgoing_edges( &self, from_id: &str, kind: Option<&str>, ) -> Result<Vec<GraphEdge>>

fn incident_edges( &self, node_id: &str, kind: Option<&str>, ) -> Result<Vec<GraphEdge>>

fn paged_edges( &self, kind: Option<&str>, options: GraphQueryOptions, ) -> Result<GraphPagedSubgraph>

fn paged_incident_edges( &self, node_id: &str, kind: Option<&str>, options: GraphQueryOptions, ) -> Result<GraphPagedSubgraph>

fn edges_between_nodes( &self, node_ids: &BTreeSet<String>, ) -> Result<Vec<GraphEdge>>

fn ranked_neighborhood( &self, center_id: &str, options: &RankedNeighborhoodOptions, ) -> Result<Option<RankedNeighborhoodResult>>

fn neighborhood( &self, center_id: &str, depth: usize, kind: Option<&str>, ) -> Result<Option<GraphSubgraph>>

fn paged_neighborhood( &self, center_id: &str, depth: usize, kind: Option<&str>, options: GraphQueryOptions, ) -> Result<Option<GraphPagedSubgraph>>

fn shortest_path( &self, from_id: &str, to_id: &str, kind: Option<&str>, ) -> Result<Option<GraphPath>>

fn shortest_path_with_max_hops( &self, from_id: &str, to_id: &str, kind: Option<&str>, max_hops: Option<usize>, ) -> Result<Option<GraphPath>>

fn reachable_nodes_by_kind( &self, from_id: &str, kind: &str, depth: usize, limit: usize, ) -> Result<Vec<(GraphNode, GraphPath)>>

fn reachable_nodes_by_kinds( &self, from_id: &str, kinds: &[&str], depth: usize, limit: usize, ) -> Result<BTreeMap<String, Vec<(GraphNode, GraphPath)>>>

fn resolve_evidence_target( &self, target: &str, kinds: &[&str], ) -> Result<Option<GraphNode>>