Struct PgPool 

pub struct PgPool(/* private fields */);

The shared PostgreSQL connection pool

Example

use diesel_rocket_pg::PgPool;
use diesel::prelude::*;
use rocket::State;
use serde::Serialize;

#[macro_use] extern crate rocket;

diesel::table! {
    user (id) {
        id -> Int4,
        email -> Varchar,
        password -> Varchar,
    }
}

#[derive(Debug, Queryable, Serialize)]
pub struct AuthUser {
    pub id: i32,
    pub email: String,
    pub password: String,
}

#[get("/user/<mail>")]
async fn get_user(mail: String, pool: &State<PgPool>) -> String {
    let result = pool.run(move |conn| {

        user::dsl::user.filter(
            user::dsl::email.eq(mail)
        ).first::<AuthUser>(conn).ok()
    }).await.unwrap();

    if let Some(u) = result {
        format!("{:?}", u)
    } else {
        "User not found!".to_string()
    }
}

#[launch]
fn rocket() -> _ {
    let uri = "postgres://user:password123@localhost:5432/database";
    let pool = PgPool::create(uri).unwrap();

    rocket::build().manage(pool).mount("/", routes![get_user])
}

Implementations

impl PgPool

pub fn create<T: Into<String>>(uri: T) -> Result<Self>

Creates a new connection pool

Arguments

• uri - The postgresql connection string

Example

use diesel_rocket_pg::PgPool;

fn main() {
    let uri = "postgres://user:password123@localhost:5432/database";
    let _pool = PgPool::create(uri).unwrap();
    /* ... */
}

pub fn create_custom<T: Into<String>>( uri: T, builder: Builder<ConnectionManager<PgConnection>>, ) -> Result<Self>

Creates a new connection pool with a custom r2d2 configuration

Arguments

• uri - The postgresql connection string
• builder - A r2d2::Builder with a custom configuration

Example

use diesel_rocket_pg::PgPool;
use r2d2::Pool;

fn main() {
    let uri = "postgres://user:password123@localhost:5432/database";
    let builder = Pool::builder()
        .max_size(50)
        .min_idle(None)
        .max_lifetime(Some(Duration::from_secs(5)));
    let _pool = PgPool::create_custom(uri, builder).unwrap();
    /* ... */
}

pub async fn run<F, R>(&self, func: F) -> Result<R>

where F: FnOnce(&mut PgConn) -> R + Send + 'static, R: Send + 'static,

Executes a diesel query in a tokio task

Example

#[get("/user/<mail>")]
async fn get_user(mail: String, pool: &State<PgPool>) -> AuthUser {
    let auth_user = pool.run(move |conn| {
        user::dsl::user.filter(
            user::dsl::email.eq(mail)
        ).first::<AuthUser>(conn).unwrap()
    }).await.unwrap();

    auth_user
}

Trait Implementations

impl Clone for PgPool

fn clone(&self) -> PgPool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PgPool

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

Formats the value using the given formatter.