Struct DbPools 

pub struct DbPools { /* private fields */ }

Database pool abstraction supporting read replicas.

Wraps primary and optional replica pools, providing methods for explicit read/write routing while maintaining backwards compatibility through Deref<Target = PgPool>.

Examples

Single Pool Configuration

use sqlx::PgPool;
use sqlx_pool_router::DbPools;

let pool = PgPool::connect("postgresql://localhost/db").await?;
let pools = DbPools::new(pool);

// Both read() and write() return the same pool
assert!(!pools.has_replica());

Primary/Replica Configuration

use sqlx::postgres::PgPoolOptions;
use sqlx_pool_router::DbPools;

let primary = PgPoolOptions::new()
    .max_connections(5)
    .connect("postgresql://primary/db")
    .await?;

let replica = PgPoolOptions::new()
    .max_connections(10)
    .connect("postgresql://replica/db")
    .await?;

let pools = DbPools::with_replica(primary, replica);
assert!(pools.has_replica());

Implementations

impl DbPools

pub fn new(primary: PgPool) -> Self

Create a new DbPools with only a primary pool.

This is useful for development or when you don’t have a read replica configured. All read and write operations will route to the primary pool.

Example

use sqlx::PgPool;
use sqlx_pool_router::DbPools;

let pool = PgPool::connect("postgresql://localhost/db").await?;
let pools = DbPools::new(pool);

pub fn with_replica(primary: PgPool, replica: PgPool) -> Self

Create a new DbPools with primary and replica pools.

Read operations will route to the replica pool for load distribution, while write operations always use the primary pool.

Example

use sqlx::postgres::PgPoolOptions;
use sqlx_pool_router::DbPools;

let primary = PgPoolOptions::new()
    .max_connections(5)
    .connect("postgresql://primary/db")
    .await?;

let replica = PgPoolOptions::new()
    .max_connections(10)
    .connect("postgresql://replica/db")
    .await?;

let pools = DbPools::with_replica(primary, replica);

pub fn has_replica(&self) -> bool

Check if a replica pool is configured.

Returns true if a replica pool was provided via with_replica.

Example

use sqlx::PgPool;
use sqlx_pool_router::DbPools;

let pool = PgPool::connect("postgresql://localhost/db").await?;
let pools = DbPools::new(pool);
assert!(!pools.has_replica());

pub async fn close(&self)

Close all database connections.

Closes both primary and replica pools (if configured).

Example

use sqlx::PgPool;
use sqlx_pool_router::DbPools;

let pool = PgPool::connect("postgresql://localhost/db").await?;
let pools = DbPools::new(pool);
pools.close().await;

Trait Implementations

impl Clone for DbPools

fn clone(&self) -> DbPools

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DbPools

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

Formats the value using the given formatter.

impl Deref for DbPools

Dereferences to the primary pool.

This allows natural usage like &*pools when you need a &PgPool. For explicit routing, use .read() or .write() methods.

type Target = Pool<Postgres>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl PoolProvider for DbPools

fn read(&self) -> &PgPool

Get a pool for read operations.

fn write(&self) -> &PgPool

Get a pool for write operations.