Struct gotham_middleware_diesel::Repo

pub struct Repo<T>where
    T: R2D2Connection + 'static,{ /* private fields */ }

A database “repository”, for running database workloads. Manages a connection pool and running blocking tasks using tokio::task::spawn_blocking which does not block the tokio event loop.

#[derive(Queryable, Debug)]
pub struct User {
    pub id: i32,
    pub name: String,
}

type Repo = gotham_middleware_diesel::Repo<SqliteConnection>;
let repo = Repo::new(database_url);
let result = runtime
    .block_on(repo.run(|mut conn| {
        use schema::users::dsl::*;
        users.load::<User>(&mut conn)
    }))
    .unwrap();

Implementations

impl<T> Repo<T>where
    T: R2D2Connection + 'static,

pub fn new(database_url: &str) -> Self

Creates a repo with default connection pool settings. The default connection pool is r2d2::Builder::default()

type Repo = gotham_middleware_diesel::Repo<SqliteConnection>;
// Accepts a database URL, e.g. "postgres://username:password@host/database"
// for a postgres connection. Here we use an Sqlite in memory connection.
let repo = Repo::new(":memory:");

pub fn from_pool_builder(
    database_url: &str,
    builder: Builder<ConnectionManager<T>>
) -> Self

Creates a repo with a pool builder, allowing you to customize any connection pool configuration.

use core::time::Duration;
use diesel::r2d2::Pool;

type Repo = gotham_middleware_diesel::Repo<SqliteConnection>;
let database_url = ":memory:";
let repo = Repo::from_pool_builder(
    database_url,
    Pool::builder()
        .connection_timeout(Duration::from_secs(120))
        .max_size(100),
);

pub fn with_test_transactions(database_url: &str) -> Self

Creates a repo for use in tests, where queries are executed with an isolated test transaction and rolled back when the connection is dropped. This allows tests to run in parallel without impacting each other.

type Repo = gotham_middleware_diesel::Repo<SqliteConnection>;
let repo = Repo::with_test_transactions(":memory:");

pub async fn run<F, R, E>(&self, f: F) -> Result<R, E>where
    F: FnOnce(PooledConnection<ConnectionManager<T>>) -> Result<R, E> + Send + Unpin + 'static,
    T: Send + 'static,
    R: Send + 'static,
    E: Send + 'static,

Runs the given closure in a way that is safe for blocking IO to the database without blocking the tokio reactor. The closure will be passed a Connection from the pool to use.

Trait Implementations

impl<T> Clone for Repo<T>where
    T: R2D2Connection + 'static,

fn clone(&self) -> Repo<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> StateData for Repo<T>where
    T: R2D2Connection + 'static,