Struct Pool 

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

A connection pool for database connections.

The pool manages a collection of connections, reusing them across requests to avoid the overhead of establishing new connections.

Type Parameters

• C: The connection type, must implement Connection

Cancellation

Pool operations respect cancellation via the Cx context:

• acquire will return early if cancellation is requested
• Connections are properly cleaned up on cancellation

Implementations

impl<C: Connection> Pool<C>

pub fn new(config: PoolConfig) -> Self

Create a new connection pool with the given configuration.

pub fn config(&self) -> PoolConfig

Get the pool configuration.

pub fn stats(&self) -> PoolStats

Get the current pool statistics.

pub fn at_capacity(&self) -> bool

Check if the pool is at capacity.

pub fn is_closed(&self) -> bool

Check if the pool has been closed.

pub async fn acquire<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 pool.

This method will:

1. Return an idle connection if one is available
2. Create a new connection if below capacity
3. Wait for a connection to become available (up to timeout)

Errors

Returns an error if:

• The pool is closed
• The acquire timeout is exceeded
• Cancellation is requested via the Cx context
• Connection validation fails (if test_on_checkout is enabled)

pub fn clear_idle(&self)

Close all currently idle connections.

If the pool mutex is poisoned, this logs an error and leaves the idle inventory untouched because its accounting cannot be mutated safely.

pub fn close(&self)

Close the pool, preventing new connections and closing all idle connections.

If the pool mutex is poisoned, this logs an error but still wakes waiters.

pub async fn close_and_drain(&self, cx: &Cx) -> Outcome<(), Error>

Close the pool and wait for every pool-owned active connection to retire.

Closing admission and removing idle inventory happen synchronously before this method first yields. Blocked acquirers are woken and observe PoolErrorKind::Closed. Connections already checked out are closed when returned; this future completes only after their explicit close_for_pool hooks finish and the active count reaches zero.

The wait is cancellation- and deadline-aware through cx. Cancellation returns Outcome::Cancelled without reopening the pool: closed remains a one-way lifecycle transition, and a later caller may resume draining. Dropping this future has the same persistent-close property.

Multiple concurrent drainers are supported by the pool’s one-shot drain latch. Since pool closure is irreversible, there is no reopen generation whose notification could be confused with this drain cycle.

Driver teardown failures are sticky and fail closed: the pool still retires every accounted resource, but this and every later drainer returns Outcome::Err after the active count reaches zero.

A connection removed with PooledConnection::detach is caller-owned and is no longer part of pool accounting, so it is outside this drain guarantee.

pub fn idle_count(&self) -> usize

Get the number of idle connections.

pub fn active_count(&self) -> usize

Get the number of active connections.

pub fn total_count(&self) -> usize

Get the total number of connections.

Trait Implementations

impl<C: Connection> Drop for Pool<C>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.