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 delete_source_projection( &mut self, source_ref: &str, provider: &str, ) -> Result<usize>

#kgrefreshdup: delete every node previously projected from source_ref by provider, so a re-extraction REPLACES that source’s subgraph instead of accumulating duplicate canonical entities across refresh cycles. Incident edges, node/edge properties, and semantic vectors are removed automatically via the ON DELETE CASCADE foreign keys. The provider scope keeps the delete from touching non-KG nodes (e.g. AST symbols) that may share a source_ref path in the same graph database. Returns the node count deleted.

pub fn link_nodes_by_shared_property( &mut self, kind: &str, id_key: &str, id_prefix: &str, edge_kind: &str, edge_properties: &[(&str, &str)], ) -> Result<usize>

#kgsameas: link nodes of kind that share the same id_key property value (restricted to values starting with id_prefix) using star edge_kind edges — each group’s members point at its lexicographically-smallest node id. This collapses duplicate logical entities for ALL graph consumers (not just the context pack), without deleting any node, so per-source provenance is preserved. Idempotent: edges key on (from,to,kind), so re-running upserts the same set. Returns the number of link edges written.

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 nodes_by_ids(&self, ids: &[String]) -> Result<Vec<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 semantic_top_candidates( &self, query_vector: &[f64], kinds: &[&str], limit: usize, ) -> Result<Vec<GraphSemanticCandidate>>

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 semantic_seeded_expansion_edges( &self, current_id: &str, options: &SemanticSeededNeighborhoodOptions, ) -> Result<SemanticSeededNeighborhoodExpansion>

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 evidence_target_candidates( &self, target: &str, kinds: &[&str], preferred_path: Option<&str>, ) -> Result<Vec<GraphNode>>

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

fn semantic_seeded_neighborhood( &self, seed_ids: &[String], options: &SemanticSeededNeighborhoodOptions, ) -> Result<SemanticSeededNeighborhoodResult, Error>