Struct orma_mobc::PgConnectionManager

pub struct PgConnectionManager<Tls> { /* fields omitted */ }

A mobc::Manager for orma::Connections. This crate is a strict derivation of mobc-postgres

Example

use mobc::Pool;
use orma_mobc::PgConnectionManager;
use orma::{Config, NoTls};
use std::time::Instant;
use std::str::FromStr;
#[tokio::main]
async fn main() {
    let config = Config::from_str("postgres://user:passwd@localhost:5432").unwrap();
    let manager = PgConnectionManager::new(config, NoTls);
    let pool = Pool::builder().max_open(20).build(manager);
    const MAX: usize = 5000;

    let now = Instant::now();
    let (tx, mut rx) = tokio::sync::mpsc::channel::<usize>(16);
    for i in 0..MAX {
        let pool = pool.clone();
        let mut tx_c = tx.clone();
        tokio::spawn(async move {
            let connection = pool.get().await.unwrap();
            let rows = connection.query("SELECT 1 + 2", &[]).await.unwrap();
            let value: i32 = rows[0].get(0);
            assert_eq!(value, 3);
            tx_c.send(i).await.unwrap();
        });
    }
    for _ in 0..MAX {
        rx.recv().await.unwrap();
    }

    println!("cost: {:?}", now.elapsed());
}

Methods

impl<Tls> PgConnectionManager<Tls>

pub fn new(config: Config, tls: Tls) -> Self

Trait Implementations

impl<Tls> Manager for PgConnectionManager<Tls> where
    Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static,
    <Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync,
    <Tls as MakeTlsConnect<Socket>>::TlsConnect: Send,
    <<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send, 

type Connection = Connection

The connection type this manager deals with.

type Error = DbError

The error type returned by Connections.

fn connect<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Self::Connection, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Attempts to create a new connection.

fn check<'life0, 'async_trait>(
    &'life0 self,
    conn: Self::Connection
) -> Pin<Box<dyn Future<Output = Result<Self::Connection, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Determines if the connection is still connected to the database.

fn spawn_task<T>(&self, task: T) where
    T: Future + Send + 'static,
    <T as Future>::Output: Send,
    <T as Future>::Output: 'static, 

Spawns a new asynchronous task.