Do some sketchyness to make Connection Send

Author: sfackler

src/lib.rs

@@ -96,9 +96,11 @@ impl StatementPoolingManager {
 
 impl r2d2::PoolManager<Connection, Error> for StatementPoolingManager {
     fn connect(&self) -> Result<Connection, Error> {
+        let cache = box RefCell::new(LruCache::<String, PostgresStatement<'static>>::new(
+                self.config.statement_pool_size));
         Ok(Connection {
             conn: box try!(self.manager.connect()),
-            stmts: RefCell::new(LruCache::new(self.config.statement_pool_size))
+            stmts: unsafe { mem::transmute(cache) },
         })
     }
 
@@ -133,21 +135,26 @@ pub trait GenericConnection {
 
 pub struct Connection {
     conn: Box<PostgresConnection>,
-    stmts: RefCell<LruCache<String, Rc<PostgresStatement<'static>>>>,
+    stmts: *mut (),
 }
 
-#[unsafe_destructor]
 impl Drop for Connection {
-    // Just make sure that all the statements drop before the connection
     fn drop(&mut self) {
-        self.stmts.borrow_mut().change_capacity(0);
+        let _: Box<RefCell<LruCache<String, Rc<PostgresStatement<'static>>>>> =
+            unsafe { mem::transmute(self.stmts) };
+    }
+}
+
+impl Connection {
+    fn get_cache(&self) -> &RefCell<LruCache<String, Rc<PostgresStatement<'static>>>> {
+        unsafe { mem::transmute(self.stmts) }
     }
 }
 
 impl GenericConnection for Connection {
     fn prepare<'a>(&'a self, query: &str) -> PostgresResult<Rc<PostgresStatement<'a>>> {
         let query = query.into_string();
-        let mut stmts = self.stmts.borrow_mut();
+        let mut stmts = self.get_cache().borrow_mut();
 
         if let Some(stmt) = stmts.get(&query) {
             return Ok(unsafe { mem::transmute(stmt.clone()) });
@@ -183,7 +190,7 @@ pub struct Transaction<'a> {
 impl<'a> GenericConnection for Transaction<'a> {
     fn prepare<'a>(&'a self, query: &str) -> PostgresResult<Rc<PostgresStatement<'a>>> {
         let query = query.into_string();
-        let mut stmts = self.conn.stmts.borrow_mut();
+        let mut stmts = self.conn.get_cache().borrow_mut();
 
         if let Some(stmt) = stmts.get(&query) {
             return Ok(unsafe { mem::transmute(stmt.clone()) });

tests/test.rs

@@ -59,16 +59,24 @@ fn test_is_valid() {
     pool.get().unwrap();
 }
 
-/*
 #[test]
 fn test_statement_pool() {
+    let config = r2d2_postgres::Config { statement_pool_size: 1 };
     let manager = r2d2_postgres::StatementPoolingManager::new(
-        "postgres://postgres@localhost", NoSsl, Default::default());
+        "postgres://postgres@localhost", NoSsl, config);
     let pool = r2d2::Pool::new(Default::default(), manager, r2d2::NoopErrorHandler).unwrap();
 
     let conn = pool.get().unwrap();
     let stmt = conn.prepare("SELECT 1::INT").unwrap();
     let stmt2 = conn.prepare("SELECT 1::INT").unwrap();
-    assert_eq!(*stmt as *mut _, *stmt2 as *mut _);
+    assert_eq!(&*stmt as *const _, &*stmt2 as *const _);
+    assert_eq!(stmt.query([]).unwrap().next().unwrap().get::<_, i32>(0), 1i32);
+
+    let stmt3 = conn.prepare("SELECT 2::INT").unwrap();
+    assert_eq!(stmt3.query([]).unwrap().next().unwrap().get::<_, i32>(0), 2i32);
+    let stmt4 = conn.prepare("SELECT 1::INT").unwrap();
+    let a = &*stmt as *const _;
+    let b = &*stmt4 as *const _;
+    assert!(a != b);
+    assert_eq!(stmt4.query([]).unwrap().next().unwrap().get::<_, i32>(0), 1i32);
 }
-*/