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_pool_registry::sqlx::{self, PgPool};
use sqlx_pool_registry::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_pool_registry::sqlx::{self, postgres::PgPoolOptions};
use sqlx_pool_registry::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_pool_registry::sqlx::{self, PgPool};
use sqlx_pool_registry::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_pool_registry::sqlx::{self, postgres::PgPoolOptions};
use sqlx_pool_registry::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 primary(&self) -> &PgPool

Get the primary pool.

Unlike write, this method describes the physical pool topology rather than the operation being routed. Both methods return the same pool for DbPools.

pub fn replica(&self) -> Option<&PgPool>

Get the configured replica pool, if one exists.

This method does not fall back to the primary pool. Use read when a routable read pool is required.

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_pool_registry::sqlx::{self, PgPool};
use sqlx_pool_registry::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_pool_registry::sqlx::{self, PgPool};
use sqlx_pool_registry::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.