I found that when the pool is dropped with some connections remain in lifetime, ALL idle connections will not drop until the connection checked out is dropped. Changing pool field in PooledConnection to Weak<SharedPool<M>> can fix this problem.

For example:

use std::{
    sync::RwLock,
    thread::sleep,
    time::{Duration, Instant},
};

use r2d2::{ManageConnection, Pool};

struct FooConnection;

impl FooConnection {
    fn new() -> FooConnection {
        println!("connection");
        FooConnection
    }
}

impl Drop for FooConnection {
    fn drop(&mut self) {
        println!("drop connection, t: {:?}", Instant::now());
    }
}

struct FooManager;

impl ManageConnection for FooManager {
    type Connection = FooConnection;
    type Error = std::io::Error;

    fn connect(&self) -> Result<FooConnection, Self::Error> {
        Ok(FooConnection::new())
    }

    fn is_valid(&self, _: &mut FooConnection) -> Result<(), Self::Error> {
        Ok(())
    }

    fn has_broken(&self, _: &mut FooConnection) -> bool {
        false
    }
}

static POOL: RwLock<Option<Pool<FooManager>>> = RwLock::new(None);

fn main() -> anyhow::Result<()> {
    let pool = r2d2::Pool::builder()
        .min_idle(Some(2))
        .max_size(4)
        .build(FooManager)?;

    *POOL.write().unwrap() = Some(pool);

    std::thread::spawn(|| {
        let _conn = POOL.read().unwrap().as_ref().unwrap().get().unwrap();
        sleep(Duration::from_secs(5));
        // <- all connections dropped here before our change

        // <- only `_conn` dropped here after our change
        // <- other idle connections will dropped eralier.
    });
    sleep(Duration::from_micros(5000));

    {
        let _ = POOL.write().unwrap().take();
        // <- all IDLE connections will dropped here after our change
    }

    sleep(Duration::from_secs(10));
    Ok(())
}

Hi, I'm creating a DbPoolConnection by using

let manager = ConnectionManager::<PgConnection>::new(self.database_url());
r2d2::Pool::builder().build(manager).expect("Failed to create pool.")

This however fails after a couple of seconds if the script is started with proxychains cargo run --release. Is there's a way to use the pool behind proxychains?

In some cases, specific initialization/cleanup needs to be done around managed connections when fetching them from the pool and releasing them to the pool.

e.g.:

1. https://github.com/diesel-rs/diesel/issues/3252 with solution suggested here
2. Attempting to close any open transaction on release-to-pool (solution where transactions are generally managed with RAII as suggested here have the issues described here).

Currently this requires having custom wrappers around PooledConnection and Pool, which prevents from always using r2d2 directly (and requires reimplementing a whole bunch of traits on the wrappers).

Something that would remove this need would be to add on_take_from_pool and on_release_to_pool hooks to CustomizeConnection (or another trait if we want backwards-compat.) and/or ManageConnection.

That would solve 1. by allowing users to automatically open a test transaction on_take_from_pool and rolling it back on_release_to_pool (on_release_to_pool would have to be called before is_valid).

That would solve 2. by allowing users (and/or implementors of ManageConnection) to automatically attempt closing any open transactions on_release_to_pool in any way they see fit.

I would imagine the overhead of the CustomizeConnection one to be really-not-too-high despite the dynamic dispatch because that would be absolutely negligible compared with what we actually do with the connection. (And obviously the overhead of the ManageConnection one would be zero because the statically dispatched no-op would be optimized out.)

Would that be something that makes sense and could potentially be added to r2d2?

Thanks,

Looking at the documentation of Builder doesn't currently help understand r2d2's behaviour, when trying to answer questions like "how do I make sure there's always at least one connection at any given instant".

This is related to ivanceras/r2d2-sqlite#39: currently ::memory is basically broken (at least in the sense of pooling connection, every connection from the pool is independent).

It's possible that sqlite's mode=memory could be used to fix the issue (at least in part, it has limitations still) but sqlite will automatically delete and release the database if it has no connections open, so for this to work properly there needs to be a way to configure the pool such that once the first connection has been created there is always at least one connection in the pool at any instant.