Make Connection a tuple struct

Author: sfackler

src/lib.rs

@@ -841,13 +841,11 @@ fn _ensure_send() {
 }
 
 /// A connection to a Postgres database.
-pub struct Connection {
-    conn: RefCell<InnerConnection>,
-}
+pub struct Connection(RefCell<InnerConnection>);
 
 impl fmt::Debug for Connection {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let conn = self.conn.borrow();
+        let conn = self.0.borrow();
         fmt.debug_struct("Connection")
             .field("stream", &conn.stream.get_ref())
             .field("cancel_data", &conn.cancel_data)
@@ -919,7 +917,7 @@ impl Connection {
     pub fn connect<T>(params: T, tls: TlsMode) -> result::Result<Connection, ConnectError>
         where T: IntoConnectParams
     {
-        InnerConnection::connect(params, tls).map(|conn| Connection { conn: RefCell::new(conn) })
+        InnerConnection::connect(params, tls).map(|conn| Connection(RefCell::new(conn)))
     }
 
     /// Executes a statement, returning the number of rows modified.
@@ -950,7 +948,7 @@ impl Connection {
     /// println!("{} rows updated", rows_updated);
     /// ```
     pub fn execute(&self, query: &str, params: &[&ToSql]) -> Result<u64> {
-        let (param_types, columns) = try!(self.conn.borrow_mut().raw_prepare("", query));
+        let (param_types, columns) = try!(self.0.borrow_mut().raw_prepare("", query));
         let info = Arc::new(StatementInfo {
             name: String::new(),
             param_types: param_types,
@@ -986,7 +984,7 @@ impl Connection {
     /// }
     /// ```
     pub fn query<'a>(&'a self, query: &str, params: &[&ToSql]) -> Result<Rows<'a>> {
-        let (param_types, columns) = try!(self.conn.borrow_mut().raw_prepare("", query));
+        let (param_types, columns) = try!(self.0.borrow_mut().raw_prepare("", query));
         let info = Arc::new(StatementInfo {
             name: String::new(),
             param_types: param_types,
@@ -1027,7 +1025,7 @@ impl Connection {
 
     /// Begins a new transaction with the specified configuration.
     pub fn transaction_with<'a>(&'a self, config: &transaction::Config) -> Result<Transaction<'a>> {
-        let mut conn = self.conn.borrow_mut();
+        let mut conn = self.0.borrow_mut();
         check_desync!(conn);
         assert!(conn.trans_depth == 0,
                 "`transaction` must be called on the active transaction");
@@ -1060,7 +1058,7 @@ impl Connection {
     /// }
     /// ```
     pub fn prepare<'a>(&'a self, query: &str) -> Result<Statement<'a>> {
-        self.conn.borrow_mut().prepare(query, self)
+        self.0.borrow_mut().prepare(query, self)
     }
 
     /// Creates a cached prepared statement.
@@ -1084,14 +1082,14 @@ impl Connection {
     /// }
     /// ```
     pub fn prepare_cached<'a>(&'a self, query: &str) -> Result<Statement<'a>> {
-        self.conn.borrow_mut().prepare_cached(query, self)
+        self.0.borrow_mut().prepare_cached(query, self)
     }
 
     /// Returns the isolation level which will be used for future transactions.
     ///
     /// This is a simple wrapper around `SHOW TRANSACTION ISOLATION LEVEL`.
     pub fn transaction_isolation(&self) -> Result<IsolationLevel> {
-        let mut conn = self.conn.borrow_mut();
+        let mut conn = self.0.borrow_mut();
         check_desync!(conn);
         let result = try!(conn.quick_query("SHOW TRANSACTION ISOLATION LEVEL"));
         IsolationLevel::new(result[0][0].as_ref().unwrap())
@@ -1139,7 +1137,7 @@ impl Connection {
     ///     ").unwrap();
     /// ```
     pub fn batch_execute(&self, query: &str) -> Result<()> {
-        self.conn.borrow_mut().quick_query(query).map(|_| ())
+        self.0.borrow_mut().quick_query(query).map(|_| ())
     }
 
     /// Returns a structure providing access to asynchronous notifications.
@@ -1154,18 +1152,18 @@ impl Connection {
     /// Used with the `cancel_query` function. The object returned can be used
     /// to cancel any query executed by the connection it was created from.
     pub fn cancel_data(&self) -> CancelData {
-        self.conn.borrow().cancel_data
+        self.0.borrow().cancel_data
     }
 
     /// Returns the value of the specified Postgres backend parameter, such as
     /// `timezone` or `server_version`.
     pub fn parameter(&self, param: &str) -> Option<String> {
-        self.conn.borrow().parameters.get(param).cloned()
+        self.0.borrow().parameters.get(param).cloned()
     }
 
     /// Sets the notice handler for the connection, returning the old handler.
     pub fn set_notice_handler(&self, handler: Box<HandleNotice>) -> Box<HandleNotice> {
-        self.conn.borrow_mut().set_notice_handler(handler)
+        self.0.borrow_mut().set_notice_handler(handler)
     }
 
     /// Returns whether or not the stream has been desynchronized due to an
@@ -1174,7 +1172,7 @@ impl Connection {
     /// If this has occurred, all further queries will immediately return an
     /// error.
     pub fn is_desynchronized(&self) -> bool {
-        self.conn.borrow().is_desynchronized()
+        self.0.borrow().is_desynchronized()
     }
 
     /// Determines if the `Connection` is currently "active", that is, if there
@@ -1183,15 +1181,15 @@ impl Connection {
     /// The `transaction` method can only be called on the active `Connection`
     /// or `Transaction`.
     pub fn is_active(&self) -> bool {
-        self.conn.borrow().trans_depth == 0
+        self.0.borrow().trans_depth == 0
     }
 
     /// Consumes the connection, closing it.
     ///
     /// Functionally equivalent to the `Drop` implementation for `Connection`
     /// except that it returns any error encountered to the caller.
     pub fn finish(self) -> Result<()> {
-        let mut conn = self.conn.borrow_mut();
+        let mut conn = self.0.borrow_mut();
         conn.finished = true;
         conn.finish_inner()
     }

src/notification.rs

@@ -35,7 +35,7 @@ impl<'a> fmt::Debug for Notifications<'a> {
 impl<'conn> Notifications<'conn> {
     /// Returns the number of pending notifications.
     pub fn len(&self) -> usize {
-        self.conn.conn.borrow().notifications.len()
+        self.conn.0.borrow().notifications.len()
     }
 
     /// Determines if there are any pending notifications.
@@ -102,7 +102,7 @@ impl<'a> FallibleIterator for Iter<'a> {
     type Error = Error;
 
     fn next(&mut self) -> Result<Option<Notification>> {
-        let mut conn = self.conn.conn.borrow_mut();
+        let mut conn = self.conn.0.borrow_mut();
 
         if let Some(notification) = conn.notifications.pop_front() {
             return Ok(Some(notification));
@@ -127,7 +127,7 @@ impl<'a> FallibleIterator for Iter<'a> {
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.conn.conn.borrow().notifications.len(), None)
+        (self.conn.0.borrow().notifications.len(), None)
     }
 }
 
@@ -141,7 +141,7 @@ impl<'a> FallibleIterator for BlockingIter<'a> {
     type Error = Error;
 
     fn next(&mut self) -> Result<Option<Notification>> {
-        let mut conn = self.conn.conn.borrow_mut();
+        let mut conn = self.conn.0.borrow_mut();
 
         if let Some(notification) = conn.notifications.pop_front() {
             return Ok(Some(notification));
@@ -177,7 +177,7 @@ impl<'a> FallibleIterator for TimeoutIter<'a> {
     type Error = Error;
 
     fn next(&mut self) -> Result<Option<Notification>> {
-        let mut conn = self.conn.conn.borrow_mut();
+        let mut conn = self.conn.0.borrow_mut();
 
         if let Some(notification) = conn.notifications.pop_front() {
             return Ok(Some(notification));
@@ -202,6 +202,6 @@ impl<'a> FallibleIterator for TimeoutIter<'a> {
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.conn.conn.borrow().notifications.len(), None)
+        (self.conn.0.borrow().notifications.len(), None)
     }
 }

src/rows.rs

@@ -236,7 +236,7 @@ impl<'a> Row<'a> {
         if !<T as FromSql>::accepts(ty) {
             return Some(Err(Error::Conversion(Box::new(WrongType::new(ty.clone())))));
         }
-        let conn = self.stmt.conn().conn.borrow();
+        let conn = self.stmt.conn().0.borrow();
         let value = match self.data[idx] {
             Some(ref data) => {
                 FromSql::from_sql(ty, data, &SessionInfo::new(&conn.parameters))
@@ -346,13 +346,13 @@ impl<'a, 'b> fmt::Debug for LazyRows<'a, 'b> {
 
 impl<'trans, 'stmt> LazyRows<'trans, 'stmt> {
     fn finish_inner(&mut self) -> Result<()> {
-        let mut conn = self.stmt.conn().conn.borrow_mut();
+        let mut conn = self.stmt.conn().0.borrow_mut();
         check_desync!(conn);
         conn.close_statement(&self.name, b'P')
     }
 
     fn execute(&mut self) -> Result<()> {
-        let mut conn = self.stmt.conn().conn.borrow_mut();
+        let mut conn = self.stmt.conn().0.borrow_mut();
 
         try!(conn.stream.write_message(|buf| frontend::execute(&self.name, self.row_limit, buf)));
         try!(conn.stream.write_message(|buf| Ok::<(), io::Error>(frontend::sync(buf))));

src/stmt.rs

@@ -69,7 +69,7 @@ impl<'conn> Statement<'conn> {
             Ok(())
         } else {
             self.finished = true;
-            let mut conn = self.conn.conn.borrow_mut();
+            let mut conn = self.conn.0.borrow_mut();
             check_desync!(conn);
             conn.close_statement(&self.info.name, b'S')
         }
@@ -81,7 +81,7 @@ impl<'conn> Statement<'conn> {
                        row_limit: i32,
                        params: &[&ToSql])
                        -> Result<(VecDeque<Vec<Option<Vec<u8>>>>, bool)> {
-        let mut conn = self.conn.conn.borrow_mut();
+        let mut conn = self.conn.0.borrow_mut();
 
         try!(conn.raw_execute(&self.info.name,
                               portal_name,
@@ -125,7 +125,7 @@ impl<'conn> Statement<'conn> {
     /// println!("{} rows updated", rows_updated);
     /// ```
     pub fn execute(&self, params: &[&ToSql]) -> Result<u64> {
-        let mut conn = self.conn.conn.borrow_mut();
+        let mut conn = self.conn.0.borrow_mut();
         check_desync!(conn);
         try!(conn.raw_execute(&self.info.name, "", 0, self.param_types(), params));
 
@@ -228,7 +228,7 @@ impl<'conn> Statement<'conn> {
         assert!(self.conn as *const _ == trans.conn() as *const _,
                 "the `Transaction` passed to `lazy_query` must be associated with the same \
                  `Connection` as the `Statement`");
-        let conn = self.conn.conn.borrow();
+        let conn = self.conn.0.borrow();
         check_desync!(conn);
         assert!(conn.trans_depth == trans.depth(),
                 "`lazy_query` must be passed the active transaction");
@@ -265,7 +265,7 @@ impl<'conn> Statement<'conn> {
     /// stmt.copy_in(&[], &mut "1\tjohn\n2\tjane\n".as_bytes()).unwrap();
     /// ```
     pub fn copy_in<R: ReadWithInfo>(&self, params: &[&ToSql], r: &mut R) -> Result<u64> {
-        let mut conn = self.conn.conn.borrow_mut();
+        let mut conn = self.conn.0.borrow_mut();
         try!(conn.raw_execute(&self.info.name, "", 0, self.param_types(), params));
 
         let (format, column_formats) = match try!(conn.read_message()) {
@@ -368,7 +368,7 @@ impl<'conn> Statement<'conn> {
     /// assert_eq!(buf, b"1\tjohn\n2\tjane\n");
     /// ```
     pub fn copy_out<'a, W: WriteWithInfo>(&'a self, params: &[&ToSql], w: &mut W) -> Result<u64> {
-        let mut conn = self.conn.conn.borrow_mut();
+        let mut conn = self.conn.0.borrow_mut();
         try!(conn.raw_execute(&self.info.name, "", 0, self.param_types(), params));
 
         let (format, column_formats) = match try!(conn.read_message()) {

src/transaction.rs

@@ -194,7 +194,7 @@ impl<'conn> TransactionInternals<'conn> for Transaction<'conn> {
 
 impl<'conn> Transaction<'conn> {
     fn finish_inner(&mut self) -> Result<()> {
-        let mut conn = self.conn.conn.borrow_mut();
+        let mut conn = self.conn.0.borrow_mut();
         debug_assert!(self.depth == conn.trans_depth);
         conn.trans_depth -= 1;
         match (self.commit.get(), &self.savepoint_name) {
@@ -254,7 +254,7 @@ impl<'conn> Transaction<'conn> {
     ///
     /// Panics if there is an active nested transaction.
     pub fn savepoint<'a>(&'a self, name: &str) -> Result<Transaction<'a>> {
-        let mut conn = self.conn.conn.borrow_mut();
+        let mut conn = self.conn.0.borrow_mut();
         check_desync!(conn);
         assert!(conn.trans_depth == self.depth,
                 "`savepoint` may only be called on the active transaction");
@@ -276,7 +276,7 @@ impl<'conn> Transaction<'conn> {
 
     /// Like `Connection::is_active`.
     pub fn is_active(&self) -> bool {
-        self.conn.conn.borrow().trans_depth == self.depth
+        self.conn.0.borrow().trans_depth == self.depth
     }
 
     /// Alters the configuration of the active transaction.