Sqlite: Introduce implicit transaction

Sqlite adds an implicit transaction if no transaction is used. That can
be problematic if you use multiple statements but it is okay for one
read statement.

Write and read write statements should use immediate transactions
because the acquire the write lock. Otherwise the write lock is only
acquired as you try to write. From there it is much harder to recover.

Change-Id: I04b0be7447f2b82b6921738d789c33cbbaa8de6e
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
Reviewed-by: Qt CI Patch Build Bot <ci_patchbuild_bot@qt.io>

2 files changed, 35 insertions, 5 deletions

diff --git a/src/libs/sqlite/sqlitereadstatement.h b/src/libs/sqlite/sqlitereadstatement.h
index 4f8091598b..04e4a37cf7 100644
--- a/src/libs/sqlite/sqlitereadstatement.h
+++ b/src/libs/sqlite/sqlitereadstatement.h
@@ -34,7 +34,7 @@ public:
     template<typename ResultType, typename... QueryTypes>
     auto valueWithTransaction(const QueryTypes &...queryValues)
     {
-        return withDeferredTransaction(Base::database(), [&] {
+        return withImplicitTransaction(Base::database(), [&] {
             return Base::template value<ResultType>(queryValues...);
         });
     }
@@ -42,7 +42,7 @@ public:
     template<typename ResultType, typename... QueryTypes>
     auto optionalValueWithTransaction(const QueryTypes &...queryValues)
     {
-        return withDeferredTransaction(Base::database(), [&] {
+        return withImplicitTransaction(Base::database(), [&] {
             return Base::template optionalValue<ResultType>(queryValues...);
         });
     }
@@ -50,7 +50,7 @@ public:
     template<typename ResultType, std::size_t capacity = 32, typename... QueryTypes>
     auto valuesWithTransaction(const QueryTypes &...queryValues)
     {
-        return withDeferredTransaction(Base::database(), [&] {
+        return withImplicitTransaction(Base::database(), [&] {
             return Base::template values<ResultType, capacity>(queryValues...);
         });
     }
@@ -58,7 +58,7 @@ public:
     template<typename Callable, typename... QueryTypes>
     void readCallbackWithTransaction(Callable &&callable, const QueryTypes &...queryValues)
     {
-        withDeferredTransaction(Base::database(), [&] {
+        withImplicitTransaction(Base::database(), [&] {
             Base::readCallback(std::forward<Callable>(callable), queryValues...);
         });
     }
@@ -66,7 +66,7 @@ public:
     template<typename Container, typename... QueryTypes>
     void readToWithTransaction(Container &container, const QueryTypes &...queryValues)
     {
-        withDeferredTransaction(Base::database(), [&] { Base::readTo(container, queryValues...); });
+        withImplicitTransaction(Base::database(), [&] { Base::readTo(container, queryValues...); });
     }
 
 protected:
diff --git a/src/libs/sqlite/sqlitetransaction.h b/src/libs/sqlite/sqlitetransaction.h
index 2cc4a7bf5f..85228eb050 100644
--- a/src/libs/sqlite/sqlitetransaction.h
+++ b/src/libs/sqlite/sqlitetransaction.h
@@ -68,6 +68,24 @@ protected:
 };
 
 template<typename TransactionInterface>
+class ImplicitTransaction
+{
+public:
+    using Transaction = TransactionInterface;
+
+    ~ImplicitTransaction() = default;
+    ImplicitTransaction(TransactionInterface &transactionInterface)
+        : m_locker(transactionInterface)
+    {}
+
+    ImplicitTransaction(const ImplicitTransaction &) = delete;
+    ImplicitTransaction &operator=(const ImplicitTransaction &) = delete;
+
+protected:
+    std::unique_lock<TransactionInterface> m_locker;
+};
+
+template<typename TransactionInterface>
 class AbstractThrowingSessionTransaction
 {
 public:
@@ -202,6 +220,18 @@ auto withTransaction(TransactionInterface &transactionInterface, Callable &&call
 }
 
 template<typename TransactionInterface, typename Callable>
+auto withImplicitTransaction(TransactionInterface &transactionInterface, Callable &&callable)
+{
+    ImplicitTransaction transaction{transactionInterface};
+
+    if constexpr (std::is_void_v<std::invoke_result_t<Callable>>) {
+        callable();
+    } else {
+        return callable();
+    }
+}
+
+template<typename TransactionInterface, typename Callable>
 auto withDeferredTransaction(TransactionInterface &transactionInterface, Callable &&callable)
 {
     if constexpr (std::is_void_v<std::invoke_result_t<Callable>>) {