Sqlite: Extent Statement::values for other container

You can now use QList and QVarLenghtArray for values. The later is quite
interesting because it is not allocating for a provided capacity.

So you can now write:

statement.valuesWithTransaction<QVarLenghtArray<int, 1024>>();

And in almost all case no expensive memory is allocated. With the help
of NRVO there should be no copy too.

That is very useful for temporary values which are transformed into a
different type.

The capacity changed to an template parameter too:

statement.valuesWithTransaction<int, 1024>();

That is more clear than before:

statement.valuesWithTransaction<int>(1024);

Change-Id: I6d8d10ed9db0cc37f0579353a416e36e23c30415
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>

4 files changed, 42 insertions, 13 deletions

diff --git a/src/libs/sqlite/sqlitebasestatement.h b/src/libs/sqlite/sqlitebasestatement.h
index 54d08260b7..fd57b4f8f1 100644
--- a/src/libs/sqlite/sqlitebasestatement.h
+++ b/src/libs/sqlite/sqlitebasestatement.h
@@ -23,6 +23,7 @@
 #include <optional>
 #include <tuple>
 #include <type_traits>
+#include <vector>
 
 using std::int64_t;
 
@@ -172,12 +173,28 @@ public:
         BaseStatement::next();
     }
 
-    template<typename ResultType, typename... QueryTypes>
-    auto values(std::size_t reserveSize, const QueryTypes &...queryValues)
+    template<typename T>
+    struct is_container : std::false_type
+    {};
+    template<typename... Args>
+    struct is_container<std::vector<Args...>> : std::true_type
+    {};
+    template<typename... Args>
+    struct is_container<QList<Args...>> : std::true_type
+    {};
+    template<typename T, qsizetype Prealloc>
+    struct is_container<QVarLengthArray<T, Prealloc>> : std::true_type
+    {};
+
+    template<typename Container,
+             std::size_t capacity = 32,
+             typename = std::enable_if_t<is_container<Container>::value>,
+             typename... QueryTypes>
+    auto values(const QueryTypes &...queryValues)
     {
         Resetter resetter{this};
-        std::vector<ResultType> resultValues;
-        resultValues.reserve(std::max(reserveSize, m_maximumResultCount));
+        Container resultValues;
+        resultValues.reserve(std::max(capacity, m_maximumResultCount));
 
         bindValues(queryValues...);
 
@@ -189,6 +206,16 @@ public:
         return resultValues;
     }
 
+    template<typename ResultType,
+             std::size_t capacity = 32,
+             template<typename...> typename Container = std::vector,
+             typename = std::enable_if_t<!is_container<ResultType>::value>,
+             typename... QueryTypes>
+    auto values(const QueryTypes &...queryValues)
+    {
+        return values<Container<ResultType>, capacity>(queryValues...);
+    }
+
     template<typename ResultType, typename... QueryTypes>
     auto value(const QueryTypes &...queryValues)
     {
diff --git a/src/libs/sqlite/sqlitereadstatement.h b/src/libs/sqlite/sqlitereadstatement.h
index 3df47efc74..4f8091598b 100644
--- a/src/libs/sqlite/sqlitereadstatement.h
+++ b/src/libs/sqlite/sqlitereadstatement.h
@@ -47,11 +47,11 @@ public:
         });
     }
 
-    template<typename ResultType, typename... QueryTypes>
-    auto valuesWithTransaction(std::size_t reserveSize, const QueryTypes &...queryValues)
+    template<typename ResultType, std::size_t capacity = 32, typename... QueryTypes>
+    auto valuesWithTransaction(const QueryTypes &...queryValues)
     {
         return withDeferredTransaction(Base::database(), [&] {
-            return Base::template values<ResultType>(reserveSize, queryValues...);
+            return Base::template values<ResultType, capacity>(queryValues...);
         });
     }
 
diff --git a/src/libs/sqlite/sqlitereadwritestatement.h b/src/libs/sqlite/sqlitereadwritestatement.h
index 08f1aeda04..2b3e6c3247 100644
--- a/src/libs/sqlite/sqlitereadwritestatement.h
+++ b/src/libs/sqlite/sqlitereadwritestatement.h
@@ -47,11 +47,13 @@ public:
         });
     }
 
-    template<typename ResultType, typename... QueryTypes>
-    auto valuesWithTransaction(std::size_t reserveSize, const QueryTypes &...queryValues)
+    template<typename ResultType,
+             std::size_t capacity = 32,
+             typename... QueryTypes>
+    auto valuesWithTransaction(const QueryTypes &...queryValues)
     {
         return withImmediateTransaction(Base::database(), [&] {
-            return Base::template values<ResultType>(reserveSize, queryValues...);
+            return Base::template values<ResultType, capacity>(queryValues...);
         });
     }
 
diff --git a/src/libs/sqlite/sqlitesessions.cpp b/src/libs/sqlite/sqlitesessions.cpp
index 96119cd20f..fd81b17ede 100644
--- a/src/libs/sqlite/sqlitesessions.cpp
+++ b/src/libs/sqlite/sqlitesessions.cpp
@@ -110,7 +110,7 @@ void Sessions::revert()
                                                                " ORDER BY id DESC"}),
                                       database};
 
-    auto changeSets = selectChangeSets.values<SessionChangeSet>(1024);
+    auto changeSets = selectChangeSets.values<SessionChangeSet, 1024>();
 
     for (auto &changeSet : changeSets) {
         int resultCode = sqlite3changeset_apply_v2(database.backend().sqliteDatabaseHandle(),
@@ -134,7 +134,7 @@ void Sessions::apply()
                                                                " ORDER BY id"}),
                                       database};
 
-    auto changeSets = selectChangeSets.values<SessionChangeSet>(1024);
+    auto changeSets = selectChangeSets.values<SessionChangeSet, 1024>();
 
     for (auto &changeSet : changeSets) {
         int resultCode = sqlite3changeset_apply_v2(database.backend().sqliteDatabaseHandle(),
@@ -170,7 +170,7 @@ SessionChangeSets Sessions::changeSets() const
                                                                " ORDER BY id DESC"}),
                                       database};
 
-    return selectChangeSets.values<SessionChangeSet>(1024);
+    return selectChangeSets.values<SessionChangeSet, 1024>();
 }
 
 void Sessions::Deleter::operator()(sqlite3_session *session)