Sqlite: Improve Sqlite wrapper

It is now possible to read values at once.

for (auto [name, value] : statement.tupleValues<String, int>(1000, "foo", 20))
   ....

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

src/libs/sqlite/createtablesqlstatementbuilder.cpp

@@ -28,12 +28,11 @@
 namespace Sqlite {
 
 CreateTableSqlStatementBuilder::CreateTableSqlStatementBuilder()
-    : m_sqlStatementBuilder("CREATE TABLE IF NOT EXISTS $table($columnDefinitions)$withoutRowId"),
-      m_useWithoutRowId(false)
+    : m_sqlStatementBuilder("CREATE $temporaryTABLE $ifNotExits$table($columnDefinitions)$withoutRowId")
 {
 }
 
-void CreateTableSqlStatementBuilder::setTable(Utils::SmallString &&tableName)
+void CreateTableSqlStatementBuilder::setTableName(Utils::SmallString &&tableName)
 {
     m_sqlStatementBuilder.clear();
 
@@ -42,11 +41,11 @@ void CreateTableSqlStatementBuilder::setTable(Utils::SmallString &&tableName)
 
 void CreateTableSqlStatementBuilder::addColumn(Utils::SmallString &&columnName,
                                                ColumnType columnType,
-                                               IsPrimaryKey isPrimaryKey)
+                                               Contraint constraint)
 {
     m_sqlStatementBuilder.clear();
 
-    m_columns.emplace_back(std::move(columnName), columnType, isPrimaryKey);
+    m_columns.emplace_back(std::move(columnName), columnType, constraint);
 }
 
 void CreateTableSqlStatementBuilder::setColumns(const SqliteColumns &columns)
@@ -61,6 +60,16 @@ void CreateTableSqlStatementBuilder::setUseWithoutRowId(bool useWithoutRowId)
     m_useWithoutRowId = useWithoutRowId;
 }
 
+void CreateTableSqlStatementBuilder::setUseIfNotExists(bool useIfNotExists)
+{
+    m_useIfNotExits = useIfNotExists;
+}
+
+void CreateTableSqlStatementBuilder::setUseTemporaryTable(bool useTemporaryTable)
+{
+    m_useTemporaryTable = useTemporaryTable;
+}
+
 void CreateTableSqlStatementBuilder::clear()
 {
     m_sqlStatementBuilder.clear();
@@ -95,8 +104,11 @@ void CreateTableSqlStatementBuilder::bindColumnDefinitions() const
     for (const SqliteColumn &columns : m_columns) {
         Utils::SmallString columnDefinitionString = {columns.name(), " ", columns.typeString()};
 
-        if (columns.isPrimaryKey())
-            columnDefinitionString.append(" PRIMARY KEY");
+        switch (columns.constraint()) {
+            case Contraint::PrimaryKey: columnDefinitionString.append(" PRIMARY KEY"); break;
+            case Contraint::Unique: columnDefinitionString.append(" UNIQUE"); break;
+            case Contraint::NoConstraint: break;
+        }
 
         columnDefinitionStrings.push_back(columnDefinitionString);
     }
@@ -108,12 +120,34 @@ void CreateTableSqlStatementBuilder::bindAll() const
 {
     m_sqlStatementBuilder.bind("$table", m_tableName.clone());
 
+    bindTemporary();
+    bindIfNotExists();
     bindColumnDefinitions();
+    bindWithoutRowId();
+}
 
+void CreateTableSqlStatementBuilder::bindWithoutRowId() const
+{
     if (m_useWithoutRowId)
         m_sqlStatementBuilder.bind("$withoutRowId", " WITHOUT ROWID");
     else
         m_sqlStatementBuilder.bindEmptyText("$withoutRowId");
 }
 
+void CreateTableSqlStatementBuilder::bindIfNotExists() const
+{
+    if (m_useIfNotExits)
+        m_sqlStatementBuilder.bind("$ifNotExits", "IF NOT EXISTS ");
+    else
+        m_sqlStatementBuilder.bindEmptyText("$ifNotExits");
+}
+
+void CreateTableSqlStatementBuilder::bindTemporary() const
+{
+    if (m_useTemporaryTable)
+        m_sqlStatementBuilder.bind("$temporary", "TEMPORARY ");
+    else
+        m_sqlStatementBuilder.bindEmptyText("$temporary");
+}
+
 } // namespace Sqlite

src/libs/sqlite/createtablesqlstatementbuilder.h

@@ -35,12 +35,14 @@ class SQLITE_EXPORT CreateTableSqlStatementBuilder
 public:
     CreateTableSqlStatementBuilder();
 
-    void setTable(Utils::SmallString &&tableName);
+    void setTableName(Utils::SmallString &&tableName);
     void addColumn(Utils::SmallString &&columnName,
                    ColumnType columnType,
-                   IsPrimaryKey isPrimaryKey = IsPrimaryKey::No);
+                   Contraint constraint = Contraint::NoConstraint);
     void setColumns(const SqliteColumns &columns);
     void setUseWithoutRowId(bool useWithoutRowId);
+    void setUseIfNotExists(bool useIfNotExists);
+    void setUseTemporaryTable(bool useTemporaryTable);
 
     void clear();
     void clearColumns();
@@ -52,12 +54,17 @@ public:
 protected:
     void bindColumnDefinitions() const;
     void bindAll() const;
+    void bindWithoutRowId() const;
+    void bindIfNotExists() const;
+    void bindTemporary() const;
 
 private:
     mutable SqlStatementBuilder m_sqlStatementBuilder;
     Utils::SmallString m_tableName;
     SqliteColumns m_columns;
-    bool m_useWithoutRowId;
+    bool m_useWithoutRowId = false;
+    bool m_useIfNotExits = false;
+    bool m_useTemporaryTable = false;
 };
 
 } // namespace Sqlite

src/libs/sqlite/sqlitecolumn.h

@@ -38,17 +38,17 @@ public:
 
     SqliteColumn(Utils::SmallString &&name,
                  ColumnType type = ColumnType::Numeric,
-                 IsPrimaryKey isPrimaryKey = IsPrimaryKey::No)
+                 Contraint constraint = Contraint::NoConstraint)
         : m_name(std::move(name)),
           m_type(type),
-          m_isPrimaryKey(isPrimaryKey)
+          m_constraint(constraint)
     {}
 
     void clear()
     {
         m_name.clear();
         m_type = ColumnType::Numeric;
-        m_isPrimaryKey = IsPrimaryKey::No;
+        m_constraint = Contraint::NoConstraint;
     }
 
     void setName(Utils::SmallString &&newName)
@@ -71,14 +71,14 @@ public:
         return m_type;
     }
 
-    void setIsPrimaryKey(IsPrimaryKey isPrimaryKey)
+    void setContraint(Contraint constraint)
     {
-        m_isPrimaryKey = isPrimaryKey;
+        m_constraint = constraint;
     }
 
-    bool isPrimaryKey() const
+    Contraint constraint() const
     {
-        return m_isPrimaryKey == IsPrimaryKey::Yes;
+        return m_constraint;
     }
 
     Utils::SmallString typeString() const
@@ -98,13 +98,13 @@ public:
     {
         return first.m_name == second.m_name
             && first.m_type == second.m_type
-            && first.m_isPrimaryKey == second.m_isPrimaryKey;
+            && first.m_constraint == second.m_constraint;
     }
 
 private:
     Utils::SmallString m_name;
     ColumnType m_type = ColumnType::Numeric;
-    IsPrimaryKey m_isPrimaryKey = IsPrimaryKey::No;
+    Contraint m_constraint = Contraint::NoConstraint;
 };
 
 using SqliteColumns = std::vector<SqliteColumn>;

src/libs/sqlite/sqlitedatabase.cpp

@@ -26,6 +26,7 @@
 #include "sqlitedatabase.h"
 
 #include "sqlitetable.h"
+#include "sqlitetransaction.h"
 
 namespace Sqlite {
 
@@ -34,6 +35,12 @@ SqliteDatabase::SqliteDatabase()
 {
 }
 
+SqliteDatabase::SqliteDatabase(Utils::PathString &&databaseFilePath)
+    : m_databaseBackend(*this)
+{
+    open(std::move(databaseFilePath));
+}
+
 void SqliteDatabase::open()
 {
     m_databaseBackend.open(m_databaseFilePath, m_openMode);
@@ -61,7 +68,7 @@ bool SqliteDatabase::isOpen() const
 
 SqliteTable &SqliteDatabase::addTable()
 {
-    m_sqliteTables.emplace_back(*this);
+    m_sqliteTables.emplace_back();
 
     return m_sqliteTables.back();
 }
@@ -118,8 +125,12 @@ void SqliteDatabase::execute(Utils::SmallStringView sqlStatement)
 
 void SqliteDatabase::initializeTables()
 {
+    SqliteImmediateTransaction<SqliteDatabase> transaction(*this);
+
     for (SqliteTable &table : m_sqliteTables)
-        table.initialize();
+        table.initialize(*this);
+
+    transaction.commit();
 }
 
 SqliteDatabaseBackend &SqliteDatabase::backend()

src/libs/sqlite/sqlitedatabase.h

@@ -37,12 +37,14 @@ namespace Sqlite {
 
 class SQLITE_EXPORT SqliteDatabase
 {
+    template <typename Database>
     friend class SqliteAbstractTransaction;
     friend class SqliteStatement;
     friend class SqliteBackend;
 
 public:
     SqliteDatabase();
+    SqliteDatabase(Utils::PathString &&databaseFilePath);
 
     SqliteDatabase(const SqliteDatabase &) = delete;
     bool operator=(const SqliteDatabase &) = delete;

src/libs/sqlite/sqlitedatabasebackend.cpp

@@ -38,14 +38,6 @@
 
 #include "sqlite3.h"
 
-#if defined(Q_OS_DARWIN) && defined(Q_CC_GNU)
-#define QTC_THREAD_LOCAL __thread
-#else
-#define QTC_THREAD_LOCAL thread_local
-#endif
-
-#define SIZE_OF_BYTEARRAY_ARRAY(array) sizeof(array)/sizeof(QByteArray)
-
 namespace Sqlite {
 
 SqliteDatabaseBackend::SqliteDatabaseBackend(SqliteDatabase &database)

src/libs/sqlite/sqliteglobal.h

@@ -37,6 +37,8 @@
 #  define SQLITE_EXPORT Q_DECL_IMPORT
 #endif
 
+namespace Sqlite {
+
 enum class ColumnType : char
 {
     Numeric,
@@ -46,10 +48,11 @@ enum class ColumnType : char
     None
 };
 
-enum class IsPrimaryKey : char
+enum class Contraint : char
 {
-    No,
-    Yes
+    NoConstraint,
+    PrimaryKey,
+    Unique
 };
 
 enum class ColumnConstraint : char
@@ -84,3 +87,5 @@ enum TextEncoding : char
 #endif
 
 };
+
+} // namespace Sqlite

src/libs/sqlite/sqlitereadstatement.h

@@ -37,6 +37,8 @@ public:
     using SqliteStatement::next;
     using SqliteStatement::reset;
     using SqliteStatement::value;
+    using SqliteStatement::structValues;
+    using SqliteStatement::tupleValues;
     using SqliteStatement::text;
     using SqliteStatement::values;
     using SqliteStatement::columnCount;

src/libs/sqlite/sqlitereadwritestatement.h

@@ -48,6 +48,8 @@ public:
     using SqliteStatement::value;
     using SqliteStatement::text;
     using SqliteStatement::values;
+    using SqliteStatement::structValues;
+    using SqliteStatement::tupleValues;
     using SqliteStatement::columnCount;
     using SqliteStatement::columnNames;
     using SqliteStatement::toValue;

src/libs/sqlite/sqlitestatement.cpp

@@ -29,13 +29,11 @@
 #include "sqlitedatabasebackend.h"
 #include "sqliteexception.h"
 
-#include <QMutex>
-#include <QtGlobal>
-#include <QVariant>
-#include <QWaitCondition>
-
 #include "sqlite3.h"
 
+#include <condition_variable>
+#include <mutex>
+
 #if defined(__GNUC__)
 #  pragma GCC diagnostic ignored "-Wignored-qualifiers"
 #endif
@@ -61,8 +59,8 @@ void SqliteStatement::deleteCompiledStatement(sqlite3_stmt *compiledStatement)
         sqlite3_finalize(compiledStatement);
 }
 
-class UnlockNotification {
-
+class UnlockNotification
+{
 public:
     static void unlockNotifyCallBack(void **arguments, int argumentCount)
     {
@@ -74,27 +72,24 @@ public:
 
     void wakeupWaitCondition()
     {
-        mutex.lock();
-        fired = 1;
-        waitCondition.wakeAll();
-        mutex.unlock();
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            m_fired = 1;
+        }
+        m_waitCondition.notify_all();
     }
 
     void wait()
     {
-        mutex.lock();
+        std::unique_lock<std::mutex> lock(m_mutex);
 
-        if (!fired) {
-            waitCondition.wait(&mutex);
-        }
-
-        mutex.unlock();
+        m_waitCondition.wait(lock, [&] () { return m_fired; });
     }
 
 private:
-    bool fired = false;
-    QWaitCondition waitCondition;
-    QMutex mutex;
+    bool m_fired = false;
+    std::condition_variable m_waitCondition;
+    std::mutex m_mutex;
 };
 
 void SqliteStatement::waitForUnlockNotify() const
@@ -143,6 +138,7 @@ void SqliteStatement::step() const
 void SqliteStatement::execute() const
 {
     next();
+    reset();
 }
 
 int SqliteStatement::columnCount() const
@@ -168,7 +164,7 @@ void SqliteStatement::bind(int index, int value)
          throwException("SqliteStatement::bind: cant' bind 32 bit integer!");
 }
 
-void SqliteStatement::bind(int index, qint64 value)
+void SqliteStatement::bind(int index, long long value)
 {
      int resultCode = sqlite3_bind_int64(m_compiledStatement.get(), index, value);
      if (resultCode != SQLITE_OK)
@@ -198,7 +194,8 @@ void SqliteStatement::bind(Utils::SmallStringView name, Type value)
 }
 
 template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, int value);
-template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, qint64 value);
+template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, long value);
+template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, long long value);
 template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, double value);
 template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, Utils::SmallStringView text);
 
@@ -363,21 +360,23 @@ SqliteDatabase &SqliteStatement::database() const
     return m_database;
 }
 
-static Utils::SmallString textForColumn(sqlite3_stmt *sqlStatment, int column)
+template <typename StringType>
+static StringType textForColumn(sqlite3_stmt *sqlStatment, int column)
 {
     const char *text =  reinterpret_cast<const char*>(sqlite3_column_text(sqlStatment, column));
     std::size_t size = std::size_t(sqlite3_column_bytes(sqlStatment, column));
 
-    return Utils::SmallString(text, size);
+    return StringType(text, size);
 }
 
-static Utils::SmallString convertToTextForColumn(sqlite3_stmt *sqlStatment, int column)
+template <typename StringType>
+static StringType convertToTextForColumn(sqlite3_stmt *sqlStatment, int column)
 {
     int dataType = sqlite3_column_type(sqlStatment, column);
     switch (dataType) {
         case SQLITE_INTEGER:
         case SQLITE_FLOAT:
-        case SQLITE3_TEXT: return textForColumn(sqlStatment, column);
+        case SQLITE3_TEXT: return textForColumn<StringType>(sqlStatment, column);
         case SQLITE_BLOB:
         case SQLITE_NULL: return {};
     }
@@ -394,7 +393,13 @@ int SqliteStatement::value<int>(int column) const
 }
 
 template<>
-qint64 SqliteStatement::value<qint64>(int column) const
+long SqliteStatement::value<long>(int column) const
+{
+    return long(value<long long>(column));
+}
+
+template<>
+long long SqliteStatement::value<long long>(int column) const
 {
     checkIfIsReadyToFetchValues();
     checkColumnIsValid(column);
@@ -409,14 +414,17 @@ double SqliteStatement::value<double>(int column) const
     return sqlite3_column_double(m_compiledStatement.get(), column);
 }
 
-template<>
+template<typename StringType>