Sqlite: Remove virtual interface dependency

With C++ 17 it is possible to deduce the template argument from the
contructor parameter(CTAD). We then do not call anymore a virtual
function but a normal function.

Change-Id: I61c3ce22322c66b256afab278e768014401b08cc
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

6 files changed, 131 insertions, 40 deletions

diff --git a/src/libs/sqlite/sqlitebasestatement.h b/src/libs/sqlite/sqlitebasestatement.h
index aa7fb11c7eb..ef098d42244 100644
--- a/src/libs/sqlite/sqlitebasestatement.h
+++ b/src/libs/sqlite/sqlitebasestatement.h
@@ -59,6 +59,8 @@ enum class Type : char { Invalid, Integer, Float, Text, Blob, Null };
 class SQLITE_EXPORT BaseStatement
 {
 public:
+    using Database = ::Sqlite::Database;
+
     explicit BaseStatement(Utils::SmallStringView sqlStatement, Database &database);
 
     BaseStatement(const BaseStatement &) = delete;
@@ -403,7 +405,7 @@ public:
         }
 
     private:
-        DeferredTransaction m_transaction;
+        DeferredTransaction<typename BaseStatement::Database> m_transaction;
         Resetter resetter;
     };
 
diff --git a/src/libs/sqlite/sqlitedatabase.h b/src/libs/sqlite/sqlitedatabase.h
index b379e2f80f1..3804d6c7a30 100644
--- a/src/libs/sqlite/sqlitedatabase.h
+++ b/src/libs/sqlite/sqlitedatabase.h
@@ -163,7 +163,6 @@ public:
     void lock() override;
     void unlock() override;
 
-private:
     void deferredBegin() override;
     void immediateBegin() override;
     void exclusiveBegin() override;
@@ -173,6 +172,7 @@ private:
     void sessionCommit() override;
     void sessionRollback() override;
 
+private:
     void initializeTables();
     void registerTransactionStatements();
     void deleteTransactionStatements();
diff --git a/src/libs/sqlite/sqlitetransaction.h b/src/libs/sqlite/sqlitetransaction.h
index 09a60446d26..1941548877b 100644
--- a/src/libs/sqlite/sqlitetransaction.h
+++ b/src/libs/sqlite/sqlitetransaction.h
@@ -59,9 +59,12 @@ protected:
     ~TransactionInterface() = default;
 };
 
+template<typename TransactionInterface>
 class AbstractTransaction
 {
 public:
+    using Transaction = TransactionInterface;
+
     AbstractTransaction(const AbstractTransaction &) = delete;
     AbstractTransaction &operator=(const AbstractTransaction &) = delete;
 
@@ -87,11 +90,14 @@ protected:
     bool m_rollback = false;
 };
 
+template<typename TransactionInterface>
 class AbstractThrowingSessionTransaction
 {
 public:
-    AbstractThrowingSessionTransaction(const AbstractTransaction &) = delete;
-    AbstractThrowingSessionTransaction &operator=(const AbstractTransaction &) = delete;
+    using Transaction = TransactionInterface;
+
+    AbstractThrowingSessionTransaction(const AbstractThrowingSessionTransaction &) = delete;
+    AbstractThrowingSessionTransaction &operator=(const AbstractThrowingSessionTransaction &) = delete;
 
     void commit()
     {
@@ -123,16 +129,19 @@ protected:
     bool m_rollback = false;
 };
 
-class AbstractThrowingTransaction : public AbstractTransaction
+template<typename TransactionInterface>
+class AbstractThrowingTransaction : public AbstractTransaction<TransactionInterface>
 {
+    using Base = AbstractTransaction<TransactionInterface>;
+
 public:
     AbstractThrowingTransaction(const AbstractThrowingTransaction &) = delete;
     AbstractThrowingTransaction &operator=(const AbstractThrowingTransaction &) = delete;
     ~AbstractThrowingTransaction() noexcept(false)
     {
         try {
-            if (m_rollback)
-                m_interface.rollback();
+            if (Base::m_rollback)
+                Base::m_interface.rollback();
         } catch (...) {
             if (!std::uncaught_exceptions())
                 throw;
@@ -141,37 +150,40 @@ public:
 
 protected:
     AbstractThrowingTransaction(TransactionInterface &transactionInterface)
-        : AbstractTransaction(transactionInterface)
+        : AbstractTransaction<TransactionInterface>(transactionInterface)
     {
     }
 };
 
-class AbstractNonThrowingDestructorTransaction : public AbstractTransaction
+template<typename TransactionInterface>
+class AbstractNonThrowingDestructorTransaction : public AbstractTransaction<TransactionInterface>
 {
+    using Base = AbstractTransaction<TransactionInterface>;
+
 public:
     AbstractNonThrowingDestructorTransaction(const AbstractNonThrowingDestructorTransaction &) = delete;
     AbstractNonThrowingDestructorTransaction &operator=(const AbstractNonThrowingDestructorTransaction &) = delete;
     ~AbstractNonThrowingDestructorTransaction()
     {
         try {
-            if (m_rollback)
-                m_interface.rollback();
+            if (Base::m_rollback)
+                Base::m_interface.rollback();
         } catch (...) {
         }
     }
 
 protected:
     AbstractNonThrowingDestructorTransaction(TransactionInterface &transactionInterface)
-        : AbstractTransaction(transactionInterface)
+        : AbstractTransaction<TransactionInterface>(transactionInterface)
     {
     }
 };
 
-template <typename BaseTransaction>
-class BasicDeferredTransaction final : public BaseTransaction
+template<typename BaseTransaction>
+class BasicDeferredTransaction : public BaseTransaction
 {
 public:
-    BasicDeferredTransaction(TransactionInterface &transactionInterface)
+    BasicDeferredTransaction(typename BaseTransaction::Transaction &transactionInterface)
         : BaseTransaction(transactionInterface)
     {
         transactionInterface.deferredBegin();
@@ -183,14 +195,38 @@ public:
     }
 };
 
-using DeferredTransaction = BasicDeferredTransaction<AbstractThrowingTransaction>;
-using DeferredNonThrowingDestructorTransaction = BasicDeferredTransaction<AbstractNonThrowingDestructorTransaction>;
+template<typename TransactionInterface>
+class DeferredTransaction final
+    : public BasicDeferredTransaction<AbstractThrowingTransaction<TransactionInterface>>
+{
+    using Base = BasicDeferredTransaction<AbstractThrowingTransaction<TransactionInterface>>;
+
+public:
+    using Base::Base;
+};
+
+template<typename TransactionInterface>
+DeferredTransaction(TransactionInterface &) -> DeferredTransaction<TransactionInterface>;
 
-template <typename BaseTransaction>
-class BasicImmediateTransaction final : public BaseTransaction
+template<typename TransactionInterface>
+class DeferredNonThrowingDestructorTransaction final
+    : public BasicDeferredTransaction<AbstractNonThrowingDestructorTransaction<TransactionInterface>>
+{
+    using Base = BasicDeferredTransaction<AbstractNonThrowingDestructorTransaction<TransactionInterface>>;
+
+public:
+    using Base::Base;
+};
+
+template<typename TransactionInterface>
+DeferredNonThrowingDestructorTransaction(TransactionInterface &)
+    -> DeferredNonThrowingDestructorTransaction<TransactionInterface>;
+
+template<typename BaseTransaction>
+class BasicImmediateTransaction : public BaseTransaction
 {
 public:
-    BasicImmediateTransaction(TransactionInterface &transactionInterface)
+    BasicImmediateTransaction(typename BaseTransaction::Transaction &transactionInterface)
         : BaseTransaction(transactionInterface)
     {
         transactionInterface.immediateBegin();
@@ -202,14 +238,38 @@ public:
     }
 };
 
-using ImmediateTransaction = BasicImmediateTransaction<AbstractThrowingTransaction>;
-using ImmediateNonThrowingDestructorTransaction = BasicImmediateTransaction<AbstractNonThrowingDestructorTransaction>;
+template<typename TransactionInterface>
+class ImmediateTransaction final
+    : public BasicImmediateTransaction<AbstractThrowingTransaction<TransactionInterface>>
+{
+    using Base = BasicImmediateTransaction<AbstractThrowingTransaction<TransactionInterface>>;
+
+public:
+    using Base::Base;
+};
+
+template<typename TransactionInterface>
+ImmediateTransaction(TransactionInterface &) -> ImmediateTransaction<TransactionInterface>;
 
-template <typename BaseTransaction>
-class BasicExclusiveTransaction final : public BaseTransaction
+template<typename TransactionInterface>
+class ImmediateNonThrowingDestructorTransaction final
+    : public BasicImmediateTransaction<AbstractNonThrowingDestructorTransaction<TransactionInterface>>
+{
+    using Base = BasicImmediateTransaction<AbstractNonThrowingDestructorTransaction<TransactionInterface>>;
+
+public:
+    using Base::Base;
+};
+
+template<typename TransactionInterface>
+ImmediateNonThrowingDestructorTransaction(TransactionInterface &)
+    -> ImmediateNonThrowingDestructorTransaction<TransactionInterface>;
+
+template<typename BaseTransaction>
+class BasicExclusiveTransaction : public BaseTransaction
 {
 public:
-    BasicExclusiveTransaction(TransactionInterface &transactionInterface)
+    BasicExclusiveTransaction(typename BaseTransaction::Transaction &transactionInterface)
         : BaseTransaction(transactionInterface)
     {
         transactionInterface.exclusiveBegin();
@@ -221,24 +281,51 @@ public:
     }
 };
 
-using ExclusiveTransaction = BasicExclusiveTransaction<AbstractThrowingTransaction>;
-using ExclusiveNonThrowingDestructorTransaction
-    = BasicExclusiveTransaction<AbstractNonThrowingDestructorTransaction>;
+template<typename TransactionInterface>
+class ExclusiveTransaction final
+    : public BasicExclusiveTransaction<AbstractThrowingTransaction<TransactionInterface>>
+{
+    using Base = BasicExclusiveTransaction<AbstractThrowingTransaction<TransactionInterface>>;
+
+public:
+    using Base::Base;
+};
+
+template<typename TransactionInterface>
+ExclusiveTransaction(TransactionInterface &) -> ExclusiveTransaction<TransactionInterface>;
 
-class ImmediateSessionTransaction final : public AbstractThrowingSessionTransaction
+template<typename TransactionInterface>
+class ExclusiveNonThrowingDestructorTransaction final
+    : public BasicExclusiveTransaction<AbstractNonThrowingDestructorTransaction<TransactionInterface>>
 {
+    using Base = BasicExclusiveTransaction<AbstractNonThrowingDestructorTransaction<TransactionInterface>>;
+
+public:
+    using Base::Base;
+};
+
+template<typename TransactionInterface>
+ExclusiveNonThrowingDestructorTransaction(TransactionInterface &)
+    -> ExclusiveNonThrowingDestructorTransaction<TransactionInterface>;
+
+template<typename TransactionInterface>
+class ImmediateSessionTransaction final
+    : public AbstractThrowingSessionTransaction<TransactionInterface>
+{
+    using Base = AbstractThrowingSessionTransaction<TransactionInterface>;
+
 public:
-    ImmediateSessionTransaction(TransactionInterface &transactionInterface)
-        : AbstractThrowingSessionTransaction(transactionInterface)
+    ImmediateSessionTransaction(typename Base::Transaction &transactionInterface)
+        : AbstractThrowingSessionTransaction<TransactionInterface>(transactionInterface)
     {
         transactionInterface.immediateSessionBegin();
     }
 
-    ~ImmediateSessionTransaction()
-    {
-        AbstractThrowingSessionTransaction::m_rollback
-            = !AbstractThrowingSessionTransaction::m_isAlreadyCommited;
-    }
+    ~ImmediateSessionTransaction() { Base::m_rollback = !Base::m_isAlreadyCommited; }
 };
 
+template<typename TransactionInterface>
+ImmediateSessionTransaction(TransactionInterface &)
+    -> ImmediateSessionTransaction<TransactionInterface>;
+
 } // namespace Sqlite
diff --git a/src/plugins/qmldesigner/designercore/imagecache/imagecachestorage.h b/src/plugins/qmldesigner/designercore/imagecache/imagecachestorage.h
index 2f7e2eb93e6..c245f31d545 100644
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachestorage.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachestorage.h
@@ -273,7 +273,7 @@ private:
 public:
     DatabaseType &database;
     Initializer initializer{database};
-    Sqlite::ImmediateNonThrowingDestructorTransaction transaction{database};
+    Sqlite::ImmediateNonThrowingDestructorTransaction<DatabaseType> transaction{database};
     mutable ReadStatement<1, 2> selectImageStatement{
         "SELECT image FROM images WHERE name=?1 AND mtime >= ?2", database};
     mutable ReadStatement<1, 2> selectSmallImageStatement{
diff --git a/tests/unit/unittest/mocksqlitestatement.h b/tests/unit/unittest/mocksqlitestatement.h
index 6e10384fbcc..82ddc187a5f 100644
--- a/tests/unit/unittest/mocksqlitestatement.h
+++ b/tests/unit/unittest/mocksqlitestatement.h
@@ -34,6 +34,8 @@
 class BaseMockSqliteStatement
 {
 public:
+    using Database = SqliteDatabaseMock;
+
     BaseMockSqliteStatement() = default;
     BaseMockSqliteStatement(SqliteDatabaseMock &databaseMock)
         : m_databaseMock{&databaseMock}
@@ -112,9 +114,9 @@ Utils::PathString BaseMockSqliteStatement::fetchValue<Utils::PathString>(int col
 
 template<int ResultCount = 1, int BindParameterCount = 0>
 class MockSqliteStatement
-    : public Sqlite::StatementImplementation<NiceMock<BaseMockSqliteStatement>, ResultCount, BindParameterCount>
+    : public Sqlite::StatementImplementation<BaseMockSqliteStatement, ResultCount, BindParameterCount>
 {
-    using Base = Sqlite::StatementImplementation<NiceMock<BaseMockSqliteStatement>, ResultCount, BindParameterCount>;
+    using Base = Sqlite::StatementImplementation<BaseMockSqliteStatement, ResultCount, BindParameterCount>;
 
 public:
     explicit MockSqliteStatement(SqliteDatabaseMock &databaseMock)
diff --git a/tests/unit/unittest/sqlitealgorithms-test.cpp b/tests/unit/unittest/sqlitealgorithms-test.cpp
index a1647979fa8..6a494696615 100644
--- a/tests/unit/unittest/sqlitealgorithms-test.cpp
+++ b/tests/unit/unittest/sqlitealgorithms-test.cpp
@@ -115,7 +115,7 @@ public:
 
 protected:
     Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
-    Sqlite::ImmediateTransaction transaction{database};
+    Sqlite::ImmediateTransaction<Sqlite::Database> transaction{database};
     Initializer initializer{database};
     Sqlite::ReadStatement<2> selectViewsStatement{"SELECT key, value FROM data ORDER BY key",
                                                   database};