Trait 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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Poolable for MysqlConnection

Available on crate feature diesel_mysql_pool only.

type Manager = ConnectionManager<MysqlConnection>

type Error = Infallible

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

impl Poolable for PgConnection

Available on crate feature diesel_postgres_pool only.

type Manager = ConnectionManager<PgConnection>

type Error = Infallible

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

impl Poolable for SqliteConnection

Available on crate feature diesel_sqlite_pool only.

type Manager = ConnectionManager<SqliteConnection>

type Error = Infallible

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

impl Poolable for Client

Available on crate feature memcache_pool only.

type Manager = ConnectionManager

type Error = MemcacheError

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

impl Poolable for Client

Available on crate feature postgres_pool only.

type Manager = PostgresConnectionManager<NoTls>

type Error = Error

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

impl Poolable for Connection

Available on crate feature sqlite_pool only.

type Manager = SqliteConnectionManager

type Error = Infallible

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

Implementors