#async #pool #r2d2

deadpool-r2d2

Dead simple async pool for r2d2 managers

3 releases (breaking)

0.3.0 Sep 26, 2023
0.2.0 Oct 26, 2021
0.1.0 Oct 18, 2021

#1846 in Database interfaces

Download history 14/week @ 2023-10-14 2/week @ 2023-10-21 19/week @ 2023-10-28 3/week @ 2023-11-04 10/week @ 2023-11-11 12/week @ 2023-11-18 10/week @ 2023-11-25 18/week @ 2023-12-02 6/week @ 2023-12-09 9/week @ 2023-12-16 17/week @ 2023-12-23 1/week @ 2023-12-30 8/week @ 2024-01-06 14/week @ 2024-01-13 25/week @ 2024-01-20 20/week @ 2024-01-27

67 downloads per month

MIT/Apache

90KB
1.5K SLoC

Deadpool for R2D2 Managers Latest Version Unsafe forbidden Rust 1.63+

Deadpool is a dead simple async pool for connections and objects of any type.

This crate implements a deadpool manager for r2d2 managers.

Features

Feature Description Extra dependencies Default
rt_tokio_1 Enable support for tokio crate deadpool/rt_tokio_1 yes
rt_async-std_1 Enable support for async-std crate deadpool/rt_async-std_1 no
serde Enable support for serde crate deadpool/serde no
tracing Enable support for tracing by propagating Spans in the interact() calls. Enable this if you use the tracing crate and you want to get useful traces from within interact() calls. deadpool-sync/tracing, tracing no

Example

use std::env;

use deadpool_r2d2::Runtime;
use r2d2_postgres::postgres::Error as PgError;

type PgManager = deadpool_r2d2::Manager<
    r2d2_postgres::PostgresConnectionManager<r2d2_postgres::postgres::NoTls>,
>;
type PgPool = deadpool_r2d2::Pool<PgManager>;

fn create_pool(max_size: usize) -> PgPool {
    let mut pg_config = r2d2_postgres::postgres::Config::new();
    pg_config.host(&env::var("PG__HOST").unwrap());
    pg_config.user(&env::var("PG__USER").unwrap());
    pg_config.password(&env::var("PG__PASSWORD").unwrap());
    pg_config.dbname(&env::var("PG__DBNAME").unwrap());
    let r2d2_manager =
        r2d2_postgres::PostgresConnectionManager::new(pg_config, r2d2_postgres::postgres::NoTls);
    let manager = PgManager::new(r2d2_manager, Runtime::Tokio1);
    let pool = PgPool::builder(manager)
        .max_size(max_size)
        .build()
        .unwrap();
    pool
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let pool = create_pool(2);
    let client = pool.get().await.unwrap();
    let answer: i32 = client
        .interact(|client| client.query_one("SELECT 42", &[]).map(|row| row.get(0)))
        .await??;
    assert_eq!(answer, 42);
    Ok(())
}

License

Licensed under either of

at your option.

Dependencies

~3–16MB
~173K SLoC