Trait rocket_sync_db_pools::Poolable

pub trait Poolable:
    Send
    + Sized
    + 'static {
    type Manager: ManageConnection<Connection = Self>;
    type Error: Debug;

    // Required method
    fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>;
}

Trait implemented by r2d2-based database adapters.

Provided Implementations

Implementations of Poolable are provided for the following types:

• diesel::MysqlConnection
• diesel::PgConnection
• diesel::SqliteConnection
• postgres::Client
• rusqlite::Connection
• memcache::Client

Implementation Guide

As an r2d2-compatible database (or other resource) adapter provider, implementing Poolable in your own library will enable Rocket users to consume your adapter with its built-in connection pooling support.

Example

Consider a library foo with the following types:

• foo::ConnectionManager, which implements r2d2::ManageConnection
• foo::Connection, the Connection associated type of foo::ConnectionManager
• foo::Error, errors resulting from manager instantiation

In order for Rocket to generate the required code to automatically provision a r2d2 connection pool into application state, the Poolable trait needs to be implemented for the connection type. The following example implements Poolable for foo::Connection:

use std::time::Duration;
use rocket::{Rocket, Build};
use rocket_sync_db_pools::{r2d2, Error, Config, Poolable, PoolResult};

impl Poolable for foo::Connection {
    type Manager = foo::ConnectionManager;
    type Error = foo::Error;

    fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self> {
        let config = Config::from(db_name, rocket)?;
        let manager = foo::ConnectionManager::new(&config.url).map_err(Error::Custom)?;
        Ok(r2d2::Pool::builder()
            .max_size(config.pool_size)
            .connection_timeout(Duration::from_secs(config.timeout as u64))
            .build(manager)?)
    }
}

In this example, ConnectionManager::new() method returns a foo::Error on failure. The Error enum consolidates this type, the r2d2::Error type that can result from r2d2::Pool::builder(), and the figment::Error type from database::Config::from().

In the event that a connection manager isn’t fallible (as is the case with Diesel’s r2d2 connection manager, for instance), the associated error type for the Poolable implementation should be std::convert::Infallible.

For more concrete example, consult Rocket’s existing implementations of Poolable.

Required Associated Types

type Manager: ManageConnection<Connection = Self>

The associated connection manager for the given connection type.

type Error: Debug

The associated error type in the event that constructing the connection manager and/or the connection pool fails.

Required Methods

fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>

Creates an r2d2 connection pool for Manager::Connection, returning the pool on success.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Poolable for MysqlConnection

type Manager = ConnectionManager<MysqlConnection>

type Error = Infallible

fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>

impl Poolable for PgConnection

type Manager = ConnectionManager<PgConnection>

type Error = Infallible

fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>

impl Poolable for SqliteConnection

type Manager = ConnectionManager<SqliteConnection>

type Error = Infallible

fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>

impl Poolable for Client

type Manager = ConnectionManager

type Error = MemcacheError

fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>

impl Poolable for Client

type Manager = PostgresConnectionManager<NoTls>

type Error = Error

fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>

impl Poolable for Connection

type Manager = SqliteConnectionManager

type Error = Infallible

fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>

Implementors