Struct PgStoreConfig 

pub struct PgStoreConfig { /* private fields */ }

How a PgStores opens and shapes its connection pool.

The defaults are meant for a service that handles turns: a pool small enough that PostgreSQL is not the thing that falls over first, an acquire timeout short enough that a saturated pool surfaces as Unavailable instead of a hung request, and connections recycled often enough that a rolling database upgrade drains cleanly.

use std::time::Duration;

use turnframe_store_postgres::PgStoreConfig;

let config = PgStoreConfig::new()
    .max_connections(16)
    .statement_timeout(Duration::from_secs(5))
    .schema("turnframe")?;
assert_eq!(config.schema_name(), Some("turnframe"));

Implementations

impl PgStoreConfig

pub const DEFAULT_MAX_CONNECTIONS: u32 = 10

Upper bound on pooled connections. PostgreSQL serves every connection with a backend process, so this is a budget shared with every other service on the same cluster.

pub const DEFAULT_MIN_CONNECTIONS: u32 = 1

Connections kept open while idle, so a quiet period does not make the next turn pay for a handshake.

pub const DEFAULT_ACQUIRE_TIMEOUT: Duration

How long a caller waits for a connection before the store reports Unavailable.

pub const DEFAULT_IDLE_TIMEOUT: Duration

How long an unused connection is kept.

pub const DEFAULT_MAX_LIFETIME: Duration

How long any connection is kept, however busy. Recycling bounds the damage of a leaked server-side state and lets a rolling upgrade drain.

pub fn new() -> Self

The defaults described above, on the public schema, with no statement timeout of the adapter’s own.

pub fn max_connections(self, connections: u32) -> Self

Sets the maximum number of pooled connections.

pub fn min_connections(self, connections: u32) -> Self

Sets the number of connections kept open while idle.

pub fn acquire_timeout(self, timeout: Duration) -> Self

Sets how long a caller waits for a connection from the pool.

This is not a statement timeout: it bounds the wait for a connection, not the work done once one is held. See Self::statement_timeout.

pub fn idle_timeout(self, timeout: Option<Duration>) -> Self

Sets how long an unused connection is kept; None keeps it forever.

pub fn max_lifetime(self, lifetime: Option<Duration>) -> Self

Sets how long any connection is kept; None keeps it forever.

pub fn statement_timeout(self, timeout: Duration) -> Self

Sets statement_timeout on every connection this pool opens.

The advisory

A statement timeout is the only thing that bounds a query the database decides to run slowly, and without one a single lock wait can hold a pooled connection until the pool is empty and every turn fails. Set one.

Set it with these three consequences in mind.

It cancels statements, not transactions. PostgreSQL raises query_canceled on the statement that ran too long; this adapter reports Timeout and abandons the transaction, so a cancelled statement inside CommitStore::commit discards the whole bundle. That is the correct outcome — a partially written bundle is an invariant violation — but it means the timeout must be generous enough for the largest bundle a turn produces, not for the median statement.

Timeout is not a signal to retry. The contract reads it as “the write may have landed”: the caller re-reads and resumes by idempotency key. A timeout set so tight that healthy commits trip it turns every one of them into a recovery.

The outbox claim is the exception to keep short. claim_due takes row locks with SKIP LOCKED, so it never waits on another dispatcher; if it is slow, something else is wrong and cutting it off is right.

A few seconds suits a service handling turns. Leave it None to inherit whatever the role or the server sets, which is the better choice when the database is administered separately.

pub fn inherit_statement_timeout(self) -> Self

Clears the adapter’s statement timeout, inheriting the server’s.

pub fn schema(self, schema: impl Into<String>) -> Result<Self, ConfigError>

Puts every table in a dedicated schema instead of the connection’s default search_path.

PgStores::migrate creates the schema when it is missing, so pointing a fresh deployment at an empty database is one call. Tests use it to give each run a private namespace inside one database.

Errors

• ConfigError::InvalidSchemaName when the name is not a plain unquoted PostgreSQL identifier. The name is interpolated into CREATE SCHEMA and into search_path, neither of which can take a bind parameter, so it is validated here rather than escaped later.

pub fn schema_name(&self) -> Option<&str>

The configured schema, if any.

pub fn statement_timeout_value(&self) -> Option<Duration>

The configured statement timeout, if any.

pub fn connection_bounds(&self) -> (u32, u32)

The configured pool bounds, as (min, max).

Trait Implementations

impl Clone for PgStoreConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PgStoreConfig

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

Formats the value using the given formatter.

impl Default for PgStoreConfig

fn default() -> Self

Returns the “default value” for a type.

impl Display for PgStoreConfig

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

Names the settings, never a connection string: this value is safe to log.

impl Eq for PgStoreConfig

impl PartialEq for PgStoreConfig

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for PgStoreConfig