Struct PostgresIncrementalBackend 

pub struct PostgresIncrementalBackend { /* private fields */ }

PostgreSQL storage backend for the incremental update system.

Uses deadpool-postgres for connection pooling and tokio-postgres for async query execution. All queries use prepared statements for optimal query plan caching.

Connection Management

The backend manages a pool of connections. The default pool size is 16 connections, configurable via the connection URL or pool configuration.

Thread Safety

This type is Send + Sync and can be shared across async tasks.

Implementations

impl PostgresIncrementalBackend

pub async fn new(database_url: &str) -> Result<Self, StorageError>

Creates a new Postgres backend connected to the given database URL.

The URL should be a standard PostgreSQL connection string: postgresql://user:password@host:port/database

Arguments

• database_url - PostgreSQL connection string.

Errors

Returns StorageError::Backend if the connection pool cannot be created.

Examples

let backend = PostgresIncrementalBackend::new("postgresql://localhost/thread").await?;

pub fn from_pool(pool: Pool) -> Self

Creates a new Postgres backend from an existing connection pool.

Useful for testing or when you want to configure the pool externally.

Arguments

• pool - A pre-configured deadpool-postgres connection pool.

pub async fn run_migrations(&self) -> Result<(), StorageError>

Runs the schema migration to create required tables and indexes.

This is idempotent: running it multiple times has no effect if the schema already exists (uses CREATE TABLE IF NOT EXISTS).

Errors

Returns StorageError::Backend if the migration SQL fails to execute.

pub async fn save_edges_batch( &self, edges: &[DependencyEdge], ) -> Result<(), StorageError>

Saves multiple dependency edges in a single transaction.

This is more efficient than calling save_edge individually for each edge, as it reduces round-trips to the database.

Arguments

• edges - Slice of dependency edges to persist.

Errors

Returns StorageError::Backend if the transaction fails. The transaction is rolled back on any error.

Trait Implementations

impl Debug for PostgresIncrementalBackend

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl StorageBackend for PostgresIncrementalBackend

fn save_fingerprint<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, file_path: &'life1 Path, fingerprint: &'life2 AnalysisDefFingerprint, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Persists a fingerprint for the given file path.

fn load_fingerprint<'life0, 'life1, 'async_trait>( &'life0 self, file_path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Option<AnalysisDefFingerprint>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads the fingerprint for a file, if one exists.

fn delete_fingerprint<'life0, 'life1, 'async_trait>( &'life0 self, file_path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Deletes the fingerprint for a file.

fn save_edge<'life0, 'life1, 'async_trait>( &'life0 self, edge: &'life1 DependencyEdge, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persists a dependency edge.

fn load_edges_from<'life0, 'life1, 'async_trait>( &'life0 self, file_path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<DependencyEdge>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads all dependency edges originating from a file.

fn load_edges_to<'life0, 'life1, 'async_trait>( &'life0 self, file_path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<DependencyEdge>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads all dependency edges targeting a file.

fn delete_edges_for<'life0, 'life1, 'async_trait>( &'life0 self, file_path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<usize, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Deletes all dependency edges involving a file (as source or target).

fn load_full_graph<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<DependencyGraph, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads the complete dependency graph from storage.

fn save_full_graph<'life0, 'life1, 'async_trait>( &'life0 self, graph: &'life1 DependencyGraph, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persists the complete dependency graph to storage.

fn name(&self) -> &'static str

Returns the name of this storage backend for observability.