Struct rocket_sync_db_pools::example::ExampleDb

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

Example of code generated by the #[database] attribute.

This implementation of ExampleDb was generated by:

use rocket_sync_db_pools::{database, diesel};

#[database("example")]
pub struct ExampleDb(diesel::SqliteConnection);

Implementations

impl ExampleDb

pub fn fairing() -> impl Fairing

Returns a fairing that initializes the database connection pool associated with Self.

The fairing must be attached before Self can be used as a request guard.

Example

use rocket_sync_db_pools::diesel;

#[database("my_db")]
struct MyConn(diesel::SqliteConnection);

#[launch]
fn rocket() -> _ {
    rocket::build().attach(MyConn::fairing())
}

pub fn pool<P: Phase>( __rocket: &Rocket<P> ) -> Option<&ConnectionPool<Self, SqliteConnection>>

Returns an opaque type that represents the connection pool backing connections of type Self as long as the fairing returned by Self::fairing() is attached and has run on __rocket.

The returned pool is Clone. Values of type Self can be retrieved from the pool by calling pool.get().await which has the same signature and semantics as Self::get_one().

Example

use rocket::tokio::{task, time};
use rocket::fairing::AdHoc;
use rocket_sync_db_pools::diesel;

#[database("my_db")]
struct MyConn(diesel::SqliteConnection);

#[launch]
fn rocket() -> _ {
    rocket::build()
        .attach(MyConn::fairing())
        .attach(AdHoc::try_on_ignite("Background DB", |rocket| async {
            let pool = match MyConn::pool(&rocket) {
                Some(pool) => pool.clone(),
                None => return Err(rocket)
            };

            // Start a background task that runs some database
            // operation every 10 seconds. If a connection isn't
            // available, retries 10 + timeout seconds later.
            tokio::task::spawn(async move {
                loop {
                    time::sleep(time::Duration::from_secs(10)).await;
                    if let Some(conn) = pool.get().await {
                        conn.run(|c| { /* perform db ops */ }).await;
                    }
                }
            });

            Ok(rocket)
        }))
}

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

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

Runs the provided function __f in an async-safe blocking thread. The function is supplied with a mutable reference to the raw connection (a value of type &mut Self.0). .awaiting the return value of this function yields the value returned by __f.

Example

use rocket_sync_db_pools::diesel;

#[database("my_db")]
struct MyConn(diesel::SqliteConnection);

#[get("/")]
async fn f(conn: MyConn) {
    // The type annotation is illustrative and isn't required.
    let result = conn.run(|c: &mut diesel::SqliteConnection| {
        // Use `c`.
    }).await;
}

pub async fn get_one<P: Phase>(__rocket: &Rocket<P>) -> Option<Self>

Retrieves a connection of type Self from the rocket instance. Returns Some as long as Self::fairing() has been attached and there is a connection available within at most timeout seconds.

Trait Implementations

impl<'r> FromRequest<'r> for ExampleDb

Retrieves a connection from the database pool or fails with a Status::ServiceUnavailable if doing so times out.

type Error = ()

The associated error to be returned if derivation fails.

fn from_request<'life0, 'async_trait>( __r: &'r Request<'life0> ) -> Pin<Box<dyn Future<Output = Outcome<Self, ()>> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

Derives an instance of Self from the incoming request metadata.

impl Sentinel for ExampleDb

fn abort(__r: &Rocket<Ignite>) -> bool

Returns true if launch should be aborted and false otherwise.