Add an option to set a transaction isolation level to the generic

transaction interface and the connecctor api

connector_api/connection.h

@@ -29,6 +29,7 @@
 
 #include <string>
 #include <sqlpp11/connection.h>
+#include <sqlpp11/transaction.h>
 #include <sqlpp11/database/char_result.h>  // You may use char result or bind result or both
 #include <sqlpp11/database/bind_result.h>  // to represent results of select and prepared select
 
@@ -130,7 +131,7 @@ namespace sqlpp
       }
 
       //! start transaction
-      void start_transaction();
+      void start_transaction(isolation_level isolation = isolation_level::undefined);
 
       //! commit transaction (or throw transaction if the transaction has been finished already)
       void commit_transaction();

include/sqlpp11/transaction.h

@@ -34,6 +34,14 @@ namespace sqlpp
   static constexpr bool quiet_auto_rollback = false;
   static constexpr bool report_auto_rollback = true;
 
+  enum class isolation_level {
+      undefined,            // use the current database default
+      serializable,         // highest level, stronguest guarantee
+      repeatable_read,      // DBMS holds read and write locks
+      read_committed,       // DMBS holds read locks, non-repeatable reads can occur
+      read_uncommitted      // lowest isolation level, dirty reads may occur
+  };
+
   template <typename Db>
   class transaction_t
   {
@@ -48,6 +56,12 @@ namespace sqlpp
       _db.start_transaction();
     }
 
+    transaction_t(Db& db, bool report_unfinished_transaction, isolation_level isolation)
+        : _db(db), _report_unfinished_transaction(report_unfinished_transaction)
+    {
+      _db.start_transaction(isolation);
+    }
+
     transaction_t(const transaction_t&) = delete;
     transaction_t(transaction_t&&) = default;
     transaction_t& operator=(const transaction_t&) = delete;
@@ -86,9 +100,22 @@ namespace sqlpp
   };
 
   template <typename Db>
-  transaction_t<Db> start_transaction(Db& db, bool report_unfinished_transaction = report_auto_rollback)
+  transaction_t<Db> start_transaction(Db& db, bool report_unfinished_transaction)
   {
-    return {db, report_unfinished_transaction};
+      return {db, report_unfinished_transaction};
+  }
+
+  template <typename Db>
+  transaction_t<Db> start_transaction(Db& db, bool report_unfinished_transaction = report_auto_rollback,
+                                      isolation_level isolation = isolation_level::undefined)
+  {
+    return {db, report_unfinished_transaction, isolation};
+  }
+
+  template <typename Db>
+  transaction_t<Db> start_transaction(Db& db, isolation_level isolation, bool report_unfinished_transaction = report_auto_rollback)
+  {
+    return {db, report_unfinished_transaction, isolation};
   }
 }
 

tests/MockDb.h

@@ -28,6 +28,7 @@
 
 #include <iostream>
 #include <sqlpp11/connection.h>
+#include <sqlpp11/transaction.h>
 #include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/schema.h>
 #include <sqlpp11/serialize.h>
@@ -244,6 +245,22 @@ struct MockDbT : public sqlpp::connection
   {
     return {name};
   }
+
+  void start_transaction(sqlpp::isolation_level level)
+  {
+    _current_isolation_level = level;
+  }
+
+  void rollback_transaction(bool)
+  {}
+
+  void commit_transaction()
+  {}
+
+  void report_rollback_failure(std::string)
+  {}
+
+  sqlpp::isolation_level _current_isolation_level;
 };
 
 using MockDb = MockDbT<false>;

tests/Select.cpp

@@ -183,5 +183,8 @@ int Select(int, char* [])
     for_each_field(row, to_cerr{});
   }
 
+  auto transaction = start_transaction(db, sqlpp::report_auto_rollback, sqlpp::isolation_level::read_committed);
+  std::cout << (db._current_isolation_level == sqlpp::isolation_level::read_committed) << std::endl;
+  
   return 0;
 }