Struct ReplicaPool 

pub struct ReplicaPool<C: Connection> { /* private fields */ }

A pool that routes reads to replicas and writes to a primary.

Example

let primary = Pool::new(primary_config);
let replica1 = Pool::new(replica1_config);
let replica2 = Pool::new(replica2_config);

let pool = ReplicaPool::new(primary, vec![replica1, replica2]);

// Reads go to replicas (factory provided at acquire time)
let conn = pool.acquire_read(&cx, || connect_replica()).await?;

// Writes go to primary
let conn = pool.acquire_write(&cx, || connect_primary()).await?;

Implementations

impl<C: Connection> ReplicaPool<C>

pub fn new(primary: Pool<C>, replicas: Vec<Pool<C>>) -> Self

Create a new replica pool with round-robin strategy.

pub fn with_strategy( primary: Pool<C>, replicas: Vec<Pool<C>>, strategy: ReplicaStrategy, ) -> Self

Create a new replica pool with a specific strategy.

pub async fn acquire_read<F, Fut>( &self, cx: &Cx, factory: F, ) -> Outcome<PooledConnection<C>, Error>

where F: Fn() -> Fut, Fut: Future<Output = Outcome<C, Error>>,

Acquire a connection for read operations.

If replicas are available, selects one based on the configured strategy. Falls back to the primary if no replicas are configured.

pub async fn acquire_write<F, Fut>( &self, cx: &Cx, factory: F, ) -> Outcome<PooledConnection<C>, Error>

where F: Fn() -> Fut, Fut: Future<Output = Outcome<C, Error>>,

Acquire a connection for write operations (always uses primary).

pub async fn acquire_primary<F, Fut>( &self, cx: &Cx, factory: F, ) -> Outcome<PooledConnection<C>, Error>

where F: Fn() -> Fut, Fut: Future<Output = Outcome<C, Error>>,

Acquire a connection from the primary (for read-after-write consistency).

pub fn primary(&self) -> &Pool<C>

Get a reference to the primary pool.

pub fn replicas(&self) -> &[Pool<C>]

Get the replica pools.

pub fn replica_count(&self) -> usize

Get the number of replicas.

pub fn strategy(&self) -> ReplicaStrategy

Get the current strategy.

Trait Implementations

impl<C: Connection> Debug for ReplicaPool<C>

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

Formats the value using the given formatter.