Move transaction to its own module

Author: sfackler

src/lib.rs

@@ -71,6 +71,9 @@ use std::time::Duration;
 #[cfg(feature = "unix_socket")]
 use std::path::PathBuf;
 
+// FIXME remove in 0.12
+pub use transaction::Transaction;
+
 use error::{Error, ConnectError, SqlState, DbError};
 use io::{StreamWrapper, NegotiateSsl};
 use message::BackendMessage::*;
@@ -93,10 +96,11 @@ mod url;
 mod util;
 pub mod error;
 pub mod io;
+pub mod notification;
 pub mod rows;
 pub mod stmt;
+pub mod transaction;
 pub mod types;
-pub mod notification;
 
 const TYPEINFO_QUERY: &'static str = "__typeinfo";
 const TYPEINFO_ENUM_QUERY: &'static str = "__typeinfo_enum";
@@ -1172,12 +1176,7 @@ impl Connection {
                 "`transaction` must be called on the active transaction");
         try!(conn.quick_query("BEGIN"));
         conn.trans_depth += 1;
-        Ok(Transaction {
-            conn: self,
-            commit: Cell::new(false),
-            depth: 1,
-            finished: false,
-        })
+        Ok(Transaction::new(self, 1))
     }
 
     /// Creates a new prepared statement.
@@ -1343,136 +1342,6 @@ impl Connection {
     }
 }
 
-/// Represents a transaction on a database connection.
-///
-/// The transaction will roll back by default.
-pub struct Transaction<'conn> {
-    conn: &'conn Connection,
-    depth: u32,
-    commit: Cell<bool>,
-    finished: bool,
-}
-
-impl<'a> fmt::Debug for Transaction<'a> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Transaction")
-           .field("commit", &self.commit.get())
-           .field("depth", &self.depth)
-           .finish()
-    }
-}
-
-impl<'conn> Drop for Transaction<'conn> {
-    fn drop(&mut self) {
-        if !self.finished {
-            let _ = self.finish_inner();
-        }
-    }
-}
-
-impl<'conn> Transaction<'conn> {
-    fn finish_inner(&mut self) -> Result<()> {
-        let mut conn = self.conn.conn.borrow_mut();
-        debug_assert!(self.depth == conn.trans_depth);
-        let query = match (self.commit.get(), self.depth != 1) {
-            (false, true) => "ROLLBACK TO sp",
-            (false, false) => "ROLLBACK",
-            (true, true) => "RELEASE sp",
-            (true, false) => "COMMIT",
-        };
-        conn.trans_depth -= 1;
-        conn.quick_query(query).map(|_| ())
-    }
-
-    /// Like `Connection::prepare`.
-    pub fn prepare(&self, query: &str) -> Result<Statement<'conn>> {
-        self.conn.prepare(query)
-    }
-
-    /// Like `Connection::prepare_cached`.
-    ///
-    /// Note that the statement will be cached for the duration of the
-    /// connection, not just the duration of this transaction.
-    pub fn prepare_cached(&self, query: &str) -> Result<Statement<'conn>> {
-        self.conn.prepare_cached(query)
-    }
-
-    /// Like `Connection::execute`.
-    pub fn execute(&self, query: &str, params: &[&ToSql]) -> Result<u64> {
-        self.conn.execute(query, params)
-    }
-
-    /// Like `Connection::query`.
-    pub fn query<'a>(&'a self, query: &str, params: &[&ToSql]) -> Result<Rows<'a>> {
-        self.conn.query(query, params)
-    }
-
-    /// Like `Connection::batch_execute`.
-    pub fn batch_execute(&self, query: &str) -> Result<()> {
-        self.conn.batch_execute(query)
-    }
-
-    /// Like `Connection::transaction`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if there is an active nested transaction.
-    pub fn transaction<'a>(&'a self) -> Result<Transaction<'a>> {
-        let mut conn = self.conn.conn.borrow_mut();
-        check_desync!(conn);
-        assert!(conn.trans_depth == self.depth,
-                "`transaction` may only be called on the active transaction");
-        try!(conn.quick_query("SAVEPOINT sp"));
-        conn.trans_depth += 1;
-        Ok(Transaction {
-            conn: self.conn,
-            commit: Cell::new(false),
-            depth: self.depth + 1,
-            finished: false,
-        })
-    }
-
-    /// Returns a reference to the `Transaction`'s `Connection`.
-    pub fn connection(&self) -> &'conn Connection {
-        self.conn
-    }
-
-    /// Like `Connection::is_active`.
-    pub fn is_active(&self) -> bool {
-        self.conn.conn.borrow().trans_depth == self.depth
-    }
-
-    /// Determines if the transaction is currently set to commit or roll back.
-    pub fn will_commit(&self) -> bool {
-        self.commit.get()
-    }
-
-    /// Sets the transaction to commit at its completion.
-    pub fn set_commit(&self) {
-        self.commit.set(true);
-    }
-
-    /// Sets the transaction to roll back at its completion.
-    pub fn set_rollback(&self) {
-        self.commit.set(false);
-    }
-
-    /// A convenience method which consumes and commits a transaction.
-    pub fn commit(self) -> Result<()> {
-        self.set_commit();
-        self.finish()
-    }
-
-    /// Consumes the transaction, commiting or rolling it back as appropriate.
-    ///
-    /// Functionally equivalent to the `Drop` implementation of `Transaction`
-    /// except that it returns any error to the caller.
-    pub fn finish(mut self) -> Result<()> {
-        self.finished = true;
-        self.finish_inner()
-    }
-}
-
 /// A trait allowing abstraction over connections and transactions
 pub trait GenericConnection {
     /// Like `Connection::execute`.
@@ -1614,3 +1483,11 @@ trait WrongTypeNew {
 trait FieldNew {
     fn new(name: String, type_: Type) -> Field;
 }
+
+trait TransactionInternals<'conn> {
+    fn new(conn: &'conn Connection, depth: u32) -> Transaction<'conn>;
+
+    fn conn(&self) -> &'conn Connection;
+
+    fn depth(&self) -> u32;
+}

src/stmt.rs

@@ -13,8 +13,8 @@ use message::BackendMessage::*;
 use message::WriteMessage;
 use util;
 use rows::{Rows, LazyRows};
-use {bad_response, Connection, Transaction, StatementInternals, Result, RowsNew};
-use {InnerConnection, SessionInfoNew, LazyRowsNew, DbErrorNew, ColumnNew, StatementInfo};
+use {bad_response, Connection, Transaction, StatementInternals, Result, RowsNew, InnerConnection,
+     SessionInfoNew, LazyRowsNew, DbErrorNew, ColumnNew, StatementInfo, TransactionInternals};
 
 /// A prepared statement.
 pub struct Statement<'conn> {
@@ -226,12 +226,12 @@ impl<'conn> Statement<'conn> {
                                      params: &[&ToSql],
                                      row_limit: i32)
                                      -> Result<LazyRows<'trans, 'stmt>> {
-        assert!(self.conn as *const _ == trans.conn as *const _,
+        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();
         check_desync!(conn);
-        assert!(conn.trans_depth == trans.depth,
+        assert!(conn.trans_depth == trans.depth(),
                 "`lazy_query` must be passed the active transaction");
         drop(conn);
 

src/transaction.rs

@@ -0,0 +1,158 @@
+//! Transactions
+
+use std::cell::Cell;
+use std::fmt;
+
+use {Result, Connection, TransactionInternals};
+use stmt::Statement;
+use rows::Rows;
+use types::ToSql;
+
+/// A transaction on a database connection.
+///
+/// The transaction will roll back by default.
+pub struct Transaction<'conn> {
+    conn: &'conn Connection,
+    depth: u32,
+    commit: Cell<bool>,
+    finished: bool,
+}
+
+impl<'a> fmt::Debug for Transaction<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Transaction")
+           .field("commit", &self.commit.get())
+           .field("depth", &self.depth)
+           .finish()
+    }
+}
+
+impl<'conn> Drop for Transaction<'conn> {
+    fn drop(&mut self) {
+        if !self.finished {
+            let _ = self.finish_inner();
+        }
+    }
+}
+
+impl<'conn> TransactionInternals<'conn> for Transaction<'conn> {
+    fn new(conn: &'conn Connection, depth: u32) -> Transaction<'conn> {
+        Transaction {
+            conn: conn,
+            depth: depth,
+            commit: Cell::new(false),
+            finished: false,
+        }
+    }
+
+    fn conn(&self) -> &'conn Connection {
+        self.conn
+    }
+
+    fn depth(&self) -> u32 {
+        self.depth
+    }
+}
+
+impl<'conn> Transaction<'conn> {
+    fn finish_inner(&mut self) -> Result<()> {
+        let mut conn = self.conn.conn.borrow_mut();
+        debug_assert!(self.depth == conn.trans_depth);
+        let query = match (self.commit.get(), self.depth != 1) {
+            (false, true) => "ROLLBACK TO sp",
+            (false, false) => "ROLLBACK",
+            (true, true) => "RELEASE sp",
+            (true, false) => "COMMIT",
+        };
+        conn.trans_depth -= 1;
+        conn.quick_query(query).map(|_| ())
+    }
+
+    /// Like `Connection::prepare`.
+    pub fn prepare(&self, query: &str) -> Result<Statement<'conn>> {
+        self.conn.prepare(query)
+    }
+
+    /// Like `Connection::prepare_cached`.
+    ///
+    /// Note that the statement will be cached for the duration of the
+    /// connection, not just the duration of this transaction.
+    pub fn prepare_cached(&self, query: &str) -> Result<Statement<'conn>> {
+        self.conn.prepare_cached(query)
+    }
+
+    /// Like `Connection::execute`.
+    pub fn execute(&self, query: &str, params: &[&ToSql]) -> Result<u64> {
+        self.conn.execute(query, params)
+    }
+
+    /// Like `Connection::query`.
+    pub fn query<'a>(&'a self, query: &str, params: &[&ToSql]) -> Result<Rows<'a>> {
+        self.conn.query(query, params)
+    }
+
+    /// Like `Connection::batch_execute`.
+    pub fn batch_execute(&self, query: &str) -> Result<()> {
+        self.conn.batch_execute(query)
+    }
+
+    /// Like `Connection::transaction`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if there is an active nested transaction.
+    pub fn transaction<'a>(&'a self) -> Result<Transaction<'a>> {
+        let mut conn = self.conn.conn.borrow_mut();
+        check_desync!(conn);
+        assert!(conn.trans_depth == self.depth,
+                "`transaction` may only be called on the active transaction");
+        try!(conn.quick_query("SAVEPOINT sp"));
+        conn.trans_depth += 1;
+        Ok(Transaction {
+            conn: self.conn,
+            commit: Cell::new(false),
+            depth: self.depth + 1,
+            finished: false,
+        })
+    }
+
+    /// Returns a reference to the `Transaction`'s `Connection`.
+    pub fn connection(&self) -> &'conn Connection {
+        self.conn
+    }
+
+    /// Like `Connection::is_active`.
+    pub fn is_active(&self) -> bool {
+        self.conn.conn.borrow().trans_depth == self.depth
+    }
+
+    /// Determines if the transaction is currently set to commit or roll back.
+    pub fn will_commit(&self) -> bool {
+        self.commit.get()
+    }
+
+    /// Sets the transaction to commit at its completion.
+    pub fn set_commit(&self) {
+        self.commit.set(true);
+    }
+
+    /// Sets the transaction to roll back at its completion.
+    pub fn set_rollback(&self) {
+        self.commit.set(false);
+    }
+
+    /// A convenience method which consumes and commits a transaction.
+    pub fn commit(self) -> Result<()> {
+        self.set_commit();
+        self.finish()
+    }
+
+    /// Consumes the transaction, commiting or rolling it back as appropriate.
+    ///
+    /// Functionally equivalent to the `Drop` implementation of `Transaction`
+    /// except that it returns any error to the caller.
+    pub fn finish(mut self) -> Result<()> {
+        self.finished = true;
+        self.finish_inner()
+    }
+}