diff --git a/Changelog.md b/Changelog.md index 76cb1d6..71c06f8 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,5 +1,10 @@ # Version UPCOMING (...) +* BREAKING CHANGE: Creating transactions from a `Connection` or savepoints from a `Transaction` + now take `&mut self` instead of `&self` to correctly represent that transactions within a + connection are inherently nested. While a transaction is alive, the parent connection or + transaction is unusable, so `Transaction` now implements `Deref`, giving + access to `Connection`'s methods via the `Transaction` itself. * Adds `Connection::prepare_cached`. `Connection` now keeps an internal cache of any statements prepared via this method. The size of this cache defaults to 16 (`prepare_cached` will always work but may re-prepare statements if more are prepared than the cache holds), and can be diff --git a/src/lib.rs b/src/lib.rs index eea21cb..130ee2d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -249,7 +249,7 @@ impl Connection { /// # Failure /// /// Will return `Err` if the underlying SQLite call fails. - pub fn transaction(&self) -> Result { + pub fn transaction(&mut self) -> Result { Transaction::new(self, TransactionBehavior::Deferred) } @@ -260,7 +260,7 @@ impl Connection { /// # Failure /// /// Will return `Err` if the underlying SQLite call fails. - pub fn transaction_with_behavior(&self, behavior: TransactionBehavior) -> Result { + pub fn transaction_with_behavior(&mut self, behavior: TransactionBehavior) -> Result { Transaction::new(self, behavior) } diff --git a/src/transaction.rs b/src/transaction.rs index e72add4..a30fc30 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -1,3 +1,5 @@ +use std::borrow::Cow; +use std::ops::Deref; use {Result, Connection}; /// Old name for `TransactionBehavior`. `SqliteTransactionBehavior` is deprecated. @@ -47,13 +49,13 @@ pub struct Transaction<'conn> { impl<'conn> Transaction<'conn> { /// Begin a new transaction. Cannot be nested; see `savepoint` for nested transactions. - pub fn new(conn: &Connection, behavior: TransactionBehavior) -> Result { + pub fn new(conn: &mut Connection, behavior: TransactionBehavior) -> Result { let query = match behavior { TransactionBehavior::Deferred => "BEGIN DEFERRED", TransactionBehavior::Immediate => "BEGIN IMMEDIATE", TransactionBehavior::Exclusive => "BEGIN EXCLUSIVE", }; - conn.execute_batch(query).map(|_| { + conn.execute_batch(query).map(move |_| { Transaction { conn: conn, depth: 0, @@ -89,11 +91,12 @@ impl<'conn> Transaction<'conn> { /// tx.commit() /// } /// ``` - pub fn savepoint(&self) -> Result { - self.conn.execute_batch("SAVEPOINT sp").map(|_| { + pub fn savepoint(&mut self) -> Result { + let new_depth = self.depth + 1; + self.conn.execute_batch(&format!("SAVEPOINT sp{}", new_depth)).map(|_| { Transaction { conn: self.conn, - depth: self.depth + 1, + depth: new_depth, commit: false, finished: false, } @@ -127,11 +130,12 @@ impl<'conn> Transaction<'conn> { fn commit_(&mut self) -> Result<()> { self.finished = true; - self.conn.execute_batch(if self.depth == 0 { - "COMMIT" + let sql = if self.depth == 0 { + Cow::Borrowed("COMMIT") } else { - "RELEASE sp" - }) + Cow::Owned(format!("RELEASE sp{}", self.depth)) + }; + self.conn.execute_batch(&sql) } /// A convenience method which consumes and rolls back a transaction. @@ -141,11 +145,12 @@ impl<'conn> Transaction<'conn> { fn rollback_(&mut self) -> Result<()> { self.finished = true; - self.conn.execute_batch(if self.depth == 0 { - "ROLLBACK" + let sql = if self.depth == 0 { + Cow::Borrowed("ROLLBACK") } else { - "ROLLBACK TO sp" - }) + Cow::Owned(format!("ROLLBACK TO sp{}", self.depth)) + }; + self.conn.execute_batch(&sql) } /// Consumes the transaction, committing or rolling back according to the current setting @@ -166,6 +171,14 @@ impl<'conn> Transaction<'conn> { } } +impl<'conn> Deref for Transaction<'conn> { + type Target = Connection; + + fn deref(&self) -> &Connection { + self.conn + } +} + #[allow(unused_must_use)] impl<'conn> Drop for Transaction<'conn> { fn drop(&mut self) { @@ -186,69 +199,80 @@ mod test { #[test] fn test_drop() { - let db = checked_memory_handle(); + let mut db = checked_memory_handle(); { - let _tx = db.transaction().unwrap(); - db.execute_batch("INSERT INTO foo VALUES(1)").unwrap(); + let tx = db.transaction().unwrap(); + tx.execute_batch("INSERT INTO foo VALUES(1)").unwrap(); // default: rollback } { let mut tx = db.transaction().unwrap(); - db.execute_batch("INSERT INTO foo VALUES(2)").unwrap(); + tx.execute_batch("INSERT INTO foo VALUES(2)").unwrap(); tx.set_commit() } { - let _tx = db.transaction().unwrap(); + let tx = db.transaction().unwrap(); assert_eq!(2i32, - db.query_row("SELECT SUM(x) FROM foo", &[], |r| r.get(0)).unwrap()); + tx.query_row("SELECT SUM(x) FROM foo", &[], |r| r.get(0)).unwrap()); } } #[test] fn test_explicit_rollback_commit() { - let db = checked_memory_handle(); + let mut db = checked_memory_handle(); { let tx = db.transaction().unwrap(); - db.execute_batch("INSERT INTO foo VALUES(1)").unwrap(); + tx.execute_batch("INSERT INTO foo VALUES(1)").unwrap(); tx.rollback().unwrap(); } { let tx = db.transaction().unwrap(); - db.execute_batch("INSERT INTO foo VALUES(2)").unwrap(); + tx.execute_batch("INSERT INTO foo VALUES(2)").unwrap(); tx.commit().unwrap(); } { - let _tx = db.transaction().unwrap(); + let tx = db.transaction().unwrap(); assert_eq!(2i32, - db.query_row("SELECT SUM(x) FROM foo", &[], |r| r.get(0)).unwrap()); + tx.query_row("SELECT SUM(x) FROM foo", &[], |r| r.get(0)).unwrap()); } } #[test] fn test_savepoint() { - let db = checked_memory_handle(); + fn assert_current_sum(x: i32, conn: &Connection) { + let i = conn.query_row("SELECT SUM(x) FROM foo", &[], |r| r.get(0)).unwrap(); + assert_eq!(x, i); + } + + let mut db = checked_memory_handle(); { let mut tx = db.transaction().unwrap(); - db.execute_batch("INSERT INTO foo VALUES(1)").unwrap(); + tx.execute_batch("INSERT INTO foo VALUES(1)").unwrap(); + assert_current_sum(1, &tx); tx.set_commit(); { let mut sp1 = tx.savepoint().unwrap(); - db.execute_batch("INSERT INTO foo VALUES(2)").unwrap(); - sp1.set_commit(); + sp1.execute_batch("INSERT INTO foo VALUES(2)").unwrap(); + assert_current_sum(3, &sp1); + // will rollback sp1 { - let sp2 = sp1.savepoint().unwrap(); - db.execute_batch("INSERT INTO foo VALUES(4)").unwrap(); + let mut sp2 = sp1.savepoint().unwrap(); + sp2.execute_batch("INSERT INTO foo VALUES(4)").unwrap(); + assert_current_sum(7, &sp2); // will rollback sp2 { let sp3 = sp2.savepoint().unwrap(); - db.execute_batch("INSERT INTO foo VALUES(8)").unwrap(); + sp3.execute_batch("INSERT INTO foo VALUES(8)").unwrap(); + assert_current_sum(15, &sp3); sp3.commit().unwrap(); // committed sp3, but will be erased by sp2 rollback } + assert_current_sum(15, &sp2); } + assert_current_sum(3, &sp1); } + assert_current_sum(1, &tx); } - assert_eq!(3i32, - db.query_row("SELECT SUM(x) FROM foo", &[], |r| r.get(0)).unwrap()); + assert_current_sum(1, &db); } }