Allow statements to be prepared on any object

Statements aren't cleaned up at the end of a transaction, so this is
safe.

Author: sfackler

src/error.rs

@@ -614,8 +614,8 @@ pub enum Error {
     InvalidColumn,
     /// A value was NULL but converted to a non-nullable Rust type
     WasNull,
-    /// An attempt was made to prepare a statement or start a transaction on an
-    /// object other than the active transaction
+    /// An attempt was made to start a transaction or execute a lazy query on
+    /// an object other than the active transaction
     WrongTransaction,
     /// The server returned an unexpected response
     BadResponse,
@@ -639,8 +639,8 @@ impl fmt::Show for Error {
             Error::InvalidColumn => write!(fmt, "Invalid column"),
             Error::WasNull => write!(fmt, "The value was NULL"),
             Error::WrongTransaction =>
-                write!(fmt, "An attempt was made to prepare a statement or start a transaction on \
-                             an object other than the active transaction"),
+                write!(fmt, "An attempt was made to start a transaction or execute a lazy query \
+                             on an object other than the active transaction"),
             Error::BadResponse =>
                 write!(fmt, "The server returned an unexpected response"),
             Error::BadData =>
@@ -665,7 +665,8 @@ impl error::Error for Error {
             Error::InvalidColumn => "Invalid column",
             Error::WasNull => "The value was NULL",
             Error::WrongTransaction => {
-                "An attempt was made to use an object other than the active transaction"
+                "An attempt was made to start a transaction or execute a lazy query on an object \
+                 other than the active transaction"
             }
             Error::BadResponse => "The server returned an unexpected response",
             Error::BadData => "The server provided data that the client could not parse",

src/lib.rs

@@ -979,22 +979,14 @@ impl<'conn> Transaction<'conn> {
     }
 
     /// Like `Connection::prepare`.
-    pub fn prepare<'a>(&'a self, query: &str) -> Result<Statement<'a>> {
-        let mut conn = self.conn.conn.borrow_mut();
-        if conn.trans_depth != self.depth {
-            return Err(Error::WrongTransaction);
-        }
-        conn.prepare(query, self.conn)
+    pub fn prepare(&self, query: &str) -> Result<Statement<'conn>> {
+        self.conn.conn.borrow_mut().prepare(query, self.conn)
     }
 
     /// Like `Connection::prepare_copy_in`.
-    pub fn prepare_copy_in<'a>(&'a self, table: &str, cols: &[&str])
-                               -> Result<CopyInStatement<'a>> {
-        let mut conn = self.conn.conn.borrow_mut();
-        if conn.trans_depth != self.depth {
-            return Err(Error::WrongTransaction);
-        }
-        conn.prepare_copy_in(table, cols, self.conn)
+    pub fn prepare_copy_in(&self, table: &str, cols: &[&str])
+                               -> Result<CopyInStatement<'conn>> {
+        self.conn.conn.borrow_mut().prepare_copy_in(table, cols, self.conn)
     }
 
     /// Like `Connection::execute`.
@@ -1004,11 +996,7 @@ impl<'conn> Transaction<'conn> {
 
     /// Like `Connection::batch_execute`.
     pub fn batch_execute(&self, query: &str) -> Result<()> {
-        let mut conn = self.conn.conn.borrow_mut();
-        if conn.trans_depth != self.depth {
-            return Err(Error::WrongTransaction);
-        }
-        conn.quick_query(query).map(|_| ())
+        self.conn.conn.borrow_mut().quick_query(query).map(|_| ())
     }
 
     /// Like `Connection::transaction`.
@@ -1043,7 +1031,12 @@ impl<'conn> Transaction<'conn> {
         if self.conn as *const _ != stmt.conn as *const _ {
             return Err(Error::WrongConnection);
         }
-        check_desync!(self.conn);
+        let conn = self.conn.conn.borrow();
+        check_desync!(conn);
+        if conn.trans_depth != self.depth {
+            return Err(Error::WrongTransaction);
+        }
+        drop(conn);
         stmt.lazy_query(row_limit, params).map(|result| {
             LazyRows {
                 _trans: self,

tests/test.rs

@@ -298,7 +298,8 @@ fn test_trans_prepare_with_nested_trans() {
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
     let trans = or_panic!(conn.transaction());
     let _trans2 = or_panic!(trans.transaction());
-    match trans.prepare("") {
+    let stmt = or_panic!(trans.prepare("SELECT 1"));
+    match trans.lazy_query(&stmt, &[], 10) {
         Err(Error::WrongTransaction) => {}
         Err(r) => panic!("Unexpected error {}", r),
         Ok(_) => panic!("Unexpected success"),
@@ -310,6 +311,16 @@ fn test_trans_prepare_with_nested_trans() {
     }
 }
 
+#[test]
+fn test_stmt_execute_after_transaction() {
+    let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));
+    let trans = or_panic!(conn.transaction());
+    let stmt = or_panic!(trans.prepare("SELECT 1"));
+    or_panic!(trans.finish());
+    let mut result = or_panic!(stmt.query(&[]));
+    assert_eq!(1i32, result.next().unwrap().get(0));
+}
+
 #[test]
 fn test_stmt_finish() {
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost", &SslMode::None));