Start of transaction configuration

Author: sfackler

src/lib.rs

@@ -322,20 +322,12 @@ pub enum IsolationLevel {
 }
 
 impl IsolationLevel {
-    fn to_set_query(&self) -> &'static str {
+    fn to_sql(&self) -> &'static str {
         match *self {
-            IsolationLevel::ReadUncommitted => {
-                "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ UNCOMMITTED"
-            }
-            IsolationLevel::ReadCommitted => {
-                "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED"
-            }
-            IsolationLevel::RepeatableRead => {
-                "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL REPEATABLE READ"
-            }
-            IsolationLevel::Serializable => {
-                "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE"
-            }
+            IsolationLevel::ReadUncommitted => "READ UNCOMMITTED",
+            IsolationLevel::ReadCommitted => "READ COMMITTED",
+            IsolationLevel::RepeatableRead => "REPEATABLE READ",
+            IsolationLevel::Serializable => "SERIALIZABLE",
         }
     }
 
@@ -1246,7 +1238,13 @@ impl Connection {
     ///
     /// This will not change the behavior of an active transaction.
     pub fn set_transaction_isolation(&self, level: IsolationLevel) -> Result<()> {
-        self.batch_execute(level.to_set_query())
+        self.set_transaction_config(transaction::Config::new().isolation_level(level))
+    }
+
+    pub fn set_transaction_config(&self, config: &transaction::Config) -> Result<()> {
+        let mut command = "SET SESSION CHARACTERISTICS AS TRANSACTION".to_owned();
+        config.build_command(&mut command);
+        self.batch_execute(&command)
     }
 
     /// Execute a sequence of SQL statements.
@@ -1491,3 +1489,7 @@ trait TransactionInternals<'conn> {
 
     fn depth(&self) -> u32;
 }
+
+trait ConfigInternals {
+    fn build_command(&self, s: &mut String);
+}

src/transaction.rs

@@ -3,11 +3,78 @@
 use std::cell::Cell;
 use std::fmt;
 
-use {Result, Connection, TransactionInternals};
+use {Result, Connection, TransactionInternals, ConfigInternals, IsolationLevel};
 use stmt::Statement;
 use rows::Rows;
 use types::ToSql;
 
+#[derive(Debug)]
+pub struct Config {
+    isolation_level: Option<IsolationLevel>,
+    read_only: Option<bool>,
+    deferrable: Option<bool>,
+}
+
+impl ConfigInternals for Config {
+    fn build_command(&self, s: &mut String) {
+        let mut first = true;
+
+        if let Some(isolation_level) = self.isolation_level {
+            s.push_str(" ISOLATION LEVEL ");
+            s.push_str(isolation_level.to_sql());
+            first = false;
+        }
+
+        if let Some(read_only) = self.read_only {
+            if first {
+                s.push(',');
+            }
+            if read_only {
+                s.push_str(" READ ONLY");
+            } else {
+                s.push_str(" READ WRITE");
+            }
+            first = false;
+        }
+
+        if let Some(deferrable) = self.deferrable {
+            if first {
+                s.push(',');
+            }
+            if deferrable {
+                s.push_str(" DEFERRABLE");
+            } else {
+                s.push_str(" NOT DEFERRABLE");
+            }
+        }
+    }
+}
+
+impl Config {
+    pub fn new() -> Config {
+        Config {
+            isolation_level: None,
+            read_only: None,
+            deferrable: None,
+        }
+    }
+
+    pub fn isolation_level(&mut self, isolation_level: IsolationLevel) -> &mut Config {
+        self.isolation_level = Some(isolation_level);
+        self
+    }
+
+    pub fn read_only(&mut self, read_only: bool) -> &mut Config {
+        self.read_only = Some(read_only);
+        self
+    }
+
+    pub fn deferrable(&mut self, deferrable: bool) -> &mut Config {
+        self.deferrable = Some(deferrable);
+        self
+    }
+}
+
 /// A transaction on a database connection.
 ///
 /// The transaction will roll back by default.