Struct PostgresIndexBackend 

pub struct PostgresIndexBackend {
    pool: Pool,
    table_name: String,
}

PostgreSQL-based index backend.

Uses deadpool_postgres::Pool for thread-safe connection pooling, enabling &self methods without interior mutability wrappers.

Fields

pool: Pool

Connection pool (thread-safe via internal Arc).

table_name: String

Table name for memories (validated against whitelist).

Implementations

impl PostgresIndexBackend

const POOL_MAX_SIZE: usize = 20usize

Maximum connections in pool (CHAOS-H1).

pub fn new(connection_url: &str, table_name: impl Into<String>) -> Result<Self>

Creates a new PostgreSQL index backend with TLS encryption (COMP-C3).

Uses rustls for TLS connections. The connection URL should include sslmode=require or sslmode=verify-full for production use.

Errors

Returns an error if the connection pool fails to initialize, if TLS configuration fails, or if the table name is not allowed.

fn root_cert_store() -> RootCertStore

Builds root certificate store for TLS.

fn parse_connection_url(url: &str) -> Result<Config>

Parses the connection URL into a tokio-postgres config (SEC-M2).

Validates the URL for security before parsing to prevent injection attacks.

fn host_to_string(h: &Host) -> String

Extracts host string from tokio-postgres Host.

fn build_pool_config(config: &Config) -> Config

Builds a deadpool config from tokio-postgres config.

Pool Exhaustion Protection (CHAOS-H1)

Configures connection pool with safety limits:

• Max 20 connections (prevents pool exhaustion)
• Runtime pool builder sets timeouts for wait/create/recycle

Statement Caching (DB-H4)

Statement caching is handled automatically by tokio-postgres connections. Each connection maintains its own prepared statement cache. The RecyclingMethod::Fast setting preserves connections (and their statement caches) across uses, providing implicit statement caching without additional configuration.

pub fn with_defaults() -> Result<Self>

Creates a backend with default settings.

Errors

Returns an error if the connection fails.

fn block_on<F, T>(&self, f: F) -> Result<T>

where F: Future<Output = Result<T>>,

Runs a blocking operation on the async pool.

fn run_migrations(&self) -> Result<()>

Runs migrations.

fn build_where_clause( filter: &SearchFilter, start_param: i32, ) -> (String, Vec<String>)

Builds WHERE clause for filters.

fn add_namespace_filter( filter: &SearchFilter, clauses: &mut Vec<String>, params: &mut Vec<String>, param_num: &mut i32, )

Adds namespace filter to WHERE clause.

fn add_domain_filter( filter: &SearchFilter, clauses: &mut Vec<String>, params: &mut Vec<String>, param_num: &mut i32, )

Adds domain filter to WHERE clause.

fn add_status_filter( filter: &SearchFilter, clauses: &mut Vec<String>, params: &mut Vec<String>, param_num: &mut i32, )

Adds status filter to WHERE clause.

fn add_project_filter( filter: &SearchFilter, clauses: &mut Vec<String>, params: &mut Vec<String>, param_num: &mut i32, )

fn add_branch_filter( filter: &SearchFilter, clauses: &mut Vec<String>, params: &mut Vec<String>, param_num: &mut i32, )

fn add_file_path_filter( filter: &SearchFilter, clauses: &mut Vec<String>, params: &mut Vec<String>, param_num: &mut i32, )

async fn index_async(&self, memory: &Memory) -> Result<()>

Async implementation of index operation.

async fn remove_async(&self, id: &MemoryId) -> Result<bool>

Async implementation of remove operation.

async fn search_async( &self, query: &str, filter: &SearchFilter, limit: usize, ) -> Result<Vec<(MemoryId, f32)>>

Async implementation of search operation.

async fn list_all_async( &self, filter: &SearchFilter, limit: usize, ) -> Result<Vec<(MemoryId, f32)>>

Async implementation of list_all operation.

async fn clear_async(&self) -> Result<()>

Async implementation of clear operation.

Trait Implementations

impl IndexBackend for PostgresIndexBackend

fn index(&self, memory: &Memory) -> Result<()>

Indexes a memory for full-text search.

fn remove(&self, id: &MemoryId) -> Result<bool>

Removes a memory from the index.

fn search( &self, query: &str, filter: &SearchFilter, limit: usize, ) -> Result<Vec<(MemoryId, f32)>>

Searches for memories matching a text query.

fn list_all( &self, filter: &SearchFilter, limit: usize, ) -> Result<Vec<(MemoryId, f32)>>

Lists all indexed memories, optionally filtered.

fn get_memory(&self, _id: &MemoryId) -> Result<Option<Memory>>

Retrieves a memory by ID.

fn clear(&self) -> Result<()>

Clears the entire index.

fn reindex(&self, memories: &[Memory]) -> Result<()>

Re-indexes all memories.

fn get_memories_batch(&self, ids: &[MemoryId]) -> Result<Vec<Option<Memory>>>

Retrieves multiple memories by their IDs in a single batch query.