Struct SqliteGraph 

pub struct SqliteGraph { /* private fields */ }

SQLite-backed GraphBackend over one mutex-guarded connection.

Opening applies the schema and runs any pending migrations, so a database created by an older llm-kernel is upgraded transparently on open.

Implementations

impl SqliteGraph

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

Open (or create) a graph database at path, applying schema + migrations.

pub fn open_in_memory() -> Result<Self>

Create an in-memory graph (useful for tests and ephemeral stores).

pub fn mark_verified(&self, id: &str, now: &str) -> Result<bool>

Record that a node’s content was verified as of now (ISO 8601).

Convenience wrapper over crate::graph::lifecycle::mark_verified — the connection is owned by the graph, so callers don’t need to open their own.

pub fn count_expired_nodes(&self, now: &str) -> Result<u64>

Count nodes whose valid_until is set and earlier than now (ISO 8601).

Convenience wrapper over crate::graph::lifecycle::count_expired_nodes.

pub fn with_tx(&self, f: impl FnOnce(&Connection) -> Result<()>) -> Result<()>

Run f against the underlying connection inside one transaction.

Commits when f returns Ok, rolls back on Err — so multi-step sequences (e.g. delete-then-insert edge replacement) cannot leave a half-applied state. f receives &Connection: the transaction derefs to it, so the free functions in crate::graph::store work as-is.

Do not call other SqliteGraph methods on the same instance inside f — they re-acquire the connection lock and will deadlock. Use only the free functions on the passed connection. Similarly, avoid the free functions that open their own transaction inside f — notably crate::graph::store::append_edges and crate::graph::store::delete_node — they fail with “cannot start a transaction within a transaction”. Their single-item counterparts (crate::graph::store::append_edge, plain DELETE) are safe.

impl SqliteGraph

CJK-aware convenience methods (available with the graph-cjk feature).

pub fn search_nodes_cjk( &self, query: &str, limit: usize, ) -> Result<Vec<GraphNode>>

CJK (or mixed) search via contiguous substring matching.

Delegates to crate::graph::cjk::search_nodes_cjk; see its docs for the matching semantics.

pub fn segment_cjk(text: &str) -> String

Segment a string for CJK tokenization (exposed for callers that want to pre-process queries or inspect tokenization).

Trait Implementations

impl GraphBackend for SqliteGraph

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

Insert or replace a node.

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

Read a single node by ID (None if absent).

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

Delete a node by ID. Returns true if a row was removed.

fn search_nodes(&self, query: &str, limit: usize) -> Result<Vec<GraphNode>>

FTS5 full-text search, ranked by importance DESC.

fn query_nodes( &self, tag: Option<&str>, node_type: Option<&str>, project: Option<&str>, limit: usize, ) -> Result<Vec<GraphNode>>

Dynamic filter by tag / node_type / project.

fn smart_recall( &self, project: Option<&str>, hint: Option<&str>, limit: usize, ) -> Result<Vec<ScoredNode>>

Composite recall — rank nodes by recency, importance, access, FTS, and graph boost. The canonical high-level read path for “what’s relevant”.

fn related_nodes(&self, start_id: &str, depth: usize) -> Result<Vec<String>>

BFS-traverse up to depth hops from start_id, returning related node IDs (excluding the start).

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

Append an edge (duplicates by edge ID are ignored).

fn append_edges(&self, edges: &[GraphEdge]) -> Result<()>

Append many edges in one call.

fn edges_for_node_dir( &self, node_id: &str, dir: EdgeDirection, relation: Option<&str>, ) -> Result<Vec<GraphEdge>>

Read edges touching node_id, filtered by direction and an optional relation. The default implementation reads both directions via Self::edges_for_node and filters in Rust; backends with directional indexes override for efficiency.

fn neighbors_weighted( &self, seed_ids: &[String], dir: EdgeDirection, relation: Option<&str>, ) -> Result<Vec<(String, f64)>>

1-hop neighbors of seed_ids (weighted sum), restricted by direction and an optional relation. Seed nodes are excluded. The default implementation walks each seed via Self::edges_for_node_dir.

fn edges_for_node(&self, node_id: &str) -> Result<Vec<GraphEdge>>

Read edges where the given node is source or target.

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

Delete an edge by ID. Returns true if a row was removed.

fn remove_edges_for_node(&self, node_id: &str) -> Result<()>

Remove every edge connected to a node.

fn current_version(&self) -> Result<u32>

Recorded schema version for this backend.

fn migrate(&self) -> Result<u32>

Apply pending migrations up to the backend’s latest schema version. Returns the resulting version.

fn related_nodes_filtered( &self, start_id: &str, depth: usize, dir: EdgeDirection, relation: Option<&str>, ) -> Result<Vec<String>>

BFS-traverse up to depth hops from start_id, returning related node IDs (excluding the start), restricted by direction and an optional relation. The default implementation hops via Self::neighbors_weighted.