Struct PgGraph 

pub struct PgGraph { /* private fields */ }

PostgreSQL-backed GraphBackend over one mutex-guarded connection.

Opening applies the schema and runs pending migrations, matching SqliteGraph::open in the main crate. An optional table_prefix (empty by default) namespaces every backing table and index so multiple graphs can share one database — see the *_with_prefix constructors.

Implementations

impl PgGraph

pub fn connect(url: &str) -> Result<Self>

Connect to url (libpq connstring or postgresql:// URL), apply schema and migrations, and return a ready backend. Uses the default (empty) table prefix.

pub fn connect_with_prefix(url: &str, prefix: &str) -> Result<Self>

Like connect, but every table/index is namespaced under prefix (e.g. "lk_" → lk_nodes / lk_edges / lk_meta). The prefix is validated by is_identifier_safe before any SQL runs.

pub fn connect_config(config: &Config) -> Result<Self>

Connect from a pre-built Config (useful for overriding dbname, e.g. when targeting a throwaway test database). Uses the default (empty) table prefix.

pub fn connect_config_with_prefix(config: &Config, prefix: &str) -> Result<Self>

Like connect_config, but every table/index is namespaced under prefix.

pub fn connect_tls<T>(url: &str, connector: T) -> Result<Self>

where T: MakeTlsConnect<Socket> + Send + 'static, T::TlsConnect: Send, T::Stream: Send, <T::TlsConnect as TlsConnect<Socket>>::Future: Send,

Connect to url using a caller-supplied TLS connector — for servers requiring sslmode=require or stricter (e.g. RDS with rds.force_ssl). See Self::connect_native_tls for the common case of a system-trust-store native-tls connector. Uses the default (empty) table prefix.

pub fn connect_tls_with_prefix<T>( url: &str, prefix: &str, connector: T, ) -> Result<Self>

where T: MakeTlsConnect<Socket> + Send + 'static, T::TlsConnect: Send, T::Stream: Send, <T::TlsConnect as TlsConnect<Socket>>::Future: Send,

TLS variant of connect_with_prefix with a caller-supplied TLS connector.

pub fn connect_config_tls<T>(config: &Config, connector: T) -> Result<Self>

where T: MakeTlsConnect<Socket> + Send + 'static, T::TlsConnect: Send, T::Stream: Send, <T::TlsConnect as TlsConnect<Socket>>::Future: Send,

Connect from a pre-built Config using a caller-supplied TLS connector. Mirrors Self::connect_config but negotiates TLS instead of postgres::NoTls. Uses the default (empty) table prefix.

pub fn connect_config_tls_with_prefix<T>( config: &Config, prefix: &str, connector: T, ) -> Result<Self>

where T: MakeTlsConnect<Socket> + Send + 'static, T::TlsConnect: Send, T::Stream: Send, <T::TlsConnect as TlsConnect<Socket>>::Future: Send,

TLS variant of connect_config_with_prefix with a caller-supplied TLS connector.

pub fn connect_native_tls(url: &str) -> Result<Self>

Connect to url over TLS using native-tls with the system trust store (default settings — full certificate chain and hostname verification against the system trust store, not weakened) — covers the common case of a Postgres server with a publicly-trusted certificate (e.g. RDS sslmode=require). For custom CA bundles or client certificates, build a connector and call Self::connect_tls directly. Uses the default (empty) table prefix.

pub fn connect_native_tls_with_prefix(url: &str, prefix: &str) -> Result<Self>

TLS variant of connect_with_prefix using native-tls with the system trust store.

pub fn from_client(client: Client) -> Result<Self>

Shared post-connect setup (schema + migrations) for every constructor.

Public so a consumer that already owns a synchronous postgres::Client can adopt PgGraph without re-opening the connection. For an async pool (e.g. sqlx::PgPool), use the planned SqlxPgGraph backend instead. Uses the default (empty) table prefix.

pub fn from_client_with_prefix(client: Client, prefix: &str) -> Result<Self>

Like from_client, but every table/index is namespaced under prefix. The prefix is validated first; an unsafe value (anything beyond ASCII alphanumeric / underscore, or a digit-led name) returns KernelError::Store before any SQL is emitted.

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

List up to limit nodes (uncapped — unlike GraphBackend::query_nodes, which is capped at 200). Used by the migration CLI to enumerate a source backend of arbitrary size.

pub fn list_edges(&self, limit: usize) -> Result<Vec<GraphEdge>>

List up to limit edges (uncapped).

Trait Implementations

impl GraphBackend for PgGraph

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.