Struct Pool

Source

pub struct Pool<M: Manager> { /* private fields */ }

Implementations§

Source §

impl<M: Manager> Pool<M>

Source

pub async fn get(&self) -> Result<PoolRef<'_, M>, M::Error>

Return a PoolRef contains reference of SharedManagedPool<Manager> and an Option<Manager::Connection>.

The PoolRef should be dropped asap when you finish the use of it. Hold it in scope would prevent the connection from pushed back to pool.

Source

pub async fn get_owned(&self) -> Result<PoolRefOwned<M>, M::Error>

Return a PoolRefOwned contains a weak smart pointer of SharedManagedPool<Manager> and an Option<Manager::Connection>.

You can move PoolRefOwned to async blocks and across await point. But the performance is considerably worse than Pool::get.

Source

pub async fn run<'a, T, E, F, FF>(&'a self, f: F) -> Result<T, E>
where F: FnOnce(PoolRef<'a, M>) -> FF, FF: Future<Output = Result<T, E>> + Send + 'a, E: From<M::Error>, T: Send + 'static,

Run the pool with an async closure.

§example:

pool.run(|mut pool_ref| async {
    let connection = &mut *pool_ref;
    Ok(())
})

Source

pub fn pause(&self)

Pause the pool

these functionalities will stop:

get connection. Pool<Manager>::get() would eventually be timed out (If Manager::timeout is manually implemented with proper timeout function. *. Otherwise it will stuck forever in executor unless you cancel the future).
spawn of new connection.
default scheduled works (They would skip at least one iteration if the schedule time come across with the time period the pool is paused).
put back connection. (connection will be dropped instead.)

Source

pub fn resume(&self)

restart the pool.

Source

pub fn running(&self) -> bool

check if the pool is running.

Source

pub fn clear(&self)

Clear the pool.

All pending connections will also be destroyed.

Spawned count is not reset to 0 so new connections can’t fill the pool until all outgoing PoolRef are dropped.

All PoolRef' and 'PoolRefOwned outside of pool before the clear happen would be destroyed when trying to return it’s connection to pool.

Source

pub async fn init(&self) -> Result<(), M::Error>

manually initialize pool. this is usually called when the Pool is built with build_uninitialized This is useful when you want to make an empty Pool and initialize it later.

§example:

#[macro_use]
extern crate lazy_static;

use tokio_postgres_tang::{Pool, PostgresManager, Builder};
use tokio_postgres::NoTls;

lazy_static! {
   static ref POOL: Pool<PostgresManager<NoTls>> = Builder::new()
        .always_check(false)
        .idle_timeout(None)
        .max_lifetime(None)
        .min_idle(24)
        .max_size(24)
        .build_uninitialized(
            PostgresManager::new_from_stringlike("postgres://postgres:123@localhost/test", NoTls)
                .expect("can't make postgres manager")
        );
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    POOL.init().await.expect("Failed to initialize postgres pool");
    Ok(())
}

Source

pub fn set_max_size(&self, size: usize)

Change the max size of pool. This operation could result in some reallocation of PoolInner and impact the performance. (Pool<Manager>::clear() will recalibrate the pool with a capacity of current max/min pool size)

No actual check is used for new max_size. Be ware not to pass a size smaller than min_idle.

Source