Struct SqlxPgGraph 

pub struct SqlxPgGraph { /* private fields */ }

Async PostgreSQL graph backend over a shared sqlx::PgPool.

Every constructor applies the schema and runs pending migrations on connect, matching PgGraph. An optional table_prefix namespaces every backing table and index so several graphs can coexist in one database (identical semantics to PgGraph’s *_with_prefix constructors). The prefix is validated by is_identifier_safe before any SQL is emitted, keeping the identifier interpolation injection-safe.

Transaction exposure

pool plus append_edges_in_tx and remove_edges_for_node_in_tx let a caller coordinate a multi-table transaction (e.g. klr’s prune: delete chunks + vectors + edges atomically). Begin a tx on pool(), run cross-table DML, call the *_in_tx helpers with the same &mut PgConnection, then commit or rollback — mirroring PgVectorIndex::remove_in_tx.

Implementations

impl SqlxPgGraph

pub async fn from_pool(pool: PgPool) -> Result<Self>

Adopt a caller-owned PgPool, apply schema + migrations, and return a ready backend. Uses the default (empty) table prefix.

pub async fn from_pool_with_prefix(pool: PgPool, prefix: &str) -> Result<Self>

Like from_pool, but every table/index is namespaced under prefix. The prefix is validated by is_identifier_safe before any SQL runs; an unsafe value returns KernelError::Store.

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

Connect to url (libpq connstring / postgresql://…) with an 8-connection pool, apply schema + migrations, and return a ready backend. Uses the default (empty) table prefix.

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

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

pub fn pool(&self) -> &PgPool

The underlying connection pool.

Callers that need cross-table transactional consistency — e.g. pruning a law’s chunks plus their graph edges atomically — can pool().begin() and run their own DML, then call the append_edges_in_tx / remove_edges_for_node_in_tx helpers on the same &mut PgConnection.

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

Recorded graph schema version from {prefix}_meta, or 0 if unset.

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

Apply pending migrations up to GRAPH_SCHEMA_VERSION. No-op when current.

Runs in a single transaction with rollback on failure — matching pg.rs::migrate. Returns the new version.

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

Insert or update a node (upsert by id). Mirrors PgGraph::upsert_node.

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

Read a node by id, or None if absent.

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

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

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

Append a single edge (ON CONFLICT DO NOTHING). Mirrors PgGraph::append_edge.

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

All edges touching node_id (either endpoint). Mirrors PgGraph::edges_for_node.

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

Delete a single edge by id. Returns true if a row was removed.

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

Batch-insert edges in chunks of 5000, each chunk its own transaction (ON CONFLICT DO NOTHING per row). Mirrors PgGraph::append_edges. sqlx caches the prepared statement per connection, so the repeated INSERT reuses one parse/plan per chunk.

pub async fn append_edges_in_tx( &self, tx: &mut PgConnection, edges: &[GraphEdge], ) -> Result<()>

Append edges within a caller-provided transaction (commit is the caller’s responsibility — this method does not commit). Enables atomic cross-table writes: begin a tx on pool, write chunks / vectors / other relations, call this with the same &mut PgConnection, then commit(). A failure anywhere rolls back the whole set.

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

Directed, optionally relation-filtered edge lookup. Mirrors PgGraph::edges_for_node_dir. dir selects out / in / both; relation further restricts to a single relationship type when Some.

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

Aggregate neighbor weights from seed nodes, optionally direction- and relation-filtered. Mirrors PgGraph::neighbors_weighted: walks the source/target halves, uses = ANY($1) for the seed set, GROUP BY the opposite endpoint, and SUM(weight). Seeds themselves are excluded. Capped at 100 seeds.

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

Remove every edge touching node_id (either endpoint). Mirrors PgGraph::remove_edges_for_node.

pub async fn remove_edges_for_node_in_tx( &self, tx: &mut PgConnection, node_id: &str, ) -> Result<()>

Remove edges for node_id within a caller-provided transaction (no commit here). Same atomic-prune pattern as Self::append_edges_in_tx.

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

ILIKE substring search over (title, body, tags) for each whitespace-separated term (AND of terms). Mirrors PgGraph::search_nodes — extension-free vanilla PostgreSQL ILIKE with escaped, wrapped patterns.

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

Bidirectional BFS up to depth hops from start_id via a recursive CTE. Mirrors PgGraph::related_nodes. Returns distinct neighbor IDs (the start node is excluded), capped at 500.