Update for new r2d2 and postgres versions

The caching pool's gone because postgres::Connection::prepare_cached
should cover its use case.

Author: sfackler

Cargo.toml

@@ -18,6 +18,5 @@ name = "test"
 path = "tests/test.rs"
 
 [dependencies]
-r2d2 = "0.2"
-postgres = "0.4"
-collect = "~0.0"
+r2d2 = "0.3"
+postgres = "0.5"

src/lib.rs

@@ -4,32 +4,24 @@
 #![allow(unstable)]
 extern crate r2d2;
 extern crate postgres;
-extern crate collect;
 
-use collect::LruCache;
-use std::borrow::ToOwned;
-use std::cell::RefCell;
-use std::default::Default;
 use std::error;
 use std::error::Error as _StdError;
 use std::fmt;
-use std::mem;
-use std::rc::Rc;
 use postgres::{IntoConnectParams, SslMode};
-use postgres::types::ToSql;
 
 /// A unified enum of errors returned by postgres::Connection
-#[derive(Clone, Show)]
+#[derive(Clone, Debug)]
 pub enum Error {
     /// A postgres::ConnectError
     Connect(postgres::ConnectError),
     /// An postgres::Error
     Other(postgres::Error),
 }
 
-impl fmt::String for Error {
+impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "{}", self.description())
+        write!(fmt, "{}: {}", self.description(), self.cause().unwrap())
     }
 }
 
@@ -49,7 +41,7 @@ impl error::Error for Error {
     }
 }
 
-/// An `r2d2::PoolManager` for `postgres::Connection`s.
+/// An `r2d2::ConnectionManager` for `postgres::Connection`s.
 ///
 /// ## Example
 ///
@@ -63,12 +55,12 @@ impl error::Error for Error {
 /// use std::default::Default;
 /// use std::thread::Thread;
 /// use postgres::SslMode;
-/// use r2d2_postgres::PostgresPoolManager;
+/// use r2d2_postgres::PostgresConnectionManager;
 ///
 /// fn main() {
 ///     let config = Default::default();
-///     let manager = PostgresPoolManager::new("postgres://postgres@localhost",
-///                                            SslMode::None);
+///     let manager = PostgresConnectionManager::new("postgres://postgres@localhost",
+///                                                  SslMode::None);
 ///     let error_handler = r2d2::LoggingErrorHandler;
 ///     let pool = Arc::new(r2d2::Pool::new(config, manager, error_handler).unwrap());
 ///
@@ -81,25 +73,35 @@ impl error::Error for Error {
 ///     }
 /// }
 /// ```
-pub struct PostgresPoolManager {
+pub struct PostgresConnectionManager {
     params: Result<postgres::ConnectParams, postgres::ConnectError>,
     ssl_mode: SslMode,
 }
 
-impl PostgresPoolManager {
-    /// Creates a new `PostgresPoolManager`.
+impl fmt::Debug for PostgresConnectionManager {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "PostgresConnectionManager {{ parameters: {:?}, ssl_mode: {:?} }}",
+               self.params, self.ssl_mode)
+    }
+}
+
+impl PostgresConnectionManager {
+    /// Creates a new `PostgresConnectionManager`.
     ///
     /// See `postgres::Connection::connect` for a description of the parameter
     /// types.
-    pub fn new<T: IntoConnectParams>(params: T, ssl_mode: SslMode) -> PostgresPoolManager {
-        PostgresPoolManager {
+    pub fn new<T: IntoConnectParams>(params: T, ssl_mode: SslMode) -> PostgresConnectionManager {
+        PostgresConnectionManager {
             params: params.into_connect_params(),
             ssl_mode: ssl_mode,
         }
     }
 }
 
-impl r2d2::PoolManager<postgres::Connection, Error> for PostgresPoolManager {
+impl r2d2::ConnectionManager for PostgresConnectionManager {
+    type Connection = postgres::Connection;
+    type Error = Error;
+
     fn connect(&self) -> Result<postgres::Connection, Error> {
         match self.params {
             Ok(ref p) => {
@@ -117,169 +119,3 @@ impl r2d2::PoolManager<postgres::Connection, Error> for PostgresPoolManager {
         conn.is_desynchronized()
     }
 }
-
-/// Configuration options for the `CachingStatementManager`.
-#[derive(Copy, Clone)]
-pub struct Config {
-    /// The number of `postgres::Statement`s that will be internally cached.
-    ///
-    /// Defaults to 10
-    pub statement_pool_size: u32,
-}
-
-impl Default for Config {
-    fn default() -> Config {
-        Config {
-            statement_pool_size: 10,
-        }
-    }
-}
-
-/// An `r2d2::PoolManager` for `Connection`s, which cache prepared statements.
-pub struct StatementCachingManager {
-    manager: PostgresPoolManager,
-    config: Config,
-}
-
-impl StatementCachingManager {
-    /// Creates a new `StatementCachingManager`.
-    ///
-    /// See `postgres::Connection::Connect` for details of the first two
-    /// parameter types.
-    pub fn new<T>(params: T, ssl_mode: SslMode, config: Config) -> StatementCachingManager
-            where T: IntoConnectParams {
-        StatementCachingManager {
-            manager: PostgresPoolManager::new(params, ssl_mode),
-            config: config
-        }
-    }
-}
-
-impl r2d2::PoolManager<Connection, Error> for StatementCachingManager {
-    fn connect(&self) -> Result<Connection, Error> {
-        let cache = Box::new(RefCell::new(LruCache::<String, postgres::Statement<'static>>::new(
-                self.config.statement_pool_size as usize)));
-        Ok(Connection {
-            conn: Box::new(try!(self.manager.connect())),
-            stmts: unsafe { mem::transmute(cache) },
-        })
-    }
-
-    fn is_valid(&self, conn: &mut Connection) -> Result<(), Error> {
-        self.manager.is_valid(&mut *conn.conn)
-    }
-
-    fn has_broken(&self, conn: &mut Connection) -> bool {
-        self.manager.has_broken(&mut *conn.conn)
-    }
-}
-
-/// A trait abstracting over functionality provided by `Connection`s and
-/// `Transaction`s.
-pub trait GenericConnection {
-    /// Like `postgres::Connection::prepare`.
-    fn prepare<'a>(&'a self, query: &str) -> postgres::Result<Rc<postgres::Statement<'a>>>;
-
-    /// Like `postgres::Connection::execute`.
-    fn execute(&self, query: &str, params: &[&ToSql]) -> postgres::Result<usize> {
-        self.prepare(query).and_then(|s| s.execute(params))
-    }
-
-    /// Like `postgres::Connection::prepare_copy_in`.
-    fn prepare_copy_in<'a>(&'a self, table: &str, columns: &[&str])
-                           -> postgres::Result<postgres::CopyInStatement<'a>>;
-
-    /// Like `postgres::Connection::transaction`.
-    fn transaction<'a>(&'a self) -> postgres::Result<Transaction<'a>>;
-
-    /// Like `postgres::Connection::batch_execute`.
-    fn batch_execute(&self, query: &str) -> postgres::Result<()>;
-}
-
-/// Like a `postgres::Connection`, but maintains a cache of
-/// `postgres::Statement`s.
-pub struct Connection {
-    conn: Box<postgres::Connection>,
-    stmts: *mut (),
-}
-
-unsafe impl Send for Connection {}
-
-impl Drop for Connection {
-    fn drop(&mut self) {
-        let _: Box<RefCell<LruCache<String, Rc<postgres::Statement<'static>>>>> =
-            unsafe { mem::transmute(self.stmts) };
-    }
-}
-
-impl Connection {
-    fn get_cache<'a>(&'a self) -> &'a RefCell<LruCache<String, Rc<postgres::Statement<'a>>>> {
-        unsafe { mem::transmute(self.stmts) }
-    }
-}
-
-impl GenericConnection for Connection {
-    fn prepare<'a>(&'a self, query: &str) -> postgres::Result<Rc<postgres::Statement<'a>>> {
-        let query = query.to_owned();
-        let mut stmts = self.get_cache().borrow_mut();
-
-        if let Some(stmt) = stmts.get(&query) {
-            return Ok(stmt.clone());
-        }
-
-        let stmt = Rc::new(try!(self.conn.prepare(&*query)));
-        stmts.insert(query, stmt.clone());
-        Ok(stmt)
-    }
-
-    fn prepare_copy_in<'a>(&'a self, table: &str, columns: &[&str])
-                           -> postgres::Result<postgres::CopyInStatement<'a>> {
-        self.conn.prepare_copy_in(table, columns)
-    }
-
-    fn transaction<'a>(&'a self) -> postgres::Result<Transaction<'a>> {
-        Ok(Transaction {
-            conn: self,
-            trans: try!(self.conn.transaction())
-        })
-    }
-
-    fn batch_execute(&self, query: &str) -> postgres::Result<()> {
-        self.conn.batch_execute(query)
-    }
-}
-
-/// Like `postgres::Transaction`.
-pub struct Transaction<'a> {
-    conn: &'a Connection,
-    trans: postgres::Transaction<'a>
-}
-
-impl<'a> GenericConnection for Transaction<'a> {
-    fn prepare<'b>(&'b self, query: &str) -> postgres::Result<Rc<postgres::Statement<'b>>> {
-        let query = query.to_owned();
-        let mut stmts = self.conn.get_cache().borrow_mut();
-
-        if let Some(stmt) = stmts.get(&query) {
-            return Ok(stmt.clone());
-        }
-
-        Ok(Rc::new(try!(self.trans.prepare(&*query))))
-    }
-
-    fn prepare_copy_in<'b>(&'b self, table: &str, columns: &[&str])
-                           -> postgres::Result<postgres::CopyInStatement<'b>> {
-        self.trans.prepare_copy_in(table, columns)
-    }
-
-    fn transaction<'b>(&'b self) -> postgres::Result<Transaction<'b>> {
-        Ok(Transaction {
-            conn: self.conn,
-            trans: try!(self.trans.transaction())
-        })
-    }
-
-    fn batch_execute(&self, query: &str) -> postgres::Result<()> {
-        self.trans.batch_execute(query)
-    }
-}

tests/test.rs

@@ -8,12 +8,11 @@ use std::sync::{Arc, Future};
 use std::sync::mpsc;
 
 use postgres::SslMode;
-use r2d2_postgres::PostgresPoolManager;
-use r2d2_postgres::GenericConnection;
+use r2d2_postgres::PostgresConnectionManager;
 
 #[test]
 fn test_basic() {
-    let manager = PostgresPoolManager::new("postgres://postgres@localhost", SslMode::None);
+    let manager = PostgresConnectionManager::new("postgres://postgres@localhost", SslMode::None);
     let config = r2d2::Config {
         pool_size: 2,
         ..Default::default()
@@ -48,7 +47,7 @@ fn test_basic() {
 
 #[test]
 fn test_is_valid() {
-    let manager = PostgresPoolManager::new("postgres://postgres@localhost", SslMode::None);
+    let manager = PostgresConnectionManager::new("postgres://postgres@localhost", SslMode::None);
     let config = r2d2::Config {
         pool_size: 1,
         test_on_check_out: true,
@@ -59,25 +58,3 @@ 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::StatementCachingManager::new(
-        "postgres://postgres@localhost", SslMode::None, 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 *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);
-}