Store connection configuration as key value pairs

Add migration for the sqlite database.
Because the Qt SQL library is a bit hard to work with use sqlite through custom wrapper.

pglablib/sqlite/SQLiteConnection.h

@@ -0,0 +1,156 @@
+#pragma once
+
+#include "sqlite3.h"
+#include <qstring.h>
+#include <stdexcept>
+
+class SQLiteException : public std::runtime_error
+{
+public:
+    explicit SQLiteException(const char* msg)
+        : std::runtime_error(msg)
+    {}
+};
+
+class SQLiteConnection;
+
+class SQLitePreparedStatement
+{
+public:
+    SQLitePreparedStatement() = default;
+    SQLitePreparedStatement(const SQLitePreparedStatement &) = delete;
+    SQLitePreparedStatement(SQLitePreparedStatement&& rhs);
+    SQLitePreparedStatement &operator=(SQLitePreparedStatement&& rhs);
+
+    ~SQLitePreparedStatement();
+
+    void Open(SQLiteConnection &db, const char *query);
+    void Open(SQLiteConnection &db, const QString &query);
+
+    void Bind(int index, const char *s, int length = 0);
+    void Bind(int index, const QString &s);
+    void Bind(int index, int v);
+
+    const char* ColumnCharPtr(int col);
+    QString ColumnText(int col);
+    int ColumnInteger(int col);
+
+    bool Step();
+
+    void Reset()
+    {
+        sqlite3_reset(pStatement);
+    }
+
+private:
+    sqlite3_stmt *pStatement = nullptr;
+
+    void Free()
+    {
+        if (pStatement != nullptr)
+        {
+            sqlite3_finalize(pStatement);
+            pStatement = nullptr;
+        }
+    }
+};
+
+
+class SQLiteTransaction
+{
+public:
+    explicit SQLiteTransaction(SQLiteConnection &db);
+    SQLiteTransaction(const SQLiteTransaction&&) = delete;
+
+    ~SQLiteTransaction();
+
+    void Commit();
+    void Rollback();
+private:
+    SQLiteConnection &db;
+    bool inTransaction = false;
+    void UncheckedRollback();
+};
+
+class SQLiteConnection
+{
+public:
+    SQLiteConnection() = default;
+    SQLiteConnection(const SQLiteConnection&) = delete;
+
+    SQLiteConnection(SQLiteConnection&& rhs);
+
+    SQLiteConnection& operator=(const SQLiteConnection &) = delete;
+
+    SQLiteConnection& operator=(SQLiteConnection && rhs);
+
+    ~SQLiteConnection()
+    {
+        if (pDb)
+        {
+            sqlite3_close(pDb);
+        }
+    }
+
+    void Open(const char *filename)
+    {
+        int result = sqlite3_open(filename, &pDb);
+        CheckResult(result);
+    }
+
+    void Open(QString filename)
+    {
+        int result = sqlite3_open16((void*)filename.data(), &pDb);
+        CheckResult(result);
+    }
+
+    void CheckResult(int result)
+    {
+        if (result == SQLITE_OK)
+            return;
+
+        if (pDb == nullptr)
+        {
+            const char * msg = sqlite3_errstr(result);
+            throw SQLiteException(msg);
+        }
+        const char * msg = sqlite3_errmsg(pDb);
+        throw SQLiteException(msg);
+    }
+
+    SQLitePreparedStatement Prepare(const char* query)
+    {
+        SQLitePreparedStatement stmt;
+        stmt.Open(*this, query);
+        return stmt;
+    }
+
+    SQLitePreparedStatement Prepare(const QString &query)
+    {
+        SQLitePreparedStatement stmt;
+        stmt.Open(*this, query);
+        return stmt;
+    }
+
+    void Exec(const char* query)
+    {
+        SQLitePreparedStatement stmt = Prepare(query);
+        stmt.Step();
+    }
+
+    void Exec(QString query)
+    {
+        SQLitePreparedStatement stmt = Prepare(query.toUtf8().constData());
+        stmt.Step();
+    }
+
+    int64_t LastInsertRowId()
+    {
+        return sqlite3_last_insert_rowid(pDb);
+    }
+
+private:
+    sqlite3 *pDb = nullptr;
+
+    friend class SQLitePreparedStatement;
+};