diff --git a/src/libs/sqlite/columndefinition.h b/src/libs/sqlite/columndefinition.h
index 66dbf64ab576444b5110f24adf51e596a26229e7..5390228dfa6f0a972b1cc806425340145e7edf37 100644
--- a/src/libs/sqlite/columndefinition.h
+++ b/src/libs/sqlite/columndefinition.h
@@ -26,19 +26,22 @@
 #pragma once
 
 #include "sqliteglobal.h"
-#include "utf8string.h"
+
+#include <utils/smallstring.h>
+
+#include <vector>
 
 namespace Sqlite {
 
 class ColumnDefinition
 {
 public:
-    void setName(const Utf8String &name)
+    void setName(Utils::SmallString &&name)
     {
-        m_name = name;
+        m_name = std::move(name);
     }
 
-    const Utf8String &name() const
+    const Utils::SmallString &name() const
     {
         return m_name;
     }
@@ -53,14 +56,14 @@ public:
         return m_type;
     }
 
-    Utf8String typeString() const
+    Utils::SmallString typeString() const
     {
         switch (m_type) {
-            case ColumnType::None: return Utf8String();
-            case ColumnType::Numeric: return Utf8StringLiteral("NUMERIC");
-            case ColumnType::Integer: return Utf8StringLiteral("INTEGER");
-            case ColumnType::Real: return Utf8StringLiteral("REAL");
-            case ColumnType::Text: return Utf8StringLiteral("TEXT");
+            case ColumnType::None: return {};
+            case ColumnType::Numeric: return "NUMERIC";
+            case ColumnType::Integer: return "INTEGER";
+            case ColumnType::Real: return "REAL";
+            case ColumnType::Text: return "TEXT";
         }
 
         Q_UNREACHABLE();
@@ -77,9 +80,11 @@ public:
     }
 
 private:
-    Utf8String m_name;
+    Utils::SmallString m_name;
     ColumnType m_type;
     bool m_isPrimaryKey = false;
 };
 
+using ColumnDefinitions = std::vector<ColumnDefinition>;
+
 } // namespace Sqlite
diff --git a/src/libs/sqlite/createtablesqlstatementbuilder.cpp b/src/libs/sqlite/createtablesqlstatementbuilder.cpp
index cefccf9c423b4f18bb00741d368e994f444a38c6..5b517610ba442d25269c61f781074bd56ddf6261 100644
--- a/src/libs/sqlite/createtablesqlstatementbuilder.cpp
+++ b/src/libs/sqlite/createtablesqlstatementbuilder.cpp
@@ -25,47 +25,45 @@
 
 #include "createtablesqlstatementbuilder.h"
 
-#include "utf8stringvector.h"
-
 namespace Sqlite {
 
 CreateTableSqlStatementBuilder::CreateTableSqlStatementBuilder()
-    : m_sqlStatementBuilder(Utf8StringLiteral("CREATE TABLE IF NOT EXISTS $table($columnDefinitions)$withoutRowId")),
+    : m_sqlStatementBuilder("CREATE TABLE IF NOT EXISTS $table($columnDefinitions)$withoutRowId"),
       m_useWithoutRowId(false)
 {
 }
 
-void CreateTableSqlStatementBuilder::setTable(const Utf8String &tableName)
+void CreateTableSqlStatementBuilder::setTable(Utils::SmallString &&tableName)
 {
     m_sqlStatementBuilder.clear();
 
-    this->m_tableName = tableName;
+    this->m_tableName = std::move(tableName);
 }
 
-void CreateTableSqlStatementBuilder::addColumnDefinition(const Utf8String &columnName,
+void CreateTableSqlStatementBuilder::addColumnDefinition(Utils::SmallString &&columnName,
                                                          ColumnType columnType,
                                                          bool isPrimaryKey)
 {
     m_sqlStatementBuilder.clear();
 
     ColumnDefinition columnDefinition;
-    columnDefinition.setName(columnName);
+    columnDefinition.setName(std::move(columnName));
     columnDefinition.setType(columnType);
     columnDefinition.setIsPrimaryKey(isPrimaryKey);
 
-    m_columnDefinitions.append(columnDefinition);
+    m_columnDefinitions.push_back(columnDefinition);
 }
 
-void CreateTableSqlStatementBuilder::setColumnDefinitions(const QVector<ColumnDefinition> &columnDefinitions)
+void CreateTableSqlStatementBuilder::setColumnDefinitions(ColumnDefinitions &&columnDefinitions)
 {
     m_sqlStatementBuilder.clear();
 
-    this->m_columnDefinitions = columnDefinitions;
+    m_columnDefinitions = std::move(columnDefinitions);
 }
 
 void CreateTableSqlStatementBuilder::setUseWithoutRowId(bool useWithoutRowId)
 {
-    this->m_useWithoutRowId = useWithoutRowId;
+    m_useWithoutRowId = useWithoutRowId;
 }
 
 void CreateTableSqlStatementBuilder::clear()
@@ -82,7 +80,7 @@ void CreateTableSqlStatementBuilder::clearColumns()
     m_columnDefinitions.clear();
 }
 
-Utf8String CreateTableSqlStatementBuilder::sqlStatement() const
+Utils::SmallStringView CreateTableSqlStatementBuilder::sqlStatement() const
 {
     if (!m_sqlStatementBuilder.isBuild())
         bindAll();
@@ -92,35 +90,35 @@ Utf8String CreateTableSqlStatementBuilder::sqlStatement() const
 
 bool CreateTableSqlStatementBuilder::isValid() const
 {
-    return m_tableName.hasContent() && !m_columnDefinitions.isEmpty();
+    return m_tableName.hasContent() && !m_columnDefinitions.empty();
 }
 
 void CreateTableSqlStatementBuilder::bindColumnDefinitions() const
 {
-    Utf8StringVector columnDefinitionStrings;
+    Utils::SmallStringVector columnDefinitionStrings;
 
-    foreach (const ColumnDefinition &columnDefinition, m_columnDefinitions) {
-        Utf8String columnDefinitionString = columnDefinition.name() + Utf8StringLiteral(" ") + columnDefinition.typeString();
+    for (const ColumnDefinition &columnDefinition : m_columnDefinitions) {
+        Utils::SmallString columnDefinitionString = {columnDefinition.name(), " ", columnDefinition.typeString()};
 
         if (columnDefinition.isPrimaryKey())
-            columnDefinitionString.append(Utf8StringLiteral(" PRIMARY KEY"));
+            columnDefinitionString.append(" PRIMARY KEY");
 
-        columnDefinitionStrings.append(columnDefinitionString);
+        columnDefinitionStrings.push_back(columnDefinitionString);
     }
 
-    m_sqlStatementBuilder.bind(Utf8StringLiteral("$columnDefinitions"), columnDefinitionStrings);
+    m_sqlStatementBuilder.bind("$columnDefinitions", columnDefinitionStrings);
 }
 
 void CreateTableSqlStatementBuilder::bindAll() const
 {
-    m_sqlStatementBuilder.bind(Utf8StringLiteral("$table"), m_tableName);
+    m_sqlStatementBuilder.bind("$table", m_tableName.clone());
 
     bindColumnDefinitions();
 
     if (m_useWithoutRowId)
-        m_sqlStatementBuilder.bind(Utf8StringLiteral("$withoutRowId"), Utf8StringLiteral(" WITHOUT ROWID"));
+        m_sqlStatementBuilder.bind("$withoutRowId", " WITHOUT ROWID");
     else
-        m_sqlStatementBuilder.bindEmptyText(Utf8StringLiteral("$withoutRowId"));
+        m_sqlStatementBuilder.bindEmptyText("$withoutRowId");
 }
 
 } // namespace Sqlite
diff --git a/src/libs/sqlite/createtablesqlstatementbuilder.h b/src/libs/sqlite/createtablesqlstatementbuilder.h
index 0c13d8ccdd8bb07a6f009bc1333a8b6525638df5..7caa42a52e247f12a99d38177719608e192f225d 100644
--- a/src/libs/sqlite/createtablesqlstatementbuilder.h
+++ b/src/libs/sqlite/createtablesqlstatementbuilder.h
@@ -28,7 +28,7 @@
 #include "columndefinition.h"
 #include "sqlstatementbuilder.h"
 
-#include <QVector>
+#include <vector>
 
 namespace Sqlite {
 
@@ -37,15 +37,15 @@ class SQLITE_EXPORT CreateTableSqlStatementBuilder
 public:
     CreateTableSqlStatementBuilder();
 
-    void setTable(const Utf8String &m_tableName);
-    void addColumnDefinition(const Utf8String &columnName, ColumnType columnType, bool isPrimaryKey = false);
-    void setColumnDefinitions(const QVector<ColumnDefinition> & m_columnDefinitions);
-    void setUseWithoutRowId(bool m_useWithoutRowId);
+    void setTable(Utils::SmallString &&tableName);
+    void addColumnDefinition(Utils::SmallString &&columnName, ColumnType columnType, bool isPrimaryKey = false);
+    void setColumnDefinitions(ColumnDefinitions &&columnDefinitions);
+    void setUseWithoutRowId(bool useWithoutRowId);
 
     void clear();
     void clearColumns();
 
-    Utf8String sqlStatement() const;
+    Utils::SmallStringView sqlStatement() const;
 
     bool isValid() const;
 
@@ -55,8 +55,8 @@ protected:
 
 private:
     mutable SqlStatementBuilder m_sqlStatementBuilder;
-    Utf8String m_tableName;
-    QVector<ColumnDefinition> m_columnDefinitions;
+    Utils::SmallString m_tableName;
+    ColumnDefinitions m_columnDefinitions;
     bool m_useWithoutRowId;
 };
 
diff --git a/src/libs/sqlite/sqlitecolumn.h b/src/libs/sqlite/sqlitecolumn.h
index e6c06862d4d3cb06ee7010698d1eb070649f757d..d9e4f20628629c931b1e53d2d9896e60e28ae2fe 100644
--- a/src/libs/sqlite/sqlitecolumn.h
+++ b/src/libs/sqlite/sqlitecolumn.h
@@ -49,12 +49,12 @@ public:
         m_isPrimaryKey = false;
     }
 
-    void setName(const Utf8String &newName)
+    void setName(Utils::SmallString &&newName)
     {
         m_name = newName;
     }
 
-    const Utf8String &name() const
+    const Utils::SmallString &name() const
     {
         return m_name;
     }
@@ -83,7 +83,7 @@ public:
     {
         ColumnDefinition columnDefinition;
 
-        columnDefinition.setName(m_name);
+        columnDefinition.setName(m_name.clone());
         columnDefinition.setType(m_type);
         columnDefinition.setIsPrimaryKey(m_isPrimaryKey);
 
@@ -91,7 +91,7 @@ public:
     }
 
 private:
-    Utf8String m_name;
+    Utils::SmallString m_name;
     ColumnType m_type;
     bool m_isPrimaryKey;
 };
diff --git a/src/libs/sqlite/sqlitedatabase.cpp b/src/libs/sqlite/sqlitedatabase.cpp
index f36d14e73daa7dc4ca28a070976129f7d62207f4..565cca76dd798923e23af0d4d73203b139fbd816 100644
--- a/src/libs/sqlite/sqlitedatabase.cpp
+++ b/src/libs/sqlite/sqlitedatabase.cpp
@@ -47,9 +47,9 @@ void SqliteDatabase::open()
     m_isOpen = true;
 }
 
-void SqliteDatabase::open(const QString &databaseFilePath)
+void SqliteDatabase::open(Utils::PathString &&databaseFilePath)
 {
-    setDatabaseFilePath(databaseFilePath);
+    setDatabaseFilePath(std::move(databaseFilePath));
     open();
 }
 
@@ -67,20 +67,20 @@ bool SqliteDatabase::isOpen() const
 void SqliteDatabase::addTable(SqliteTable *newSqliteTable)
 {
     newSqliteTable->setSqliteDatabase(this);
-    m_sqliteTables.append(newSqliteTable);
+    m_sqliteTables.push_back(newSqliteTable);
 }
 
-const QVector<SqliteTable *> &SqliteDatabase::tables() const
+const std::vector<SqliteTable *> &SqliteDatabase::tables() const
 {
     return m_sqliteTables;
 }
 
-void SqliteDatabase::setDatabaseFilePath(const QString &databaseFilePath)
+void SqliteDatabase::setDatabaseFilePath(Utils::PathString &&databaseFilePath)
 {
-    m_databaseFilePath = databaseFilePath;
+    m_databaseFilePath = std::move(databaseFilePath);
 }
 
-const QString &SqliteDatabase::databaseFilePath() const
+const Utils::PathString &SqliteDatabase::databaseFilePath() const
 {
     return m_databaseFilePath;
 }
diff --git a/src/libs/sqlite/sqlitedatabase.h b/src/libs/sqlite/sqlitedatabase.h
index ca24e98fc06e0acc3ffd3502e7a957cdcf83e3fd..95817a0f0becc2b460e393408c815805166154a3 100644
--- a/src/libs/sqlite/sqlitedatabase.h
+++ b/src/libs/sqlite/sqlitedatabase.h
@@ -28,8 +28,9 @@
 #include "sqlitedatabasebackend.h"
 #include "sqliteglobal.h"
 
-#include <QString>
-#include <QVector>
+#include <utils/smallstring.h>
+
+#include <vector>
 
 namespace Sqlite {
 
@@ -46,16 +47,16 @@ public:
     ~SqliteDatabase();
 
     void open();
-    void open(const QString &databaseFilePath);
+    void open(Utils::PathString &&databaseFilePath);
     void close();
 
     bool isOpen() const;
 
     void addTable(SqliteTable *newSqliteTable);
-    const QVector<SqliteTable *> &tables() const;
+    const std::vector<SqliteTable *> &tables() const;
 
-    void setDatabaseFilePath(const QString &databaseFilePath);
-    const QString &databaseFilePath() const;
+    void setDatabaseFilePath(Utils::PathString &&databaseFilePath);
+    const Utils::PathString &databaseFilePath() const;
 
     void setJournalMode(JournalMode journalMode);
     JournalMode journalMode() const;
@@ -70,8 +71,8 @@ private:
 
 private:
     SqliteDatabaseBackend m_databaseBackend;
-    QVector<SqliteTable*> m_sqliteTables;
-    QString m_databaseFilePath;
+    std::vector<SqliteTable*> m_sqliteTables;
+    Utils::PathString m_databaseFilePath;
     JournalMode m_journalMode;
     bool m_isOpen = false;
 };
diff --git a/src/libs/sqlite/sqlitedatabasebackend.cpp b/src/libs/sqlite/sqlitedatabasebackend.cpp
index f31ccc766aadd18abcfcaf812abf1bda039c25df..eb7a14a05a2bef327ab1ec99a65accf30f97c83b 100644
--- a/src/libs/sqlite/sqlitedatabasebackend.cpp
+++ b/src/libs/sqlite/sqlitedatabasebackend.cpp
@@ -100,15 +100,14 @@ void SqliteDatabaseBackend::checkpointFullWalLog()
     checkIfLogCouldBeCheckpointed(resultCode);
 }
 
-void SqliteDatabaseBackend::open(const QString &databaseFilePath)
+void SqliteDatabaseBackend::open(Utils::SmallStringView databaseFilePath)
 {
     checkCanOpenDatabase(databaseFilePath);
 
-    QByteArray databaseUtf8Path = databaseFilePath.toUtf8();
-    int resultCode = sqlite3_open_v2(databaseUtf8Path.data(),
-                                      &m_databaseHandle,
-                                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
-                                      NULL);
+    int resultCode = sqlite3_open_v2(databaseFilePath.data(),
+                                     &m_databaseHandle,
+                                     SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
+                                     NULL);
 
     checkDatabaseCouldBeOpened(resultCode);
 
@@ -123,33 +122,33 @@ sqlite3 *SqliteDatabaseBackend::sqliteDatabaseHandle()
     return m_databaseHandle;
 }
 
-void SqliteDatabaseBackend::setPragmaValue(const Utf8String &pragmaKey, const Utf8String &newPragmaValue)
+void SqliteDatabaseBackend::setPragmaValue(Utils::SmallStringView pragmaKey, Utils::SmallStringView newPragmaValue)
 {
-    SqliteReadWriteStatement statement(Utf8StringLiteral("PRAGMA ") + pragmaKey + Utf8StringLiteral("='") + newPragmaValue + Utf8StringLiteral("'"), *this);
+    SqliteReadWriteStatement statement(Utils::SmallString{"PRAGMA ", pragmaKey, "='", newPragmaValue, "'"}, *this);
     statement.step();
-    Utf8String pragmeValueInDatabase = toValue<Utf8String>(Utf8StringLiteral("PRAGMA ") + pragmaKey);
+    Utils::SmallString pragmeValueInDatabase = toValue<Utils::SmallString>("PRAGMA " + pragmaKey);
 
     checkPragmaValue(pragmeValueInDatabase, newPragmaValue);
 }
 
-Utf8String SqliteDatabaseBackend::pragmaValue(const Utf8String &pragma)
+Utils::SmallString SqliteDatabaseBackend::pragmaValue(Utils::SmallStringView pragma)
 {
-    return toValue<Utf8String>(Utf8StringLiteral("PRAGMA ") + pragma);
+    return toValue<Utils::SmallString>("PRAGMA " + pragma);
 }
 
 void SqliteDatabaseBackend::setJournalMode(JournalMode journalMode)
 {
-    setPragmaValue(Utf8StringLiteral("journal_mode"), journalModeToPragma(journalMode));
+    setPragmaValue("journal_mode", journalModeToPragma(journalMode));
 }
 
 JournalMode SqliteDatabaseBackend::journalMode()
 {
-    return pragmaToJournalMode(pragmaValue(Utf8StringLiteral("journal_mode")));
+    return pragmaToJournalMode(pragmaValue("journal_mode"));
 }
 
 void SqliteDatabaseBackend::setTextEncoding(TextEncoding textEncoding)
 {
-    setPragmaValue(Utf8StringLiteral("encoding"), textEncodingToPragma(textEncoding));
+    setPragmaValue("encoding", textEncodingToPragma(textEncoding));
     cacheTextEncoding();
 }
 
@@ -159,9 +158,9 @@ TextEncoding SqliteDatabaseBackend::textEncoding()
 }
 
 
-Utf8StringVector SqliteDatabaseBackend::columnNames(const Utf8String &tableName)
+Utils::SmallStringVector SqliteDatabaseBackend::columnNames(Utils::SmallStringView tableName)
 {
-    SqliteReadWriteStatement statement(Utf8StringLiteral("SELECT * FROM ") + tableName, *this);
+    SqliteReadWriteStatement statement("SELECT * FROM " + tableName, *this);
     return statement.columnNames();
 }
 
@@ -175,9 +174,9 @@ int SqliteDatabaseBackend::totalChangesCount()
     return sqlite3_total_changes(sqliteDatabaseHandle());
 }
 
-void SqliteDatabaseBackend::execute(const Utf8String &sqlStatementUtf8)
+void SqliteDatabaseBackend::execute(Utils::SmallStringView sqlStatement)
 {
-    SqliteReadWriteStatement statement(sqlStatementUtf8, *this);
+    SqliteReadWriteStatement statement(sqlStatement, *this);
     statement.step();
 }
 
@@ -233,7 +232,7 @@ int SqliteDatabaseBackend::busyHandlerCallback(void *, int counter)
 
 void SqliteDatabaseBackend::cacheTextEncoding()
 {
-    m_cachedTextEncoding = pragmaToTextEncoding(pragmaValue(Utf8StringLiteral("encoding")));
+    m_cachedTextEncoding = pragmaToTextEncoding(pragmaValue("encoding"));
 }
 
 void SqliteDatabaseBackend::checkForOpenDatabaseWhichCanBeClosed()
@@ -250,7 +249,7 @@ void SqliteDatabaseBackend::checkDatabaseClosing(int resultCode)
     }
 }
 
-void SqliteDatabaseBackend::checkCanOpenDatabase(const QString &databaseFilePath)
+void SqliteDatabaseBackend::checkCanOpenDatabase(Utils::SmallStringView databaseFilePath)
 {
     if (databaseFilePath.isEmpty())
         throw SqliteException("SqliteDatabaseBackend::SqliteDatabaseBackend: database cannot be opened:", "database file path is empty!");
@@ -270,7 +269,8 @@ void SqliteDatabaseBackend::checkDatabaseCouldBeOpened(int resultCode)
     }
 }
 
-void SqliteDatabaseBackend::checkPragmaValue(const Utf8String &databaseValue, const Utf8String &expectedValue)
+void SqliteDatabaseBackend::checkPragmaValue(Utils::SmallStringView databaseValue,
+                                             Utils::SmallStringView expectedValue)
 {
     if (databaseValue != expectedValue)
         throwException("SqliteDatabaseBackend::setPragmaValue: pragma value is not set!");
@@ -318,33 +318,35 @@ void SqliteDatabaseBackend::checkIfLogCouldBeCheckpointed(int resultCode)
         throwException("SqliteDatabaseBackend::checkpointFullWalLog: WAL log could not be checkpointed!");
 }
 
-int SqliteDatabaseBackend::indexOfPragma(const Utf8String pragma, const Utf8String pragmas[], size_t pragmaCount)
+namespace {
+template<std::size_t Size>
+int indexOfPragma(Utils::SmallStringView pragma, const Utils::SmallStringView (&pragmas)[Size])
 {
-    for (unsigned int index = 0; index < pragmaCount; index++) {
+    for (unsigned int index = 0; index < Size; index++) {
         if (pragma == pragmas[index])
             return int(index);
     }
 
     return -1;
-
+}
 }
 
-static const Utf8String journalModeStrings[] = {
-    Utf8StringLiteral("delete"),
-    Utf8StringLiteral("truncate"),
-    Utf8StringLiteral("persist"),
-    Utf8StringLiteral("memory"),
-    Utf8StringLiteral("wal")
+constexpr const Utils::SmallStringView journalModeStrings[] = {
+    "delete",
+    "truncate",
+    "persist",
+    "memory",
+    "wal"
 };
 
-const Utf8String &SqliteDatabaseBackend::journalModeToPragma(JournalMode journalMode)
+Utils::SmallStringView SqliteDatabaseBackend::journalModeToPragma(JournalMode journalMode)
 {
     return journalModeStrings[int(journalMode)];
 }
 
-JournalMode SqliteDatabaseBackend::pragmaToJournalMode(const Utf8String &pragma)
+JournalMode SqliteDatabaseBackend::pragmaToJournalMode(Utils::SmallStringView pragma)
 {
-    int index = indexOfPragma(pragma, journalModeStrings, SIZE_OF_BYTEARRAY_ARRAY(journalModeStrings));
+    int index = indexOfPragma(pragma, journalModeStrings);
 
     if (index < 0)
         throwExceptionStatic("SqliteDatabaseBackend::pragmaToJournalMode: pragma can't be transformed in a journal mode enumeration!");
@@ -352,20 +354,20 @@ JournalMode SqliteDatabaseBackend::pragmaToJournalMode(const Utf8String &pragma)
     return static_cast<JournalMode>(index);
 }
 
-static const Utf8String textEncodingStrings[] = {
-    Utf8StringLiteral("UTF-8"),
-    Utf8StringLiteral("UTF-16le"),
-    Utf8StringLiteral("UTF-16be")
+constexpr const Utils::SmallStringView textEncodingStrings[] = {
+    "UTF-8",
+    "UTF-16le",
+    "UTF-16be"
 };
 
-const Utf8String &SqliteDatabaseBackend::textEncodingToPragma(TextEncoding textEncoding)
+Utils::SmallStringView SqliteDatabaseBackend::textEncodingToPragma(TextEncoding textEncoding)
 {
     return textEncodingStrings[textEncoding];
 }
 
-TextEncoding SqliteDatabaseBackend::pragmaToTextEncoding(const Utf8String &pragma)
+TextEncoding SqliteDatabaseBackend::pragmaToTextEncoding(Utils::SmallStringView pragma)
 {
-    int index = indexOfPragma(pragma, textEncodingStrings, SIZE_OF_BYTEARRAY_ARRAY(textEncodingStrings));
+    int index = indexOfPragma(pragma, textEncodingStrings);
 
     if (index < 0)
         throwExceptionStatic("SqliteDatabaseBackend::pragmaToTextEncoding: pragma can't be transformed in a text encoding enumeration!");
@@ -387,9 +389,9 @@ void SqliteDatabaseBackend::throwException(const char *whatHasHappens) const
 }
 
 template <typename Type>
-Type SqliteDatabaseBackend::toValue(const Utf8String &sqlStatementUtf8)
+Type SqliteDatabaseBackend::toValue(Utils::SmallStringView sqlStatement)
 {
-    SqliteReadWriteStatement statement(sqlStatementUtf8, *this);
+    SqliteReadWriteStatement statement(sqlStatement, *this);
 
     statement.next();
 
diff --git a/src/libs/sqlite/sqlitedatabasebackend.h b/src/libs/sqlite/sqlitedatabasebackend.h
index ae0944f92927ad65031dc84282b9a1340c5fc508..d7027e0ba4e2c134683af1791030d73c4e915b3f 100644
--- a/src/libs/sqlite/sqlitedatabasebackend.h
+++ b/src/libs/sqlite/sqlitedatabasebackend.h
@@ -27,9 +27,7 @@
 
 #include "sqliteglobal.h"
 
-#include "utf8stringvector.h"
-
-#include <QStringList>
+#include <utils/smallstringvector.h>
 
 struct sqlite3;
 
@@ -49,7 +47,7 @@ public:
     void shutdownSqliteLibrary();
     void checkpointFullWalLog();
 
-    void open(const QString &databaseFilePath);
+    void open(Utils::SmallStringView databaseFilePath);
     void close();
     void closeWithoutException();
 
@@ -63,21 +61,21 @@ public:
 
 
 
-    Utf8StringVector columnNames(const Utf8String &tableName);
+    Utils::SmallStringVector columnNames(Utils::SmallStringView tableName);
 
     int changesCount();
     int totalChangesCount();
 
-    void execute(const Utf8String &sqlStatementUtf8);
+    void execute(Utils::SmallStringView sqlStatement);
 
     template <typename Type>
-    Type toValue(const Utf8String &sqlStatementUtf8);
+    Type toValue(Utils::SmallStringView sqlStatement);
 
 protected:
     bool databaseIsOpen() const;
 
-    void setPragmaValue(const Utf8String &pragma, const Utf8String &value);
-    Utf8String pragmaValue(const Utf8String &pragma);
+    void setPragmaValue(Utils::SmallStringView pragma, Utils::SmallStringView value);
+    Utils::SmallString pragmaValue(Utils::SmallStringView pragma);
 
     void registerBusyHandler();
     void registerRankingFunction();
@@ -87,9 +85,9 @@ protected:
 
     void checkForOpenDatabaseWhichCanBeClosed();
     void checkDatabaseClosing(int resultCode);
-    void checkCanOpenDatabase(const QString &databaseFilePath);
+    void checkCanOpenDatabase(Utils::SmallStringView databaseFilePath);
     void checkDatabaseCouldBeOpened(int resultCode);
-    void checkPragmaValue(const Utf8String &databaseValue, const Utf8String &expectedValue);
+    void checkPragmaValue(Utils::SmallStringView databaseValue, Utils::SmallStringView expectedValue);
     void checkDatabaseHandleIsNotNull();
     void checkIfMultithreadingIsActivated(int resultCode);
     void checkIfLoogingIsActivated(int resultCode);
@@ -98,11 +96,10 @@ protected:
     void checkShutdownSqliteLibraryWasSuccesful(int resultCode);
     void checkIfLogCouldBeCheckpointed(int resultCode);
 
-    static int indexOfPragma(const Utf8String pragma, const Utf8String pragmas[], size_t pragmaCount);
-    static const Utf8String &journalModeToPragma(JournalMode journalMode);
-    static JournalMode pragmaToJournalMode(const Utf8String &pragma);
-    const Utf8String &textEncodingToPragma(TextEncoding textEncoding);
-    static TextEncoding pragmaToTextEncoding(const Utf8String &pragma);
+    static Utils::SmallStringView journalModeToPragma(JournalMode journalMode);
+    static JournalMode pragmaToJournalMode(Utils::SmallStringView pragma);
+    Utils::SmallStringView textEncodingToPragma(TextEncoding textEncoding);
+    static TextEncoding pragmaToTextEncoding(Utils::SmallStringView pragma);
 
     Q_NORETURN static void throwExceptionStatic(const char *whatHasHappens);
     Q_NORETURN void throwException(const char *whatHasHappens) const;
diff --git a/src/libs/sqlite/sqliteglobal.cpp b/src/libs/sqlite/sqliteglobal.cpp
index 68a83bc58ec2ec72f4f7ffc029638485a4033253..3f9b05ce1c4bc03d54283ea00e69276ae358c16a 100644
--- a/src/libs/sqlite/sqliteglobal.cpp
+++ b/src/libs/sqlite/sqliteglobal.cpp
@@ -28,5 +28,4 @@
 
 namespace Sqlite {
 
-
 }
diff --git a/src/libs/sqlite/sqliteglobal.h b/src/libs/sqlite/sqliteglobal.h
index 9349230fabad486b34bb4dc535c355b7988eb88c..49cdcfa76255ddc3b0bb620f52eb9489cdbef9d7 100644
--- a/src/libs/sqlite/sqliteglobal.h
+++ b/src/libs/sqlite/sqliteglobal.h
@@ -25,6 +25,8 @@
 
 #pragma once
 
+#include <utils/smallstringfwd.h>
+
 #include <QtGlobal>
 
 #if defined(BUILD_SQLITE_LIBRARY)
@@ -35,11 +37,6 @@
 #  define SQLITE_EXPORT Q_DECL_IMPORT
 #endif
 
-
-namespace Sqlite {
-SQLITE_EXPORT void registerTypes();
-}
-
 enum class ColumnType {
     Numeric,
     Integer,
@@ -71,17 +68,3 @@ enum TextEncoding {
 #endif
 
 };
-
-QT_BEGIN_NAMESPACE
-template <typename T> class QVector;
-template <typename T> class QSet;
-template <class Key, class T> class QHash;
-template <class Key, class T> class QMap;
-class QVariant;
-QT_END_NAMESPACE
-
-class Utf8String;
-class Utf8StringVector;
-
-typedef QMap<Utf8String, QVariant> RowDictionary;
-typedef QVector<RowDictionary> RowDictionaries;
diff --git a/src/libs/sqlite/sqlitereadstatement.cpp b/src/libs/sqlite/sqlitereadstatement.cpp
index 18bc8b6a2b729d8f87be9fac0c032ea043ac15fe..86e2f7d6ab3c0adb18fc89782f547da96f09d3fc 100644
--- a/src/libs/sqlite/sqlitereadstatement.cpp
+++ b/src/libs/sqlite/sqlitereadstatement.cpp
@@ -29,9 +29,9 @@
 
 namespace Sqlite {
 
-SqliteReadStatement::SqliteReadStatement(const Utf8String &sqlStatementUtf8,
+SqliteReadStatement::SqliteReadStatement(Utils::SmallStringView sqlStatement,
                                          SqliteDatabase &database)
-    : SqliteStatement(sqlStatementUtf8, database)
+    : SqliteStatement(sqlStatement, database)
 {
     checkIsReadOnlyStatement();
 }
diff --git a/src/libs/sqlite/sqlitereadstatement.h b/src/libs/sqlite/sqlitereadstatement.h
index 3795e5cf25f9795f2f7f1729e060a598c5ce6292..02c998fb5d1e7b67683900015306da326c60455b 100644
--- a/src/libs/sqlite/sqlitereadstatement.h
+++ b/src/libs/sqlite/sqlitereadstatement.h
@@ -32,14 +32,13 @@ namespace Sqlite {
 class SQLITE_EXPORT SqliteReadStatement final : private SqliteStatement
 {
 public:
-    explicit SqliteReadStatement(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
+    explicit SqliteReadStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
 
     using SqliteStatement::next;
     using SqliteStatement::reset;
     using SqliteStatement::value;
+    using SqliteStatement::text;
     using SqliteStatement::values;
-    using SqliteStatement::rowColumnValueMap;
-    using SqliteStatement::twoColumnValueMap;
     using SqliteStatement::columnCount;
     using SqliteStatement::columnNames;
     using SqliteStatement::bind;
diff --git a/src/libs/sqlite/sqlitereadwritestatement.cpp b/src/libs/sqlite/sqlitereadwritestatement.cpp
index cf88143d9ea09e535cbad9f8160c4b1c868e0205..b642675e0a92a7e8c5c6446f1eb336335660e146 100644
--- a/src/libs/sqlite/sqlitereadwritestatement.cpp
+++ b/src/libs/sqlite/sqlitereadwritestatement.cpp
@@ -27,15 +27,15 @@
 
 namespace Sqlite {
 
-SqliteReadWriteStatement::SqliteReadWriteStatement(const Utf8String &sqlStatementUft8,
+SqliteReadWriteStatement::SqliteReadWriteStatement(Utils::SmallStringView sqlStatement,
                                                    SqliteDatabase &database)
-    : SqliteStatement(sqlStatementUft8, database)
+    : SqliteStatement(sqlStatement, database)
 {
 }
 
-SqliteReadWriteStatement::SqliteReadWriteStatement(const Utf8String &sqlStatementUft8,
+SqliteReadWriteStatement::SqliteReadWriteStatement(Utils::SmallStringView sqlStatement,
                                                    SqliteDatabaseBackend &backend)
-    : SqliteStatement(sqlStatementUft8, backend)
+    : SqliteStatement(sqlStatement, backend)
 {
 }
 
diff --git a/src/libs/sqlite/sqlitereadwritestatement.h b/src/libs/sqlite/sqlitereadwritestatement.h
index 9d644fbaf2dce67a4d6a393cb12bfdfbe2d6a548..8488fcc67c7e956620d17a4e5b855acbab724128 100644
--- a/src/libs/sqlite/sqlitereadwritestatement.h
+++ b/src/libs/sqlite/sqlitereadwritestatement.h
@@ -34,7 +34,7 @@ class SQLITE_EXPORT SqliteReadWriteStatement final : private SqliteStatement
     friend class SqliteDatabaseBackend;
 
 public:
-    explicit SqliteReadWriteStatement(const Utf8String &sqlStatementUft8, SqliteDatabase &database);
+    SqliteReadWriteStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
 
     using SqliteStatement::next;
     using SqliteStatement::step;
@@ -43,16 +43,15 @@ public:
     using SqliteStatement::bindingIndexForName;
     using SqliteStatement::setBindingColumnNames;
     using SqliteStatement::bindingColumnNames;
-    using SqliteStatement::write;
     using SqliteStatement::value;
+    using SqliteStatement::text;
     using SqliteStatement::values;
-    using SqliteStatement::rowColumnValueMap;
     using SqliteStatement::columnCount;
     using SqliteStatement::columnNames;
     using SqliteStatement::toValue;
 
 private:
-    explicit SqliteReadWriteStatement(const Utf8String &sqlStatementUft8,
+    explicit SqliteReadWriteStatement(Utils::SmallStringView sqlStatement,
                                       SqliteDatabaseBackend &backend);
 };
 
diff --git a/src/libs/sqlite/sqlitestatement.cpp b/src/libs/sqlite/sqlitestatement.cpp
index d0fb886c14e9aac047f36f5e1c1ca007ca277d55..37081ca106466369384b86826f69a828738d5c68 100644
--- a/src/libs/sqlite/sqlitestatement.cpp
+++ b/src/libs/sqlite/sqlitestatement.cpp
@@ -42,20 +42,20 @@
 
 namespace Sqlite {
 
-SqliteStatement::SqliteStatement(const Utf8String &sqlStatementUtf8, SqliteDatabase &database)
-    : SqliteStatement(sqlStatementUtf8, database.backend())
+SqliteStatement::SqliteStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database)
+    : SqliteStatement(sqlStatement, database.backend())
 {
 
 }
 
-SqliteStatement::SqliteStatement(const Utf8String &sqlStatementUtf8, SqliteDatabaseBackend &databaseBackend)
+SqliteStatement::SqliteStatement(Utils::SmallStringView sqlStatement, SqliteDatabaseBackend &databaseBackend)
     : m_compiledStatement(nullptr, deleteCompiledStatement),
       m_databaseBackend(databaseBackend),
       m_bindingParameterCount(0),
       m_columnCount(0),
       m_isReadyToFetchValues(false)
 {
-    prepare(sqlStatementUtf8);
+    prepare(sqlStatement);
     setBindingParameterCount();
     setBindingColumnNamesFromStatement();
     setColumnCount();
@@ -70,8 +70,6 @@ void SqliteStatement::deleteCompiledStatement(sqlite3_stmt *compiledStatement)
 class UnlockNotification {
 
 public:
-    UnlockNotification() : fired(false) {};
-
     static void unlockNotifyCallBack(void **arguments, int argumentCount)
     {
         for (int index = 0; index < argumentCount; index++) {
@@ -100,7 +98,7 @@ public:
     }
 
 private:
-    bool fired;
+    bool fired = false;
     QWaitCondition waitCondition;
     QMutex mutex;
 };
@@ -148,32 +146,18 @@ void SqliteStatement::step() const
     next();
 }
 
-void SqliteStatement::write(const RowDictionary &rowDictionary)
-{
-    bind(rowDictionary);
-    step();
-    reset();
-}
-
-void SqliteStatement::writeUnchecked(const RowDictionary &rowDictionary)
-{
-    bindUnchecked(rowDictionary);
-    step();
-    reset();
-}
-
 int SqliteStatement::columnCount() const
 {
     return m_columnCount;
 }
 
-Utf8StringVector SqliteStatement::columnNames() const
+Utils::SmallStringVector SqliteStatement::columnNames() const
 {
-    Utf8StringVector columnNames;
+    Utils::SmallStringVector columnNames;
     int columnCount = SqliteStatement::columnCount();
-    columnNames.reserve(columnCount);
+    columnNames.reserve(std::size_t(columnCount));
     for (int columnIndex = 0; columnIndex < columnCount; columnIndex++)
-        columnNames.append(Utf8String(sqlite3_column_origin_name(m_compiledStatement.get(), columnIndex), -1));
+        columnNames.emplace_back(sqlite3_column_origin_name(m_compiledStatement.get(), columnIndex));
 
     return columnNames;
 }
@@ -199,117 +183,52 @@ void SqliteStatement::bind(int index, double value)
         throwException("SqliteStatement::bind: cant' bind double!");
 }
 
-void SqliteStatement::bind(int index, const QString &text)
+void SqliteStatement::bind(int index, Utils::SmallStringView text)
 {
-    int resultCode;
-    if (databaseTextEncoding() == Utf8) {
-        QByteArray textUtf8 = text.toUtf8();
-        resultCode = sqlite3_bind_text(m_compiledStatement.get(), index, textUtf8.constData(), textUtf8.size(), SQLITE_TRANSIENT);
-    } else {
-        resultCode = sqlite3_bind_text16(m_compiledStatement.get(), index, text.constData(), text.size() * 2, SQLITE_TRANSIENT);
-    }
-
+    int resultCode = sqlite3_bind_text(m_compiledStatement.get(), index, text.data(), int(text.size()), SQLITE_TRANSIENT);
     if (resultCode != SQLITE_OK)
-        throwException("SqliteStatement::bind: cant' not bind text!");
-}
-
-void SqliteStatement::bind(int index, const QByteArray &blob)
-{
-    sqlite3_bind_blob(m_compiledStatement.get(), index, blob.constData(), blob.size(), SQLITE_TRANSIENT);
-}
-
-void SqliteStatement::bind(int index, const QVariant &value)
-{
-    checkBindingIndex(index);
-
-    switch (value.type()) {
-        case QVariant::Bool:
-        case QVariant::Int:
-            bind(index, value.toInt());
-            break;
-        case QVariant::UInt:
-        case QVariant::LongLong:
-        case QVariant::ULongLong:
-            bind(index, value.toLongLong());
-            break;
-        case QVariant::Double:
-            bind(index, value.toDouble());
-            break;
-        case QVariant::String:
-            bind(index, value.toString());
-            break;
-        case QVariant::ByteArray:
-            bind(index, value.toByteArray());
-            break;
-        default:
-            sqlite3_bind_null(m_compiledStatement.get(), index);
-    }
+        throwException("SqliteStatement::bind: cant' bind double!");
 }
 
 template <typename Type>
-void SqliteStatement::bind(const Utf8String &name, const Type &value)
+void SqliteStatement::bind(Utils::SmallStringView name, Type value)
 {
     int index = bindingIndexForName(name);
     checkBindingName(index);
     bind(index, value);
 }
 
-template SQLITE_EXPORT void SqliteStatement::bind(const Utf8String &name, const int &value);
-template SQLITE_EXPORT void SqliteStatement::bind(const Utf8String &name, const qint64 &value);
-template SQLITE_EXPORT void SqliteStatement::bind(const Utf8String &name, const double &value);
-template SQLITE_EXPORT void SqliteStatement::bind(const Utf8String &name, const QString &text);
-template SQLITE_EXPORT void SqliteStatement::bind(const Utf8String &name, const QByteArray &blob);
-template SQLITE_EXPORT void SqliteStatement::bind(const Utf8String &name, const QVariant &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, double value);
+template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, Utils::SmallStringView text);
 
-int SqliteStatement::bindingIndexForName(const Utf8String &name)
+int SqliteStatement::bindingIndexForName(Utils::SmallStringView name)
 {
-    return  sqlite3_bind_parameter_index(m_compiledStatement.get(), name.constData());
+    return  sqlite3_bind_parameter_index(m_compiledStatement.get(), name.data());
 }
 
-void SqliteStatement::bind(const RowDictionary &rowDictionary)
-{
-    checkBindingValueMapIsEmpty(rowDictionary);
-
-    int columnIndex = 1;
-    foreach (const Utf8String &columnName, m_bindingColumnNames) {
-        checkParameterCanBeBound(rowDictionary, columnName);
-        QVariant value = rowDictionary.value(columnName);
-        bind(columnIndex, value);
-        columnIndex += 1;
-    }
-}
-
-void SqliteStatement::bindUnchecked(const RowDictionary &rowDictionary)
-{
-    checkBindingValueMapIsEmpty(rowDictionary);
-
-    int columnIndex = 1;
-    foreach (const Utf8String &columnName, m_bindingColumnNames) {
-        if (rowDictionary.contains(columnName)) {
-            QVariant value = rowDictionary.value(columnName);
-            bind(columnIndex, value);
-        }
-        columnIndex += 1;
-    }
-}
-
-void SqliteStatement::setBindingColumnNames(const Utf8StringVector &bindingColumnNames)
+void SqliteStatement::setBindingColumnNames(const Utils::SmallStringVector &bindingColumnNames)
 {
     m_bindingColumnNames = bindingColumnNames;
 }
 
-const Utf8StringVector &SqliteStatement::bindingColumnNames() const
+const Utils::SmallStringVector &SqliteStatement::bindingColumnNames() const
 {
     return m_bindingColumnNames;
 }
 
-void SqliteStatement::prepare(const Utf8String &sqlStatementUtf8)
+void SqliteStatement::prepare(Utils::SmallStringView sqlStatement)
 {
     int resultCode;
 
     do {
         sqlite3_stmt *sqliteStatement = nullptr;
-        resultCode = sqlite3_prepare_v2(sqliteDatabaseHandle(), sqlStatementUtf8.constData(), sqlStatementUtf8.byteSize(), &sqliteStatement, nullptr);
+        resultCode = sqlite3_prepare_v2(sqliteDatabaseHandle(),
+                                        sqlStatement.data(),
+                                        int(sqlStatement.size()),
+                                        &sqliteStatement,
+                                        nullptr);
         m_compiledStatement.reset(sqliteStatement);
 
         if (resultCode == SQLITE_LOCKED)
@@ -373,9 +292,9 @@ void SqliteStatement::checkIfIsReadyToFetchValues() const
         throwException("SqliteStatement::value: there are no values to fetch!");
 }
 
-void SqliteStatement::checkColumnsAreValid(const QVector<int> &columns) const
+void SqliteStatement::checkColumnsAreValid(const std::vector<int> &columns) const
 {
-    foreach (int column, columns) {
+    for (int column : columns) {
         if (column < 0 || column >= m_columnCount)
             throwException("SqliteStatement::values: column index out of bound!");
     }
@@ -399,30 +318,24 @@ void SqliteStatement::checkBindingName(int index) const
         throwException("SqliteStatement::bind: binding name are not exists in this statement!");
 }
 
-void SqliteStatement::checkParameterCanBeBound(const RowDictionary &rowDictionary, const Utf8String &columnName)
-{
-    if (!rowDictionary.contains(columnName))
-        throwException("SqliteStatement::bind: Not all parameters are bound!");
-}
-
 void SqliteStatement::setBindingParameterCount()
 {
     m_bindingParameterCount = sqlite3_bind_parameter_count(m_compiledStatement.get());
 }
 
-Utf8String chopFirstLetter(const char *rawBindingName)
+Utils::SmallStringView chopFirstLetter(const char *rawBindingName)
 {
-    QByteArray bindingName(rawBindingName);
-    bindingName = bindingName.mid(1);
+    if (rawBindingName != nullptr)
+        return Utils::SmallStringView(++rawBindingName);
 
-    return Utf8String::fromByteArray(bindingName);
+    return Utils::SmallStringView("");
 }
 
 void SqliteStatement::setBindingColumnNamesFromStatement()
 {
     for (int index = 1; index <= m_bindingParameterCount; index++) {
-        Utf8String bindingName = chopFirstLetter(sqlite3_bind_parameter_name(m_compiledStatement.get(), index));
-        m_bindingColumnNames.append(bindingName);
+        Utils::SmallStringView bindingName = chopFirstLetter(sqlite3_bind_parameter_name(m_compiledStatement.get(), index));
+        m_bindingColumnNames.push_back(Utils::SmallString(bindingName));
     }
 }
 
@@ -431,12 +344,6 @@ void SqliteStatement::setColumnCount()
     m_columnCount = sqlite3_column_count(m_compiledStatement.get());
 }
 
-void SqliteStatement::checkBindingValueMapIsEmpty(const RowDictionary &rowDictionary) const
-{
-    if (rowDictionary.isEmpty())
-        throwException("SqliteStatement::bind: can't bind empty row!");
-}
-
 bool SqliteStatement::isReadOnlyStatement() const
 {
     return sqlite3_stmt_readonly(m_compiledStatement.get());
@@ -452,64 +359,23 @@ QString SqliteStatement::columnName(int column) const
     return QString::fromUtf8(sqlite3_column_name(m_compiledStatement.get(), column));
 }
 
-static bool columnIsBlob(sqlite3_stmt *sqlStatment, int column)
-{
-    return sqlite3_column_type(sqlStatment, column) == SQLITE_BLOB;
-}
-
-static QByteArray byteArrayForColumn(sqlite3_stmt *sqlStatment, int column)
-{
-    if (columnIsBlob(sqlStatment, column)) {
-        const char *blob =  static_cast<const char*>(sqlite3_column_blob(sqlStatment, column));
-        int size = sqlite3_column_bytes(sqlStatment, column);
-
-        return QByteArray(blob, size);
-    }
-
-    return QByteArray();
-}
-
-static QString textForColumn(sqlite3_stmt *sqlStatment, int column)
-{
-    const QChar *text =  static_cast<const QChar*>(sqlite3_column_text16(sqlStatment, column));
-    int size = sqlite3_column_bytes16(sqlStatment, column) / 2;
-
-    return QString(text, size);
-}
-
-static Utf8String utf8TextForColumn(sqlite3_stmt *sqlStatment, int column)
+static Utils::SmallString textForColumn(sqlite3_stmt *sqlStatment, int column)
 {
     const char *text =  reinterpret_cast<const char*>(sqlite3_column_text(sqlStatment, column));
-    int size = sqlite3_column_bytes(sqlStatment, column);
+    std::size_t size = std::size_t(sqlite3_column_bytes(sqlStatment, column));
 
-    return Utf8String(text, size);
+    return Utils::SmallString(text, size);
 }
 
-
-static Utf8String convertedToUtf8StringForColumn(sqlite3_stmt *sqlStatment, int column)
-{
-    int dataType = sqlite3_column_type(sqlStatment, column);
-    switch (dataType) {
-        case SQLITE_INTEGER: return Utf8String::fromByteArray(QByteArray::number(sqlite3_column_int64(sqlStatment, column)));
-        case SQLITE_FLOAT: return Utf8String::fromByteArray(QByteArray::number(sqlite3_column_double(sqlStatment, column)));
-        case SQLITE_BLOB: return Utf8String();
-        case SQLITE3_TEXT: return utf8TextForColumn(sqlStatment, column);
-        case SQLITE_NULL: return Utf8String();
-    }
-
-    Q_UNREACHABLE();
-}
-
-
-static QVariant variantForColumn(sqlite3_stmt *sqlStatment, int column)
+static Utils::SmallString convertToTextForColumn(sqlite3_stmt *sqlStatment, int column)
 {
     int dataType = sqlite3_column_type(sqlStatment, column);
     switch (dataType) {
-        case SQLITE_INTEGER: return QVariant::fromValue(sqlite3_column_int64(sqlStatment, column));
-        case SQLITE_FLOAT: return QVariant::fromValue(sqlite3_column_double(sqlStatment, column));
-        case SQLITE_BLOB: return QVariant::fromValue(byteArrayForColumn(sqlStatment, column));
-        case SQLITE3_TEXT: return QVariant::fromValue(textForColumn(sqlStatment, column));
-        case SQLITE_NULL: return QVariant();
+        case SQLITE_INTEGER:
+        case SQLITE_FLOAT:
+        case SQLITE3_TEXT: return textForColumn(sqlStatment, column);
+        case SQLITE_BLOB:
+        case SQLITE_NULL: return {};
     }
 
     Q_UNREACHABLE();
@@ -540,94 +406,49 @@ double SqliteStatement::value<double>(int column) const
 }
 
 template<>
-QByteArray SqliteStatement::value<QByteArray>(int column) const
-{
-    checkIfIsReadyToFetchValues();
-    checkColumnIsValid(column);
-    return byteArrayForColumn(m_compiledStatement.get(), column);
-}
-
-template<>
-Utf8String SqliteStatement::value<Utf8String>(int column) const
-{
-    checkIfIsReadyToFetchValues();
-    checkColumnIsValid(column);
-    return convertedToUtf8StringForColumn(m_compiledStatement.get(), column);
-}
-
-template<>
-QString SqliteStatement::value<QString>(int column) const
+Utils::SmallString SqliteStatement::value<Utils::SmallString>(int column) const
 {
     checkIfIsReadyToFetchValues();
     checkColumnIsValid(column);
-    return textForColumn(m_compiledStatement.get(), column);
+    return convertToTextForColumn(m_compiledStatement.get(), column);
 }
 
-template<>
-QVariant SqliteStatement::value<QVariant>(int column) const
+Utils::SmallString SqliteStatement::text(int column) const
 {
-    checkIfIsReadyToFetchValues();
-    checkColumnIsValid(column);
-    return variantForColumn(m_compiledStatement.get(), column);
+    return value<Utils::SmallString>(column);
 }
 
 template <typename ContainerType>
- ContainerType SqliteStatement::columnValues(const QVector<int> &columnIndices) const
+ContainerType SqliteStatement::columnValues(const std::vector<int> &columnIndices) const
 {
-    typedef typename ContainerType::value_type ElementType;
+    using ElementType = typename ContainerType::value_type;
     ContainerType valueContainer;
-    valueContainer.reserve(columnIndices.count());
+    valueContainer.reserve(columnIndices.size());
     for (int columnIndex : columnIndices)
-        valueContainer += value<ElementType>(columnIndex);
+        valueContainer.push_back(value<ElementType>(columnIndex));
 
     return valueContainer;
 }
 
-QMap<QString, QVariant> SqliteStatement::rowColumnValueMap() const
-{
-    QMap<QString, QVariant> values;
-
-    reset();
-
-    if (next()) {
-        for (int column = 0; column < columnCount(); column++)
-            values.insert(columnName(column), variantForColumn(m_compiledStatement.get(), column));
-    }
-
-    return values;
-}
-
-QMap<QString, QVariant> SqliteStatement::twoColumnValueMap() const
-{
-    QMap<QString, QVariant> values;
-
-    reset();
-
-    while (next())
-        values.insert(textForColumn(m_compiledStatement.get(), 0), variantForColumn(m_compiledStatement.get(), 1));
-
-    return values;
-}
-
 template <typename ContainerType>
-ContainerType SqliteStatement::values(const QVector<int> &columns, int size) const
+ContainerType SqliteStatement::values(const std::vector<int> &columns, int size) const
 {
     checkColumnsAreValid(columns);
 
     ContainerType resultValues;
-    resultValues.reserve(size);
+    resultValues.reserve(typename ContainerType::size_type(size));
 
     reset();
 
     while (next()) {
-        resultValues += columnValues<ContainerType>(columns);
+        auto values = columnValues<ContainerType>(columns);
+        std::move(values.begin(), values.end(), std::back_inserter(resultValues));
     }
 
     return resultValues;
 }
 
-template SQLITE_EXPORT QVector<QVariant> SqliteStatement::values<QVector<QVariant>>(const QVector<int> &columnIndices, int size) const;
-template SQLITE_EXPORT QVector<Utf8String> SqliteStatement::values<QVector<Utf8String>>(const QVector<int> &columnIndices, int size) const;
+template SQLITE_EXPORT Utils::SmallStringVector SqliteStatement::values<Utils::SmallStringVector>(const std::vector<int> &columnIndices, int size) const;
 
 template <typename ContainerType>
 ContainerType SqliteStatement::values(int column) const
@@ -638,34 +459,29 @@ ContainerType SqliteStatement::values(int column) const
     reset();
 
     while (next()) {
-        resultValues += value<ElementType>(column);
+        resultValues.push_back(value<ElementType>(column));
     }
 
     return resultValues;
 }
 
-template SQLITE_EXPORT QVector<qint64> SqliteStatement::values<QVector<qint64>>(int column) const;
-template SQLITE_EXPORT QVector<double> SqliteStatement::values<QVector<double>>(int column) const;
-template SQLITE_EXPORT QVector<QByteArray> SqliteStatement::values<QVector<QByteArray>>(int column) const;
-template SQLITE_EXPORT Utf8StringVector SqliteStatement::values<Utf8StringVector>(int column) const;
-template SQLITE_EXPORT QVector<QString> SqliteStatement::values<QVector<QString>>(int column) const;
+template SQLITE_EXPORT std::vector<qint64> SqliteStatement::values<std::vector<qint64>>(int column) const;
+template SQLITE_EXPORT std::vector<double> SqliteStatement::values<std::vector<double>>(int column) const;
+template SQLITE_EXPORT Utils::SmallStringVector SqliteStatement::values<Utils::SmallStringVector>(int column) const;
 
 template <typename Type>
-Type SqliteStatement::toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database)
+Type SqliteStatement::toValue(Utils::SmallStringView sqlStatement, SqliteDatabase &database)
 {
-    SqliteStatement statement(sqlStatementUtf8, database);
+    SqliteStatement statement(sqlStatement, database);
 
     statement.next();
 
     return statement.value<Type>(0);
 }
 
-template SQLITE_EXPORT int SqliteStatement::toValue<int>(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
-template SQLITE_EXPORT qint64 SqliteStatement::toValue<qint64>(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
-template SQLITE_EXPORT double SqliteStatement::toValue<double>(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
-template SQLITE_EXPORT QString SqliteStatement::toValue<QString>(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
-template SQLITE_EXPORT QByteArray SqliteStatement::toValue<QByteArray>(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
-template SQLITE_EXPORT Utf8String SqliteStatement::toValue<Utf8String>(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
-template SQLITE_EXPORT QVariant SqliteStatement::toValue<QVariant>(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
+template SQLITE_EXPORT int SqliteStatement::toValue<int>(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
+template SQLITE_EXPORT qint64 SqliteStatement::toValue<qint64>(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
+template SQLITE_EXPORT double SqliteStatement::toValue<double>(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
+template SQLITE_EXPORT Utils::SmallString SqliteStatement::toValue<Utils::SmallString>(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
 
 } // namespace Sqlite
diff --git a/src/libs/sqlite/sqlitestatement.h b/src/libs/sqlite/sqlitestatement.h
index bda6b93100092e4770d2a1769ae8b6d71ac48153..1c748a35443246f906ce237b5714bee604008adc 100644
--- a/src/libs/sqlite/sqlitestatement.h
+++ b/src/libs/sqlite/sqlitestatement.h
@@ -28,11 +28,8 @@
 #include "sqliteglobal.h"
 
 #include "sqliteexception.h"
-#include "utf8stringvector.h"
 
-#include <QString>
-#include <QVariant>
-#include <QVector>
+#include <utils/smallstringvector.h>
 
 #include <type_traits>
 #include <memory>
@@ -48,7 +45,7 @@ class SqliteDatabaseBackend;
 class SQLITE_EXPORT SqliteStatement
 {
 protected:
-    explicit SqliteStatement(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
+    explicit SqliteStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
 
     static void deleteCompiledStatement(sqlite3_stmt *m_compiledStatement);
 
@@ -58,45 +55,35 @@ protected:
 
     template<typename Type>
     Type value(int column) const;
+    Utils::SmallString text(int column) const;
     int columnCount() const;
-    Utf8StringVector columnNames() const;
+    Utils::SmallStringVector columnNames() const;
 
     void bind(int index, int value);
     void bind(int index, qint64 value);
     void bind(int index, double value);
-    void bind(int index, const QString &text);
-    void bind(int index, const QByteArray &blob);
-    void bind(int index, const QVariant &value);
+    void bind(int index, Utils::SmallStringView value);
 
     template <typename Type>
-    void bind(const Utf8String &name, const Type &value);
+    void bind(Utils::SmallStringView name, Type value);
 
-    int bindingIndexForName(const Utf8String &name);
+    int bindingIndexForName(Utils::SmallStringView name);
 
-    void bind(const RowDictionary &rowDictionary);
-    void bindUnchecked(const RowDictionary &rowDictionary);
-
-    void setBindingColumnNames(const Utf8StringVector &bindingColumnNames);
-    const Utf8StringVector &bindingColumnNames() const;
+    void setBindingColumnNames(const Utils::SmallStringVector &bindingColumnNames);
+    const Utils::SmallStringVector &bindingColumnNames() const;
 
     template <typename ContainerType>
-    ContainerType values(const QVector<int> &columns, int size = 0) const;
+    ContainerType values(const std::vector<int> &columns, int size = 0) const;
 
     template <typename ContainerType>
     ContainerType values(int column = 0) const;
 
-    QMap<QString, QVariant> rowColumnValueMap() const;
-    QMap<QString, QVariant> twoColumnValueMap() const;
-
     template <typename Type>
-    static Type toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
+    static Type toValue(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
 
-    void prepare(const Utf8String &sqlStatementUtf8);
+    void prepare(Utils::SmallStringView sqlStatement);
     void waitForUnlockNotify() const;
 
-    void write(const RowDictionary &rowDictionary);
-    void writeUnchecked(const RowDictionary &rowDictionary);
-
     sqlite3 *sqliteDatabaseHandle() const;
     TextEncoding databaseTextEncoding();
 
@@ -105,30 +92,28 @@ protected:
     void checkForPrepareError(int resultCode) const;
     void setIfIsReadyToFetchValues(int resultCode) const;
     void checkIfIsReadyToFetchValues() const;
-    void checkColumnsAreValid(const QVector<int> &columns) const;
+    void checkColumnsAreValid(const std::vector<int> &columns) const;
     void checkColumnIsValid(int column) const;
     void checkBindingIndex(int index) const;
     void checkBindingName(int index) const;
-    void checkParameterCanBeBound(const RowDictionary &rowDictionary, const Utf8String &columnName);
     void setBindingParameterCount();
     void setBindingColumnNamesFromStatement();
     void setColumnCount();
-    void checkBindingValueMapIsEmpty(const RowDictionary &rowDictionary) const;
     bool isReadOnlyStatement() const;
     Q_NORETURN void throwException(const char *whatHasHappened) const;
 
     template <typename ContainerType>
-    ContainerType columnValues(const QVector<int> &columnIndices) const;
+    ContainerType columnValues(const std::vector<int> &columnIndices) const;
 
     QString columnName(int column) const;
 
 protected:
-    explicit SqliteStatement(const Utf8String &sqlStatementUtf8,
+    explicit SqliteStatement(Utils::SmallStringView sqlStatement,
                              SqliteDatabaseBackend &databaseBackend);
 
 private:
     std::unique_ptr<sqlite3_stmt, void (*)(sqlite3_stmt*)> m_compiledStatement;
-    Utf8StringVector m_bindingColumnNames;
+    Utils::SmallStringVector m_bindingColumnNames;
     SqliteDatabaseBackend &m_databaseBackend;
     int m_bindingParameterCount;
     int m_columnCount;
diff --git a/src/libs/sqlite/sqlitetable.cpp b/src/libs/sqlite/sqlitetable.cpp
index 5f0eeba6bf390f70b9a2d08ef64e87b22e5e369f..8d24fdfae42f4beed0e8829315a71f89c9ed30b2 100644
--- a/src/libs/sqlite/sqlitetable.cpp
+++ b/src/libs/sqlite/sqlitetable.cpp
@@ -44,12 +44,12 @@ SqliteTable::~SqliteTable()
     qDeleteAll(m_sqliteColumns);
 }
 
-void SqliteTable::setName(const Utf8String &name)
+void SqliteTable::setName(Utils::SmallString &&name)
 {
-    m_tableName = name;
+    m_tableName = std::move(name);
 }
 
-const Utf8String &SqliteTable::name() const
+Utils::SmallStringView SqliteTable::name() const
 {
     return m_tableName;
 }
@@ -66,10 +66,10 @@ bool SqliteTable::useWithoutRowId() const
 
 void SqliteTable::addColumn(SqliteColumn *newColumn)
 {
-    m_sqliteColumns.append(newColumn);
+    m_sqliteColumns.push_back(newColumn);
 }
 
-const QVector<SqliteColumn *> &SqliteTable::columns() const
+const std::vector<SqliteColumn *> &SqliteTable::columns() const
 {
     return m_sqliteColumns;
 }
@@ -84,7 +84,7 @@ void SqliteTable::initialize()
     try {
         CreateTableSqlStatementBuilder createTableSqlStatementBuilder;
 
-        createTableSqlStatementBuilder.setTable(m_tableName);
+        createTableSqlStatementBuilder.setTable(m_tableName.clone());
         createTableSqlStatementBuilder.setUseWithoutRowId(m_withoutRowId);
         createTableSqlStatementBuilder.setColumnDefinitions(createColumnDefintions());
 
@@ -104,12 +104,12 @@ bool SqliteTable::isReady() const
     return m_isReady;
 }
 
-QVector<ColumnDefinition> SqliteTable::createColumnDefintions() const
+ColumnDefinitions SqliteTable::createColumnDefintions() const
 {
-    QVector<ColumnDefinition> columnDefintions;
+    ColumnDefinitions columnDefintions;
 
     for (SqliteColumn *sqliteColumn : m_sqliteColumns)
-        columnDefintions.append(sqliteColumn->columnDefintion());
+        columnDefintions.push_back(sqliteColumn->columnDefintion());
 
     return columnDefintions;
 }
diff --git a/src/libs/sqlite/sqlitetable.h b/src/libs/sqlite/sqlitetable.h
index d9f77ed06a95360a499ace3d544268ccdb7ce488..9108b8c41916164fb065e11e670df3e98525570c 100644
--- a/src/libs/sqlite/sqlitetable.h
+++ b/src/libs/sqlite/sqlitetable.h
@@ -43,14 +43,14 @@ public:
     SqliteTable();
     ~SqliteTable();
 
-    void setName(const Utf8String &name);
-    const Utf8String &name() const;
+    void setName(Utils::SmallString &&name);
+    Utils::SmallStringView name() const;
 
     void setUseWithoutRowId(bool useWithoutWorId);
     bool useWithoutRowId() const;
 
     void addColumn(SqliteColumn *newColumn);
-    const QVector<SqliteColumn *> &columns() const;
+    const std::vector<SqliteColumn *> &columns() const;
 
     void setSqliteDatabase(SqliteDatabase *database);
 
@@ -59,11 +59,11 @@ public:
     bool isReady() const;
 
 private:
-    QVector<ColumnDefinition> createColumnDefintions() const;
+    ColumnDefinitions createColumnDefintions() const;
 
 private:
-    QVector<SqliteColumn*> m_sqliteColumns;
-    Utf8String m_tableName;
+    std::vector<SqliteColumn*> m_sqliteColumns;
+    Utils::SmallString m_tableName;
     SqliteDatabase *m_sqliteDatabase;
     bool m_withoutRowId;
 
diff --git a/src/libs/sqlite/sqlitetransaction.cpp b/src/libs/sqlite/sqlitetransaction.cpp
index e66f39ca3e3cee7e96aeb975e7545b508d691eb1..dd790ee55296b8d4c97abc1482a6b80be17d665c 100644
--- a/src/libs/sqlite/sqlitetransaction.cpp
+++ b/src/libs/sqlite/sqlitetransaction.cpp
@@ -34,12 +34,12 @@ namespace Sqlite {
 SqliteAbstractTransaction::~SqliteAbstractTransaction()
 {
     if (!m_isAlreadyCommited)
-        m_databaseBackend.execute(Utf8StringLiteral("ROLLBACK"));
+        m_databaseBackend.execute("ROLLBACK");
 }
 
 void SqliteAbstractTransaction::commit()
 {
-    m_databaseBackend.execute(Utf8StringLiteral("COMMIT"));
+    m_databaseBackend.execute("COMMIT");
     m_isAlreadyCommited = true;
 }
 
@@ -56,19 +56,19 @@ SqliteAbstractTransaction::SqliteAbstractTransaction(SqliteDatabase &database)
 SqliteTransaction::SqliteTransaction(SqliteDatabase &database)
     : SqliteAbstractTransaction(database)
 {
-    m_databaseBackend.execute(Utf8StringLiteral("BEGIN"));
+    m_databaseBackend.execute("BEGIN");
 }
 
 SqliteImmediateTransaction::SqliteImmediateTransaction(SqliteDatabase &database)
     : SqliteAbstractTransaction(database)
 {
-    m_databaseBackend.execute(Utf8StringLiteral("BEGIN IMMEDIATE"));
+    m_databaseBackend.execute("BEGIN IMMEDIATE");
 }
 
 SqliteExclusiveTransaction::SqliteExclusiveTransaction(SqliteDatabase &database)
     : SqliteAbstractTransaction(database)
 {
-    m_databaseBackend.execute(Utf8StringLiteral("BEGIN EXCLUSIVE"));
+    m_databaseBackend.execute("BEGIN EXCLUSIVE");
 }
 
 } // namespace Sqlite
diff --git a/src/libs/sqlite/sqlitewritestatement.cpp b/src/libs/sqlite/sqlitewritestatement.cpp
index 20eb0d03ec0c93df52104f950f69d051491e7e9a..934f99ee114ebd715df8534918dfe2ff4f02e36c 100644
--- a/src/libs/sqlite/sqlitewritestatement.cpp
+++ b/src/libs/sqlite/sqlitewritestatement.cpp
@@ -27,9 +27,9 @@
 
 namespace Sqlite {
 
-SqliteWriteStatement::SqliteWriteStatement(const Utf8String &sqlStatementUtf8,
+SqliteWriteStatement::SqliteWriteStatement(Utils::SmallStringView sqlStatement,
                                            SqliteDatabase &database)
-    : SqliteStatement(sqlStatementUtf8, database)
+    : SqliteStatement(sqlStatement, database)
 {
     checkIsWritableStatement();
 }
diff --git a/src/libs/sqlite/sqlitewritestatement.h b/src/libs/sqlite/sqlitewritestatement.h
index 14341203d6eea06dbcdd64e20c57d30206fec5cd..907222423d7cc5eae1b615e35b420cfbe4a6fb5e 100644
--- a/src/libs/sqlite/sqlitewritestatement.h
+++ b/src/libs/sqlite/sqlitewritestatement.h
@@ -32,17 +32,14 @@ namespace Sqlite {
 class SQLITE_EXPORT SqliteWriteStatement : private SqliteStatement
 {
 public:
-    explicit SqliteWriteStatement(const Utf8String &sqlStatementUtf8, SqliteDatabase &database);
+    explicit SqliteWriteStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
 
     using SqliteStatement::step;
     using SqliteStatement::reset;
     using SqliteStatement::bind;
-    using SqliteStatement::bindUnchecked;
     using SqliteStatement::bindingIndexForName;
     using SqliteStatement::setBindingColumnNames;
     using SqliteStatement::bindingColumnNames;
-    using SqliteStatement::write;
-    using SqliteStatement::writeUnchecked;
 
 protected:
     void checkIsWritableStatement();
diff --git a/src/libs/sqlite/sqlstatementbuilder.cpp b/src/libs/sqlite/sqlstatementbuilder.cpp
index 5dd7469f55cf2adbe3beb897e07ff6d9ad6f0c7d..7d34059733e616f767af6baae8e68ceb15a34b93 100644
--- a/src/libs/sqlite/sqlstatementbuilder.cpp
+++ b/src/libs/sqlite/sqlstatementbuilder.cpp
@@ -26,139 +26,164 @@
 #include "sqlstatementbuilder.h"
 
 #include "sqlstatementbuilderexception.h"
-#include "utf8stringvector.h"
+
+#include <utils/smallstringvector.h>
 
 #include <algorithm>
 
 namespace Sqlite {
 
-SqlStatementBuilder::SqlStatementBuilder(const Utf8String &sqlTemplate)
-    : m_sqlTemplate(sqlTemplate)
+SqlStatementBuilder::SqlStatementBuilder(Utils::SmallString &&sqlTemplate)
+    : m_sqlTemplate(std::move(sqlTemplate))
 {
 }
 
-void SqlStatementBuilder::bindEmptyText(const Utf8String &name)
+void SqlStatementBuilder::bindEmptyText(Utils::SmallString &&name)
 {
     clearSqlStatement();
     checkIfPlaceHolderExists(name);
-    changeBinding(name, Utf8String());
+    changeBinding(std::move(name), {});
 }
 
-void SqlStatementBuilder::bind(const Utf8String &name, const Utf8String &text)
+void SqlStatementBuilder::bind(Utils::SmallString &&name, Utils::SmallString &&text)
 {
     clearSqlStatement();
     checkBindingTextIsNotEmpty(text);
     checkIfPlaceHolderExists(name);
-    changeBinding(name, text);
+    changeBinding(std::move(name), std::move(text));
 }
 
-void SqlStatementBuilder::bind(const Utf8String &name, const Utf8StringVector &textVector)
+void SqlStatementBuilder::bind(Utils::SmallString &&name, const Utils::SmallStringVector &textVector)
 {
     clearSqlStatement();
     checkBindingTextVectorIsNotEmpty(textVector);
     checkIfPlaceHolderExists(name);
-    changeBinding(name, textVector.join(Utf8StringLiteral(", ")));
+    changeBinding(std::move(name), textVector.join(", "));
 }
 
-void SqlStatementBuilder::bind(const Utf8String &name, int value)
+void SqlStatementBuilder::bind(Utils::SmallString &&name, int value)
 {
     clearSqlStatement();
     checkIfPlaceHolderExists(name);
-    changeBinding(name, Utf8String::number(value));
+    changeBinding(std::move(name), Utils::SmallString::number(value));
 }
 
-void SqlStatementBuilder::bind(const Utf8String &name, const QVector<int> &integerVector)
+namespace {
+Utils::SmallStringVector integerVectorToStringVector(const std::vector<int> &integerVector)
+{
+    Utils::SmallStringVector stringVector;
+    stringVector.reserve(integerVector.size());
+
+    std::transform(integerVector.begin(),
+                   integerVector.end(),
+                   std::back_inserter(stringVector),
+                   [] (int i) { return Utils::SmallString::number(i); });
+
+    return stringVector;
+}
+}
+void SqlStatementBuilder::bind(Utils::SmallString &&name, const std::vector<int> &integerVector)
 {
     clearSqlStatement();
     checkBindingIntegerVectorIsNotEmpty(integerVector);
     checkIfPlaceHolderExists(name);
-    changeBinding(name, Utf8StringVector::fromIntegerVector(integerVector).join(Utf8StringLiteral(", ")));
+    changeBinding(std::move(name), integerVectorToStringVector(integerVector).join(", "));
 }
 
-void SqlStatementBuilder::bindWithInsertTemplateParameters(const Utf8String &name, const Utf8StringVector &columns)
+void SqlStatementBuilder::bindWithInsertTemplateParameters(Utils::SmallString &&name,
+                                                           const Utils::SmallStringVector &columns)
 {
     clearSqlStatement();
     checkBindingTextVectorIsNotEmpty(columns);
     checkIfPlaceHolderExists(name);
-    changeBinding(name, insertTemplateParameters(columns));
+    changeBinding(std::move(name), insertTemplateParameters(columns));
 }
 
-void SqlStatementBuilder::bindWithUpdateTemplateParameters(const Utf8String &name, const Utf8StringVector &columns)
+void SqlStatementBuilder::bindWithUpdateTemplateParameters(Utils::SmallString &&name,
+                                                           const Utils::SmallStringVector &columns)
 {
     clearSqlStatement();
     checkBindingTextVectorIsNotEmpty(columns);
     checkIfPlaceHolderExists(name);
-    changeBinding(name, updateTemplateParameters(columns));
+    changeBinding(std::move(name), updateTemplateParameters(columns));
 }
 
-void SqlStatementBuilder::bindWithUpdateTemplateNames(const Utf8String &name, const Utf8StringVector &columns)
+void SqlStatementBuilder::bindWithUpdateTemplateNames(Utils::SmallString &&name,
+                                                      const Utils::SmallStringVector &columns)
 {
     clearSqlStatement();
     checkBindingTextVectorIsNotEmpty(columns);
     checkIfPlaceHolderExists(name);
-    changeBinding(name, updateTemplateNames(columns));
+    changeBinding(std::move(name), updateTemplateNames(columns));
 }
 
 void SqlStatementBuilder::clear()
 {
     m_bindings.clear();
-    m_sqlStatement_.clear();
+    m_sqlStatement.clear();
 }
 
-const Utf8String SqlStatementBuilder::insertTemplateParameters(const Utf8StringVector &columns)
+Utils::SmallString SqlStatementBuilder::insertTemplateParameters(const Utils::SmallStringVector &columns)
 {
-    const Utf8StringVector templateParamters(columns.count(), Utf8StringLiteral("?"));
+    const Utils::SmallStringVector templateParamters(columns.size(), "?");
 
-    return templateParamters.join(Utf8StringLiteral(", "));
+    return templateParamters.join(", ");
 }
 
-const Utf8String SqlStatementBuilder::updateTemplateParameters(const Utf8StringVector &columns)
+Utils::SmallString SqlStatementBuilder::updateTemplateParameters(const Utils::SmallStringVector &columns)
 {
-    Utf8String templateParamters = columns.join(Utf8StringLiteral("=?, "));
-    templateParamters.append(Utf8StringLiteral("=?"));
+    Utils::SmallString templateParamters = columns.join("=?, ");
+    templateParamters.append("=?");
 
     return templateParamters;
 }
 
-const Utf8String SqlStatementBuilder::updateTemplateNames(const Utf8StringVector &columns)
+Utils::SmallString SqlStatementBuilder::updateTemplateNames(const Utils::SmallStringVector &columns)
 {
-    Utf8StringVector templateNames;
+    Utils::SmallStringVector templateNames;
+    templateNames.reserve(columns.size());
+
+    auto convertToTemplateNames = [] (const Utils::SmallString &column) {
+        return Utils::SmallString::join({column, "=@", column});
+    };
 
-    foreach (const Utf8String &columnName, columns)
-        templateNames.append(columnName+Utf8StringLiteral("=@")+columnName);
+    std::transform(columns.begin(),
+                   columns.end(),
+                   std::back_inserter(templateNames),
+                   convertToTemplateNames);
 
-    return templateNames.join(Utf8StringLiteral(", "));
+    return templateNames.join(", ");
 }
 
 void SqlStatementBuilder::sortBindings() const
 {
     std::sort(m_bindings.begin(), m_bindings.end(), [] (const BindingPair &lhs,const BindingPair &rhs)
     {
-        return lhs.first.byteSize() == rhs.first.byteSize() ? lhs.first.toByteArray() < rhs.first.toByteArray() : lhs.first.byteSize() > rhs.first.byteSize();
+        return lhs.first.size() == rhs.first.size() ? lhs.first < rhs.first : lhs.first.size() > rhs.first.size();
     });
 }
 
-Utf8String SqlStatementBuilder::sqlStatement() const
+Utils::SmallStringView SqlStatementBuilder::sqlStatement() const
 {
     if (!isBuild())
         generateSqlStatement();
 
-    return m_sqlStatement_;
+    return m_sqlStatement;
 }
 
 bool SqlStatementBuilder::isBuild() const
 {
-    return m_sqlStatement_.hasContent();
+    return m_sqlStatement.hasContent();
 }
 
-Utf8String SqlStatementBuilder::columnTypeToString(ColumnType columnType)
+Utils::SmallString SqlStatementBuilder::columnTypeToString(ColumnType columnType)
 {
     switch (columnType) {
-        case ColumnType::Numeric: return Utf8StringLiteral("NUMERIC");
-        case ColumnType::Integer: return Utf8StringLiteral("INTEGER");
-        case ColumnType::Real: return Utf8StringLiteral("REAL");
-        case ColumnType::Text: return Utf8StringLiteral("TEXT");
-        case ColumnType::None: return Utf8String();
+        case ColumnType::Numeric: return "NUMERIC";
+        case ColumnType::Integer: return "INTEGER";
+        case ColumnType::Real: return "REAL";
+        case ColumnType::Text: return "TEXT";
+        case ColumnType::None: return {};
     }
 
     Q_UNREACHABLE();
@@ -166,66 +191,66 @@ Utf8String SqlStatementBuilder::columnTypeToString(ColumnType columnType)
 
 void SqlStatementBuilder::generateSqlStatement() const
 {
-    m_sqlStatement_ = m_sqlTemplate;
+    m_sqlStatement = m_sqlTemplate;
 
     sortBindings();
 
-    auto bindingIterator = m_bindings.cbegin();
-    while (bindingIterator != m_bindings.cend()) {
-        const Utf8String &placeHolderToken = bindingIterator->first;
-        const Utf8String &replacementToken = bindingIterator->second;
-        m_sqlStatement_.replace(placeHolderToken, replacementToken);
-        ++bindingIterator;
+    for (const auto &entry : m_bindings) {
+        const Utils::SmallStringView placeHolderToken = entry.first;
+        const Utils::SmallStringView replacementToken = entry.second;
+        m_sqlStatement.replace(placeHolderToken, replacementToken);
     }
 
     checkIfNoPlaceHoldersAynmoreExists();
 }
 
-void SqlStatementBuilder::changeBinding(const Utf8String &name, const Utf8String &text)
+void SqlStatementBuilder::changeBinding(Utils::SmallString &&name, Utils::SmallString &&text)
 {
 
-    auto findBindingIterator = std::find_if(m_bindings.begin(), m_bindings.end(), [name] (const BindingPair &binding) {
+    auto findBindingIterator = std::find_if(m_bindings.begin(),
+                                            m_bindings.end(),
+                                            [&] (const BindingPair &binding) {
         return binding.first == name;
     });
 
     if (findBindingIterator == m_bindings.end())
-        m_bindings.push_back(std::make_pair(name, text));
+        m_bindings.push_back(std::make_pair(std::move(name), std::move(text)));
     else
-        findBindingIterator->second = text;
+        findBindingIterator->second = std::move(text);
 }
 
 void SqlStatementBuilder::clearSqlStatement()
 {
-    m_sqlStatement_.clear();
+    m_sqlStatement.clear();
 }
 
-void SqlStatementBuilder::checkIfPlaceHolderExists(const Utf8String &name) const
+void SqlStatementBuilder::checkIfPlaceHolderExists(Utils::SmallStringView name) const
 {
-    if (name.byteSize() < 2 || !name.startsWith('$') || !m_sqlTemplate.contains(name))
-        throwException("SqlStatementBuilder::bind: placeholder name does not exists!", name.constData());
+    if (name.size() < 2 || !name.startsWith('$') || !m_sqlTemplate.contains(name))
+        throwException("SqlStatementBuilder::bind: placeholder name does not exists!", name.data());
 }
 
 void SqlStatementBuilder::checkIfNoPlaceHoldersAynmoreExists() const
 {
-    if (m_sqlStatement_.contains('$'))
+    if (m_sqlStatement.contains('$'))
         throwException("SqlStatementBuilder::bind: there are still placeholder in the sql statement!", m_sqlTemplate.constData());
 }
 
-void SqlStatementBuilder::checkBindingTextIsNotEmpty(const Utf8String &text) const
+void SqlStatementBuilder::checkBindingTextIsNotEmpty(Utils::SmallStringView text) const
 {
     if (text.isEmpty())
         throwException("SqlStatementBuilder::bind: binding text it empty!", m_sqlTemplate.constData());
 }
 
-void SqlStatementBuilder::checkBindingTextVectorIsNotEmpty(const Utf8StringVector &textVector) const
+void SqlStatementBuilder::checkBindingTextVectorIsNotEmpty(const Utils::SmallStringVector &textVector) const
 {
-    if (textVector.isEmpty())
+    if (textVector.empty())
         throwException("SqlStatementBuilder::bind: binding text vector it empty!", m_sqlTemplate.constData());
 }
 
-void SqlStatementBuilder::checkBindingIntegerVectorIsNotEmpty(const QVector<int> &integerVector) const
+void SqlStatementBuilder::checkBindingIntegerVectorIsNotEmpty(const std::vector<int> &integerVector) const
 {
-    if (integerVector.isEmpty())
+    if (integerVector.empty())
         throwException("SqlStatementBuilder::bind: binding integer vector it empty!", m_sqlTemplate.constData());
 }
 
diff --git a/src/libs/sqlite/sqlstatementbuilder.h b/src/libs/sqlite/sqlstatementbuilder.h
index b1d70f18e31a01090bb64b88b4b17a6089f4a3be..c24e0b9ed947dd20f766d70a17252a4038185154 100644
--- a/src/libs/sqlite/sqlstatementbuilder.h
+++ b/src/libs/sqlite/sqlstatementbuilder.h
@@ -25,7 +25,9 @@
 
 #pragma once
 
-#include "utf8string.h"
+#include "sqliteglobal.h"
+
+#include <utils/smallstringvector.h>
 
 #include <utility>
 #include <vector>
@@ -34,48 +36,51 @@ namespace Sqlite {
 
 class SQLITE_EXPORT SqlStatementBuilder
 {
-    using BindingPair = std::pair<Utf8String, Utf8String>;
+    using BindingPair = std::pair<Utils::SmallString, Utils::SmallString>;
 public:
-    SqlStatementBuilder(const Utf8String &m_sqlTemplate);
-
-    void bindEmptyText(const Utf8String &name);
-    void bind(const Utf8String &name, const Utf8String &text);
-    void bind(const Utf8String &name, const Utf8StringVector &textVector);
-    void bind(const Utf8String &name, int value);
-    void bind(const Utf8String &name, const QVector<int> &integerVector);
-    void bindWithInsertTemplateParameters(const Utf8String &name, const Utf8StringVector &columns);
-    void bindWithUpdateTemplateParameters(const Utf8String &name, const Utf8StringVector &columns);
-    void bindWithUpdateTemplateNames(const Utf8String &name, const Utf8StringVector &columns);
+    SqlStatementBuilder(Utils::SmallString &&m_sqlTemplate);
+
+    void bindEmptyText(Utils::SmallString &&name);
+    void bind(Utils::SmallString &&name, Utils::SmallString &&text);
+    void bind(Utils::SmallString &&name, const Utils::SmallStringVector &textVector);
+    void bind(Utils::SmallString &&name, int value);
+    void bind(Utils::SmallString &&name, const std::vector<int> &integerVector);
+    void bindWithInsertTemplateParameters(Utils::SmallString &&name,
+                                          const Utils::SmallStringVector &columns);
+    void bindWithUpdateTemplateParameters(Utils::SmallString &&name,
+                                          const Utils::SmallStringVector &columns);
+    void bindWithUpdateTemplateNames(Utils::SmallString &&name,
+                                     const Utils::SmallStringVector &columns);
     void clear();
 
-    Utf8String sqlStatement() const;
+    Utils::SmallStringView sqlStatement() const;
 
     bool isBuild() const;
 
-    static Utf8String columnTypeToString(ColumnType columnType);
+    static Utils::SmallString columnTypeToString(ColumnType columnType);
 
 protected:
-    static const Utf8String insertTemplateParameters(const Utf8StringVector &columns);
-    static const Utf8String updateTemplateParameters(const Utf8StringVector &columns);
-    static const Utf8String updateTemplateNames(const Utf8StringVector &columns);
+    static Utils::SmallString insertTemplateParameters(const Utils::SmallStringVector &columns);
+    static Utils::SmallString updateTemplateParameters(const Utils::SmallStringVector &columns);
+    static Utils::SmallString updateTemplateNames(const Utils::SmallStringVector &columns);
 
     void sortBindings() const;
     void generateSqlStatement() const;
 
-    void changeBinding(const Utf8String &name, const Utf8String &text);
+    void changeBinding(Utils::SmallString &&name, Utils::SmallString &&text);
 
     void clearSqlStatement();
-    void checkIfPlaceHolderExists(const Utf8String &name) const;
+    void checkIfPlaceHolderExists(Utils::SmallStringView name) const;
     void checkIfNoPlaceHoldersAynmoreExists() const;
-    void checkBindingTextIsNotEmpty(const Utf8String &text) const;
-    void checkBindingTextVectorIsNotEmpty(const Utf8StringVector &textVector) const;
-    void checkBindingIntegerVectorIsNotEmpty(const QVector<int> &integerVector) const;
+    void checkBindingTextIsNotEmpty(Utils::SmallStringView text) const;
+    void checkBindingTextVectorIsNotEmpty(const Utils::SmallStringVector &textVector) const;
+    void checkBindingIntegerVectorIsNotEmpty(const std::vector<int> &integerVector) const;
 
     Q_NORETURN static void throwException(const char *whatHasHappened, const char *errorMessage);
 
 private:
-    Utf8String m_sqlTemplate;
-    mutable Utf8String m_sqlStatement_;
+    Utils::SmallString m_sqlTemplate;
+    mutable Utils::SmallString m_sqlStatement;
     mutable std::vector<BindingPair> m_bindings;
 };
 
diff --git a/tests/unit/unittest/createtablesqlstatementbuilder-test.cpp b/tests/unit/unittest/createtablesqlstatementbuilder-test.cpp
index 8da34753b84bbf52baa8efda4fe455a5540a2253..9baafcfb4e2efcf264ea5d27eac5ea7c548e4d5e 100644
--- a/tests/unit/unittest/createtablesqlstatementbuilder-test.cpp
+++ b/tests/unit/unittest/createtablesqlstatementbuilder-test.cpp
@@ -25,24 +25,21 @@
 
 #include "googletest.h"
 
-#include <QString>
-
 #include <createtablesqlstatementbuilder.h>
 #include <sqlstatementbuilderexception.h>
 
-#include <utf8stringvector.h>
-
 namespace {
 
 using Sqlite::ColumnDefinition;
+using Sqlite::ColumnDefinitions;
 using Sqlite::SqlStatementBuilderException;
 
 class CreateTableSqlStatementBuilder : public ::testing::Test
 {
 protected:
     void bindValues();
-    static const QVector<ColumnDefinition> createColumnDefintions();
-    static const ColumnDefinition createColumnDefintion(const Utf8String &name,
+    static ColumnDefinitions createColumnDefintions();
+    static ColumnDefinition createColumnDefintion(Utils::SmallString name,
                                                         ColumnType type,
                                                         bool isPrimaryKey = false);
 protected:
@@ -85,25 +82,25 @@ TEST_F(CreateTableSqlStatementBuilder, SqlStatement)
     bindValues();
 
     ASSERT_THAT(builder.sqlStatement(),
-                Utf8StringLiteral("CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)"));}
+                "CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)");}
 
 TEST_F(CreateTableSqlStatementBuilder, AddColumnToExistingColumns)
 {
     bindValues();
 
-    builder.addColumnDefinition(Utf8StringLiteral("number2"), ColumnType::Real);
+    builder.addColumnDefinition("number2", ColumnType::Real);
 
     ASSERT_THAT(builder.sqlStatement(),
-                Utf8StringLiteral("CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC, number2 REAL)"));}
+                "CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC, number2 REAL)");}
 
 TEST_F(CreateTableSqlStatementBuilder, ChangeTable)
 {
     bindValues();
 
-    builder.setTable(Utf8StringLiteral("test2"));
+    builder.setTable("test2");
 
     ASSERT_THAT(builder.sqlStatement(),
-                Utf8StringLiteral("CREATE TABLE IF NOT EXISTS test2(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)"));
+                "CREATE TABLE IF NOT EXISTS test2(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)");
 }
 
 TEST_F(CreateTableSqlStatementBuilder, IsInvalidAfterClearColumsOnly)
@@ -121,11 +118,11 @@ TEST_F(CreateTableSqlStatementBuilder, ClearColumnsAndAddColumnNewColumns)
     bindValues();
     builder.clearColumns();
 
-    builder.addColumnDefinition(Utf8StringLiteral("name3"), ColumnType::Text);
-    builder.addColumnDefinition(Utf8StringLiteral("number3"), ColumnType::Real);
+    builder.addColumnDefinition("name3", ColumnType::Text);
+    builder.addColumnDefinition("number3", ColumnType::Real);
 
     ASSERT_THAT(builder.sqlStatement(),
-                Utf8StringLiteral("CREATE TABLE IF NOT EXISTS test(name3 TEXT, number3 REAL)"));
+                "CREATE TABLE IF NOT EXISTS test(name3 TEXT, number3 REAL)");
 }
 
 TEST_F(CreateTableSqlStatementBuilder, SetWitoutRowId)
@@ -135,44 +132,44 @@ TEST_F(CreateTableSqlStatementBuilder, SetWitoutRowId)
     builder.setUseWithoutRowId(true);
 
     ASSERT_THAT(builder.sqlStatement(),
-                Utf8StringLiteral("CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC) WITHOUT ROWID"));
+                "CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC) WITHOUT ROWID");
 }
 
 TEST_F(CreateTableSqlStatementBuilder, SetColumnDefinitions)
 {
     builder.clear();
-    builder.setTable(Utf8StringLiteral("test"));
+    builder.setTable("test");
 
     builder.setColumnDefinitions(createColumnDefintions());
 
     ASSERT_THAT(builder.sqlStatement(),
-                Utf8StringLiteral("CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)"));
+                "CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)");
 }
 
 void CreateTableSqlStatementBuilder::bindValues()
 {
     builder.clear();
-    builder.setTable(Utf8StringLiteral("test"));
-    builder.addColumnDefinition(Utf8StringLiteral("id"), ColumnType::Integer, true);
-    builder.addColumnDefinition(Utf8StringLiteral("name"), ColumnType::Text);
-    builder.addColumnDefinition(Utf8StringLiteral("number"),ColumnType:: Numeric);
+    builder.setTable("test");
+    builder.addColumnDefinition("id", ColumnType::Integer, true);
+    builder.addColumnDefinition("name", ColumnType::Text);
+    builder.addColumnDefinition("number",ColumnType:: Numeric);
 }
 
-const QVector<ColumnDefinition> CreateTableSqlStatementBuilder::createColumnDefintions()
+ColumnDefinitions CreateTableSqlStatementBuilder::createColumnDefintions()
 {
-    QVector<ColumnDefinition>  columnDefinitions;
-    columnDefinitions.append(createColumnDefintion(Utf8StringLiteral("id"), ColumnType::Integer, true));
-    columnDefinitions.append(createColumnDefintion(Utf8StringLiteral("name"), ColumnType::Text));
-    columnDefinitions.append(createColumnDefintion(Utf8StringLiteral("number"), ColumnType::Numeric));
+    ColumnDefinitions  columnDefinitions;
+    columnDefinitions.push_back(createColumnDefintion("id", ColumnType::Integer, true));
+    columnDefinitions.push_back(createColumnDefintion("name", ColumnType::Text));
+    columnDefinitions.push_back(createColumnDefintion("number", ColumnType::Numeric));
 
     return columnDefinitions;
 }
 
-const ColumnDefinition CreateTableSqlStatementBuilder::createColumnDefintion(const Utf8String &name, ColumnType type, bool isPrimaryKey)
+ColumnDefinition CreateTableSqlStatementBuilder::createColumnDefintion(Utils::SmallString name, ColumnType type, bool isPrimaryKey)
 {
     ColumnDefinition columnDefinition;
 
-    columnDefinition.setName(name);
+    columnDefinition.setName(std::move(name));
     columnDefinition.setType(type);
     columnDefinition.setIsPrimaryKey(isPrimaryKey);
 
diff --git a/tests/unit/unittest/sqlitecolumn-test.cpp b/tests/unit/unittest/sqlitecolumn-test.cpp
index 1be06324588241782845fa1ac03c953d103525f5..5da235dda17ba4df5cba2de660cdaf99946b5308 100644
--- a/tests/unit/unittest/sqlitecolumn-test.cpp
+++ b/tests/unit/unittest/sqlitecolumn-test.cpp
@@ -41,9 +41,9 @@ protected:
 
 TEST_F(SqliteColumn, ChangeName)
 {
-    column.setName(Utf8StringLiteral("Claudia"));
+    column.setName("Claudia");
 
-    ASSERT_THAT(column.name(), Utf8StringLiteral("Claudia"));
+    ASSERT_THAT(column.name(), "Claudia");
 }
 
 TEST_F(SqliteColumn, DefaultType)
@@ -72,11 +72,11 @@ TEST_F(SqliteColumn, SetPrimaryKey)
 
 TEST_F(SqliteColumn, GetColumnDefinition)
 {
-    column.setName(Utf8StringLiteral("Claudia"));
+    column.setName("Claudia");
 
     ColumnDefinition columnDefintion = column.columnDefintion();
 
-    ASSERT_THAT(columnDefintion.name(), Utf8StringLiteral("Claudia"));
+    ASSERT_THAT(columnDefintion.name(), "Claudia");
     ASSERT_THAT(columnDefintion.type(), ColumnType::Numeric);
     ASSERT_FALSE(columnDefintion.isPrimaryKey());
 }
diff --git a/tests/unit/unittest/sqlitedatabasebackend-test.cpp b/tests/unit/unittest/sqlitedatabasebackend-test.cpp
index b15e5e1ea77cd5c870ef21c27e80f3beb85c8ff6..88c7a53063f1354dc852fddf7166e260b7fe09b5 100644
--- a/tests/unit/unittest/sqlitedatabasebackend-test.cpp
+++ b/tests/unit/unittest/sqlitedatabasebackend-test.cpp
@@ -42,7 +42,7 @@ protected:
     void SetUp() override;
     void TearDown() override;
 
-    QString databaseFilePath = QDir::tempPath() + QStringLiteral("/SqliteDatabaseBackendTest.db");
+    Utils::PathString databaseFilePath = QDir::tempPath() + "/SqliteDatabaseBackendTest.db";
     Sqlite::SqliteDatabaseBackend databaseBackend;
 };
 
@@ -62,7 +62,7 @@ TEST_F(SqliteDatabaseBackend, CloseAlreadyClosedDatabase)
 
 TEST_F(SqliteDatabaseBackend, OpenWithWrongPath)
 {
-    ASSERT_THROW(databaseBackend.open(QStringLiteral("/xxx/SqliteDatabaseBackendTest.db")), SqliteException);
+    ASSERT_THROW(databaseBackend.open("/xxx/SqliteDatabaseBackendTest.db"), SqliteException);
 }
 
 TEST_F(SqliteDatabaseBackend, DefaultJournalMode)
@@ -135,7 +135,7 @@ TEST_F(SqliteDatabaseBackend, TextEncodingCannotBeChangedAfterTouchingDatabase)
 {
     databaseBackend.setJournalMode(JournalMode::Memory);
 
-    databaseBackend.execute(Utf8StringLiteral("CREATE TABLE text(name, number)"));
+    databaseBackend.execute("CREATE TABLE text(name, number)");
 
     ASSERT_THROW(databaseBackend.setTextEncoding(Utf16), SqliteException);
 }
diff --git a/tests/unit/unittest/sqlitestatement-test.cpp b/tests/unit/unittest/sqlitestatement-test.cpp
index 0acb7d7635b8438daa468a604eaba83e3c8157f2..952c2112f459dec6d467dd19f4dba45b5b3b5770 100644
--- a/tests/unit/unittest/sqlitestatement-test.cpp
+++ b/tests/unit/unittest/sqlitestatement-test.cpp
@@ -29,17 +29,15 @@
 #include <sqlitereadstatement.h>
 #include <sqlitereadwritestatement.h>
 #include <sqlitewritestatement.h>
-#include <utf8string.h>
 
-#include <QByteArray>
 #include <QDir>
-#include <QMap>
-#include <QString>
-#include <QStringList>
-#include <QVariant>
+
+#include <vector>
 
 namespace {
 
+using testing::ElementsAre;
+
 using Sqlite::SqliteException;
 using Sqlite::SqliteDatabase;
 using Sqlite::SqliteReadStatement;
@@ -57,58 +55,44 @@ protected:
 
 TEST_F(SqliteStatement, PrepareFailure)
 {
-    ASSERT_THROW(SqliteReadStatement(Utf8StringLiteral("blah blah blah"), database), SqliteException);
-    ASSERT_THROW(SqliteWriteStatement(Utf8StringLiteral("blah blah blah"), database), SqliteException);
-    ASSERT_THROW(SqliteReadStatement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)"), database), SqliteException);
-    ASSERT_THROW(SqliteWriteStatement(Utf8StringLiteral("SELECT name, number FROM test '"), database), SqliteException);
+    ASSERT_THROW(SqliteReadStatement("blah blah blah", database), SqliteException);
+    ASSERT_THROW(SqliteWriteStatement("blah blah blah", database), SqliteException);
+    ASSERT_THROW(SqliteReadStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), SqliteException);
+    ASSERT_THROW(SqliteWriteStatement("SELECT name, number FROM test '", database), SqliteException);
 }
 
 TEST_F(SqliteStatement, CountRows)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT * FROM test"), database);
+    SqliteReadStatement statement("SELECT * FROM test", database);
     int nextCount = 0;
     while (statement.next())
         ++nextCount;
 
-    int sqlCount = SqliteReadStatement::toValue<int>(Utf8StringLiteral("SELECT count(*) FROM test"), database);
+    int sqlCount = SqliteReadStatement::toValue<int>("SELECT count(*) FROM test", database);
 
     ASSERT_THAT(nextCount, sqlCount);
 }
 
 TEST_F(SqliteStatement, Value)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER BY name"), database);
-
+    SqliteReadStatement statement("SELECT name, number FROM test ORDER BY name", database);
     statement.next();
 
-    ASSERT_THAT(statement.value<QVariant>(1).type(), QVariant::ByteArray);
-
     statement.next();
 
     ASSERT_THAT(statement.value<int>(0), 0);
     ASSERT_THAT(statement.value<qint64>(0), 0);
     ASSERT_THAT(statement.value<double>(0), 0.0);
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("foo"));
-    ASSERT_THAT(statement.value<Utf8String>(0), Utf8StringLiteral("foo"));
-    ASSERT_THAT(statement.value<QVariant>(0), QVariant::fromValue(QStringLiteral("foo")));
-    ASSERT_THAT(statement.value<QVariant>(0).type(), QVariant::String);
-
+    ASSERT_THAT(statement.text(0), "foo");
     ASSERT_THAT(statement.value<int>(1), 23);
     ASSERT_THAT(statement.value<qint64>(1), 23);
     ASSERT_THAT(statement.value<double>(1), 23.3);
-    ASSERT_THAT(statement.value<QString>(1), QStringLiteral("23.3"));
-    ASSERT_THAT(statement.value<Utf8String>(1), Utf8StringLiteral("23.3"));
-    ASSERT_THAT(statement.value<QVariant>(1), QVariant::fromValue(23.3));
-    ASSERT_THAT(statement.value<QVariant>(1).type(), QVariant::Double);
-
-    statement.next();
-
-    ASSERT_THAT(statement.value<QVariant>(1).type(), QVariant::LongLong);
+    ASSERT_THAT(statement.text(1), "23.3");
 }
 
 TEST_F(SqliteStatement, ValueFailure)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test", database);
     ASSERT_THROW(statement.value<int>(0), SqliteException);
 
     statement.reset();
@@ -125,442 +109,164 @@ TEST_F(SqliteStatement, ValueFailure)
 
 TEST_F(SqliteStatement, ToIntergerValue)
 {
-    ASSERT_THAT(SqliteReadStatement::toValue<int>(Utf8StringLiteral("SELECT number FROM test WHERE name='foo'"), database), 23);
+    ASSERT_THAT(SqliteReadStatement::toValue<int>("SELECT number FROM test WHERE name='foo'", database), 23);
 }
 
 TEST_F(SqliteStatement, ToLongIntergerValue)
 {
-    ASSERT_THAT(SqliteReadStatement::toValue<qint64>(Utf8StringLiteral("SELECT number FROM test WHERE name='foo'"), database), 23LL);
+    ASSERT_THAT(SqliteReadStatement::toValue<qint64>("SELECT number FROM test WHERE name='foo'", database), 23LL);
 }
 
 TEST_F(SqliteStatement, ToDoubleValue)
 {
-    ASSERT_THAT(SqliteReadStatement::toValue<double>(Utf8StringLiteral("SELECT number FROM test WHERE name='foo'"), database), 23.3);
-}
-
-TEST_F(SqliteStatement, ToQStringValue)
-{
-    ASSERT_THAT(SqliteReadStatement::toValue<QString>(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'"), database), QStringLiteral("foo"));
-}
-
-TEST_F(SqliteStatement, ToUtf8StringValue)
-{
-    ASSERT_THAT(SqliteReadStatement::toValue<Utf8String>(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'"), database), Utf8StringLiteral("foo"));
-}
-
-TEST_F(SqliteStatement, ToQByteArrayValueIsNull)
-{
-    ASSERT_TRUE(SqliteReadStatement::toValue<QByteArray>(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'"), database).isNull());
+    ASSERT_THAT(SqliteReadStatement::toValue<double>("SELECT number FROM test WHERE name='foo'", database), 23.3);
 }
 
-TEST_F(SqliteStatement, ToQVariantValue)
+TEST_F(SqliteStatement, ToStringValue)
 {
-    ASSERT_THAT(SqliteReadStatement::toValue<QVariant>(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'"), database), QVariant::fromValue(QStringLiteral("foo")));
+    ASSERT_THAT(SqliteReadStatement::toValue<Utils::SmallString>("SELECT name FROM test WHERE name='foo'", database), "foo");
 }
 
 TEST_F(SqliteStatement, Utf8Values)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER by name"), database);
-
-    Utf8StringVector values = statement.values<Utf8StringVector>();
-    ASSERT_THAT(values.count(), 3);
-    ASSERT_THAT(values.at(0), Utf8StringLiteral("bar"));
-    ASSERT_THAT(values.at(1), Utf8StringLiteral("foo"));
-    ASSERT_THAT(values.at(2), Utf8StringLiteral("poo"));
-}
-TEST_F(SqliteStatement, DoubleValues)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER by name"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test ORDER by name", database);
 
-    QVector<double> values = statement.values<QVector<double>>(1);
+    auto values = statement.values<Utils::SmallStringVector>();
 
-    ASSERT_THAT(values.count(), 3);
-    ASSERT_THAT(values.at(0), 0.0);
-    ASSERT_THAT(values.at(1), 23.3);
-    ASSERT_THAT(values.at(2), 40.0);
+    ASSERT_THAT(values, ElementsAre("bar", "foo", "poo"));
 }
-
-TEST_F(SqliteStatement, QVariantValues)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER by name"), database);
-
-    QVector<QVariant> values = statement.values<QVector<QVariant>>(QVector<int>() << 0 << 1);
-
-    ASSERT_THAT(values.count(), 6);
-    ASSERT_THAT(values.at(0), QVariant::fromValue(QStringLiteral("bar")));
-    ASSERT_THAT(values.at(1), QVariant::fromValue(QByteArray::fromHex("0500")));
-    ASSERT_THAT(values.at(2), QVariant::fromValue(QStringLiteral("foo")));
-    ASSERT_THAT(values.at(3), QVariant::fromValue(23.3));
-    ASSERT_THAT(values.at(4), QVariant::fromValue(QStringLiteral("poo")));
-    ASSERT_THAT(values.at(5), QVariant::fromValue(40));
-}
-
-TEST_F(SqliteStatement, RowColumnValueMapCountForValidRow)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE rowid=1"), database);
-
-    QMap<QString, QVariant> values = statement.rowColumnValueMap();
-
-    ASSERT_THAT(values.count(), 2);
-}
-
-TEST_F(SqliteStatement, RowColumnValueMapCountForInvalidRow)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE rowid=100"), database);
-
-    QMap<QString, QVariant> values = statement.rowColumnValueMap();
-
-    ASSERT_THAT(values.count(), 0);
-}
-
-TEST_F(SqliteStatement, RowColumnValueMapValues)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE rowid=2"), database);
-
-    QMap<QString, QVariant> values = statement.rowColumnValueMap();
-
-    ASSERT_THAT(values.value(QStringLiteral("name")).toString(), QStringLiteral("foo"));
-    ASSERT_THAT(values.value(QStringLiteral("number")).toDouble(), 23.3);
-}
-
-TEST_F(SqliteStatement, TwoColumnValueMapCount)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database);
-
-    QMap<QString, QVariant> values = statement.twoColumnValueMap();
-
-    ASSERT_THAT(values.count(), 3);
-}
-
-TEST_F(SqliteStatement, TwoColumnValueMapValues)
+TEST_F(SqliteStatement, DoubleValues)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test ORDER by name", database);
 
-    QMap<QString, QVariant> values = statement.twoColumnValueMap();
+    auto values = statement.values<std::vector<double>>(1);
 
-    ASSERT_THAT(values.value(QStringLiteral("foo")).toDouble(), 23.3);
+    ASSERT_THAT(values, ElementsAre(0.0, 23.3, 40.0));
 }
 
 TEST_F(SqliteStatement, ValuesFailure)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test", database);
 
-    ASSERT_THROW(statement.values<QVector<QVariant>>(QVector<int>() << 1 << 2);, SqliteException);
-    ASSERT_THROW(statement.values<QVector<QVariant>>(QVector<int>() << -1 << 1);, SqliteException);
+    ASSERT_THROW(statement.values<Utils::SmallStringVector>({1, 2}), SqliteException);
+    ASSERT_THROW(statement.values<Utils::SmallStringVector>({-1, 1}), SqliteException);
 }
 
 TEST_F(SqliteStatement, ColumnNames)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database);
-
-    Utf8StringVector columnNames = statement.columnNames();
+    SqliteReadStatement statement("SELECT name, number FROM test", database);
 
-    ASSERT_THAT(columnNames.count(), statement.columnCount());
+    auto columnNames = statement.columnNames();
 
-    ASSERT_THAT(columnNames.at(0), Utf8StringLiteral("name"));
-    ASSERT_THAT(columnNames.at(1), Utf8StringLiteral("number"));
+    ASSERT_THAT(columnNames, ElementsAre("name", "number"));
 }
 
-TEST_F(SqliteStatement, BindQString)
+TEST_F(SqliteStatement, BindString)
 {
 
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name=?"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test WHERE name=?", database);
 
-    statement.bind(1, QStringLiteral("foo"));
+    statement.bind(1, "foo");
 
     statement.next();
 
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("foo"));
+    ASSERT_THAT(statement.text(0), "foo");
     ASSERT_THAT(statement.value<double>(1), 23.3);
 }
 
 TEST_F(SqliteStatement, BindInteger)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test WHERE number=?", database);
 
     statement.bind(1, 40);
     statement.next();
 
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("poo"));
+    ASSERT_THAT(statement.text(0),"poo");
 }
 
 TEST_F(SqliteStatement, BindLongInteger)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test WHERE number=?", database);
 
     statement.bind(1, qint64(40));
     statement.next();
 
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("poo"));
-}
-
-TEST_F(SqliteStatement, BindByteArray)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database);
-
-    statement.bind(1, QByteArray::fromHex("0500"));
-    statement.next();
-
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("bar"));
+    ASSERT_THAT(statement.text(0), "poo");
 }
 
 TEST_F(SqliteStatement, BindDouble)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test WHERE number=?", database);
 
     statement.bind(1, 23.3);
     statement.next();
 
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("foo"));
-}
-
-TEST_F(SqliteStatement, BindIntergerQVariant)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database);
-
-    statement.bind(1, QVariant::fromValue(40));
-    statement.next();
-
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("poo"));
-}
-
-TEST_F(SqliteStatement, BindLongIntergerQVariant)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database);
-
-    statement.bind(1, QVariant::fromValue(qint64(40)));
-    statement.next();
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("poo"));
-}
-
-TEST_F(SqliteStatement, BindDoubleQVariant)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database);
-
-    statement.bind(1, QVariant::fromValue(23.3));
-    statement.next();
-
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("foo"));
- }
-
-TEST_F(SqliteStatement, BindByteArrayQVariant)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database);
-
-    statement.bind(1, QVariant::fromValue(QByteArray::fromHex("0500")));
-    statement.next();
-
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("bar"));
+    ASSERT_THAT(statement.text(0), "foo");
 }
 
 TEST_F(SqliteStatement, BindIntegerByParameter)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test WHERE number=@number", database);
 
-    statement.bind(Utf8StringLiteral("@number"), 40);
+    statement.bind("@number", 40);
     statement.next();
 
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("poo"));
+    ASSERT_THAT(statement.text(0), "poo");
 }
 
 TEST_F(SqliteStatement, BindLongIntegerByParameter)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database);
-
-    statement.bind(Utf8StringLiteral("@number"), qint64(40));
-    statement.next();
-
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("poo"));
-}
-
-TEST_F(SqliteStatement, BindByteArrayByParameter)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test WHERE number=@number", database);
 
-    statement.bind(Utf8StringLiteral("@number"), QByteArray::fromHex("0500"));
+    statement.bind("@number", qint64(40));
     statement.next();
 
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("bar"));
+    ASSERT_THAT(statement.text(0), "poo");
 }
 
 TEST_F(SqliteStatement, BindDoubleByIndex)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database);
-
-    statement.bind(statement.bindingIndexForName(Utf8StringLiteral("@number")), 23.3);
-    statement.next();
-
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("foo"));
-}
-
-TEST_F(SqliteStatement, BindQVariantByIndex)
-{
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test WHERE number=@number", database);
 
-    statement.bind(statement.bindingIndexForName(Utf8StringLiteral("@number")), QVariant::fromValue((40)));
+    statement.bind(statement.bindingIndexForName("@number"), 23.3);
     statement.next();
 
-    ASSERT_THAT(statement.value<QString>(0), QStringLiteral("poo"));
-
+    ASSERT_THAT(statement.text(0), "foo");
 }
 
 TEST_F(SqliteStatement, BindFailure)
 {
-    SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database);
+    SqliteReadStatement statement("SELECT name, number FROM test WHERE number=@number", database);
 
     ASSERT_THROW(statement.bind(0, 40), SqliteException);
     ASSERT_THROW(statement.bind(2, 40), SqliteException);
-    ASSERT_THROW(statement.bind(Utf8StringLiteral("@name"), 40), SqliteException);
+    ASSERT_THROW(statement.bind("@name", 40), SqliteException);
 }
 
 TEST_F(SqliteStatement, RequestBindingNamesFromStatement)
 {
-    Utf8StringVector expectedValues({Utf8StringLiteral("name"), Utf8StringLiteral("number"), Utf8StringLiteral("id")});
-
-    SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET name=@name, number=@number WHERE rowid=@id"), database);
-
-    ASSERT_THAT(statement.bindingColumnNames(), expectedValues);
-}
-
-TEST_F(SqliteStatement, WriteUpdateWidthUnamedParameter)
-{
-    {
-        int startTotalCount = database.totalChangesCount();
-        RowDictionary firstValueMap;
-        firstValueMap.insert(Utf8StringLiteral("name"), QStringLiteral("foo"));
-        firstValueMap.insert(Utf8StringLiteral("number"), 66.6);
-
-        RowDictionary secondValueMap;
-        secondValueMap.insert(Utf8StringLiteral("name"), QStringLiteral("bar"));
-        secondValueMap.insert(Utf8StringLiteral("number"), 77.7);
-
-        SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET number=? WHERE name=?"), database);
-        statement.setBindingColumnNames(Utf8StringVector() << Utf8StringLiteral("number") << Utf8StringLiteral("name"));
-
-        statement.write(firstValueMap);
-
-        ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1);
-
-        statement.write(firstValueMap);
-
-        ASSERT_THAT(database.totalChangesCount(), startTotalCount + 2);
-
-        statement.write(secondValueMap);
-
-        ASSERT_THAT(database.totalChangesCount(), startTotalCount + 3);
-    }
+    SqliteWriteStatement statement("UPDATE test SET name=@name, number=@number WHERE rowid=@id", database);
 
-    {
-        SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='foo'"), database);
-
-        statement.next();
-
-        ASSERT_THAT(statement.value<double>(1), 66.6);
-    }
-}
-
-TEST_F(SqliteStatement, WriteUpdateWidthNamedParameter)
-{
-    {
-        int startTotalCount = database.totalChangesCount();
-        RowDictionary firstValueMap;
-        firstValueMap.insert(Utf8StringLiteral("name"), QStringLiteral("foo"));
-        firstValueMap.insert(Utf8StringLiteral("number"), 99.9);
-
-        SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET number=@number WHERE name=@name"), database);
-        statement.write(firstValueMap);
-        ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1);
-    }
-
-    {
-        SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='foo'"), database);
-        statement.next();
-        ASSERT_THAT(statement.value<double>(1), 99.9);
-    }
-}
-
-TEST_F(SqliteStatement, WriteUpdateWidthNamedParameterAndBindNotAllParameter)
-{
-    {
-        int startTotalCount = database.totalChangesCount();
-        RowDictionary firstValueMap;
-        firstValueMap.insert(Utf8StringLiteral("name"), QStringLiteral("foo"));
-
-        SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET number=@number WHERE name=@name"), database);
-        statement.writeUnchecked(firstValueMap);
-        ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1);
-    }
-
-    {
-        SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='foo'"), database);
-        statement.next();
-        ASSERT_THAT(statement.value<double>(1), 0.0);
-    }
-}
-
-TEST_F(SqliteStatement, WriteInsert)
-{
-    {
-        int startTotalCount = database.totalChangesCount();
-
-        RowDictionary valueMap;
-        valueMap.insert(Utf8StringLiteral("name"), QStringLiteral("jane"));
-        valueMap.insert(Utf8StringLiteral("number"), 232.3);
-
-        SqliteWriteStatement statement(Utf8StringLiteral("INSERT OR IGNORE INTO test(name, number) VALUES (?, ?)"), database);
-        statement.setBindingColumnNames(Utf8StringVector() << Utf8StringLiteral("name") << Utf8StringLiteral("number"));
-        statement.write(valueMap);
-        ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1);
-        statement.write(valueMap);
-        ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1);
-    }
-
-    {
-        SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='jane'"), database);
-        statement.next();
-        ASSERT_THAT(statement.value<double>(1), 232.3);
-    }
-}
-
-TEST_F(SqliteStatement, WriteFailure)
-{
-    {
-        RowDictionary valueMap;
-        valueMap.insert(Utf8StringLiteral("name"), QStringLiteral("foo"));
-        valueMap.insert(Utf8StringLiteral("number"), 323.3);
-
-        SqliteWriteStatement statement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)"), database);
-        statement.setBindingColumnNames(Utf8StringVector() << Utf8StringLiteral("name") << Utf8StringLiteral("number"));
-        ASSERT_THROW(statement.write(valueMap), SqliteException);
-    }
-
-    {
-        RowDictionary valueMap;
-        valueMap.insert(Utf8StringLiteral("name"), QStringLiteral("bar"));
-
-        SqliteWriteStatement statement(Utf8StringLiteral("INSERT OR IGNORE INTO test(name, number) VALUES (?, ?)"), database);
-        statement.setBindingColumnNames(Utf8StringVector() << Utf8StringLiteral("name") << Utf8StringLiteral("number"));
-        ASSERT_THROW(statement.write(valueMap), SqliteException);
-    }
+    ASSERT_THAT(statement.bindingColumnNames(), ElementsAre("name", "number", "id"));
 }
 
 TEST_F(SqliteStatement, ClosedDatabase)
 {
     database.close();
-    ASSERT_THROW(SqliteWriteStatement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)"), database), SqliteException);
-    ASSERT_THROW(SqliteReadStatement(Utf8StringLiteral("SELECT * FROM test"), database), SqliteException);
-    ASSERT_THROW(SqliteReadWriteStatement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)"), database), SqliteException);
+    ASSERT_THROW(SqliteWriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), SqliteException);
+    ASSERT_THROW(SqliteReadStatement("SELECT * FROM test", database), SqliteException);
+    ASSERT_THROW(SqliteReadWriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), SqliteException);
     database.open(QDir::tempPath() + QStringLiteral("/SqliteStatementTest.db"));
 }
 
 void SqliteStatement::SetUp()
 {
     database.setJournalMode(JournalMode::Memory);
-    database.open(QStringLiteral(":memory:"));
-    SqliteWriteStatement(Utf8StringLiteral("CREATE TABLE test(name TEXT UNIQUE, number NUMERIC)"), database).step();
-    SqliteWriteStatement(Utf8StringLiteral("INSERT INTO  test VALUES ('bar', x'0500')"), database).step();
-    SqliteWriteStatement(Utf8StringLiteral("INSERT INTO  test VALUES ('foo', 23.3)"), database).step();
-    SqliteWriteStatement(Utf8StringLiteral("INSERT INTO  test VALUES ('poo', 40)"), database).step();
+    database.open(":memory:");
+    SqliteWriteStatement("CREATE TABLE test(name TEXT UNIQUE, number NUMERIC)", database).step();
+    SqliteWriteStatement("INSERT INTO  test VALUES ('bar', 'blah')", database).step();
+    SqliteWriteStatement("INSERT INTO  test VALUES ('foo', 23.3)", database).step();
+    SqliteWriteStatement("INSERT INTO  test VALUES ('poo', 40)", database).step();
 }
 
 void SqliteStatement::TearDown()
diff --git a/tests/unit/unittest/sqlitetable-test.cpp b/tests/unit/unittest/sqlitetable-test.cpp
index 2000af9f406b8d787a923178c211316a6d97e4a5..07f1108657b19f0ece671f812682f7b2365304ae 100644
--- a/tests/unit/unittest/sqlitetable-test.cpp
+++ b/tests/unit/unittest/sqlitetable-test.cpp
@@ -29,10 +29,6 @@
 #include <sqlitecolumn.h>
 #include <sqlitedatabase.h>
 #include <sqlitetable.h>
-#include <utf8string.h>
-
-#include <QSignalSpy>
-#include <QVariant>
 
 namespace {
 
@@ -45,12 +41,12 @@ protected:
     void SetUp() override;
     void TearDown() override;
 
-    SqliteColumn *addColumn(const Utf8String &columnName);
+    SqliteColumn *addColumn(Utils::SmallString columnName);
 
     SpyDummy spyDummy;
     SqliteDatabase database;
     Sqlite::SqliteTable *table = new Sqlite::SqliteTable;
-    Utf8String tableName = Utf8StringLiteral("testTable");
+    Utils::SmallString tableName = "testTable";
 };
 
 
@@ -63,7 +59,7 @@ TEST_F(SqliteTable, ColumnIsAddedToTable)
 
 TEST_F(SqliteTable, SetTableName)
 {
-    table->setName(tableName);
+    table->setName(tableName.clone());
 
     ASSERT_THAT(table->name(), tableName);
 }
@@ -77,8 +73,8 @@ TEST_F(SqliteTable, SetUseWithoutRowid)
 
 TEST_F(SqliteTable, TableIsReadyAfterOpenDatabase)
 {
-    table->setName(tableName);
-    addColumn(Utf8StringLiteral("name"));
+    table->setName(tableName.clone());
+    addColumn("name");
 
     database.open();
 
@@ -99,11 +95,11 @@ void SqliteTable::TearDown()
     table = nullptr;
 }
 
-SqliteColumn *SqliteTable::addColumn(const Utf8String &columnName)
+SqliteColumn *SqliteTable::addColumn(Utils::SmallString columnName)
 {
     SqliteColumn *newSqliteColum = new SqliteColumn;
 
-    newSqliteColum->setName(columnName);
+    newSqliteColum->setName(std::move(columnName));
 
     table->addColumn(newSqliteColum);
 
diff --git a/tests/unit/unittest/sqlstatementbuilder-test.cpp b/tests/unit/unittest/sqlstatementbuilder-test.cpp
index e0466f852874a44972e327b3a3ea065510620947..028a141c72947b7ed0c7c6622071cd5bcdbf08b5 100644
--- a/tests/unit/unittest/sqlstatementbuilder-test.cpp
+++ b/tests/unit/unittest/sqlstatementbuilder-test.cpp
@@ -27,108 +27,107 @@
 
 #include <sqlstatementbuilderexception.h>
 #include <sqlstatementbuilder.h>
-#include <utf8stringvector.h>
-
-#include <QString>
 
 using namespace ::testing;
 
 using Sqlite::SqlStatementBuilder;
 using Sqlite::SqlStatementBuilderException;
 
+using SV = Utils::SmallStringVector;
+
 TEST(SqlStatementBuilder, Bind)
 {
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("SELECT $columns FROM $table WHERE $column = 'foo' AND rowid=$row AND rowid IN ($rows)"));
+    SqlStatementBuilder sqlStatementBuilder("SELECT $columns FROM $table WHERE $column = 'foo' AND rowid=$row AND rowid IN ($rows)");
 
-    sqlStatementBuilder.bind(Utf8StringLiteral("$columns"), Utf8StringVector() << Utf8StringLiteral("name") << Utf8StringLiteral("number"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$column"), Utf8StringLiteral("name"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$table"), Utf8StringLiteral("test"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$row"), 20);
-    sqlStatementBuilder.bind(Utf8StringLiteral("$rows"), QVector<int>() << 1 << 2 << 3);
+    sqlStatementBuilder.bind("$columns", SV{"name", "number"});
+    sqlStatementBuilder.bind("$column", "name");
+    sqlStatementBuilder.bind("$table", "test");
+    sqlStatementBuilder.bind("$row", 20);
+    sqlStatementBuilder.bind("$rows", {1, 2, 3});
 
-    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), Utf8StringLiteral("SELECT name, number FROM test WHERE name = 'foo' AND rowid=20 AND rowid IN (1, 2, 3)"));
+    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), "SELECT name, number FROM test WHERE name = 'foo' AND rowid=20 AND rowid IN (1, 2, 3)");
 }
 
 TEST(SqlStatementBuilder, BindEmpty)
 {
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("SELECT $columns FROM $table$emptyPart"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$columns"), Utf8StringVector() << Utf8StringLiteral("name") << Utf8StringLiteral("number"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$table"), Utf8StringLiteral("test"));
+    SqlStatementBuilder sqlStatementBuilder("SELECT $columns FROM $table$emptyPart");
+    sqlStatementBuilder.bind("$columns", SV{"name", "number"});
+    sqlStatementBuilder.bind("$table", "test");
 
-    sqlStatementBuilder.bindEmptyText(Utf8StringLiteral("$emptyPart"));
+    sqlStatementBuilder.bindEmptyText("$emptyPart");
 
-    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), Utf8StringLiteral("SELECT name, number FROM test"));
+    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), "SELECT name, number FROM test");
 }
 
 TEST(SqlStatementBuilder, BindFailure)
 {
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("SELECT $columns FROM $table"));
+    SqlStatementBuilder sqlStatementBuilder("SELECT $columns FROM $table");
 
-    Utf8StringVector columns;
+    Utils::SmallStringVector columns;
 
-    ASSERT_THROW(sqlStatementBuilder.bind(Utf8StringLiteral("$columns"), Utf8StringLiteral("")), SqlStatementBuilderException);
-    ASSERT_THROW(sqlStatementBuilder.bind(Utf8StringLiteral("columns"), Utf8StringLiteral("test")), SqlStatementBuilderException);
-    ASSERT_THROW(sqlStatementBuilder.bind(Utf8StringLiteral("$columns"), columns), SqlStatementBuilderException);
-    ASSERT_THROW(sqlStatementBuilder.bindWithInsertTemplateParameters(Utf8StringLiteral("$columns"), columns), SqlStatementBuilderException);
-    ASSERT_THROW(sqlStatementBuilder.bindWithUpdateTemplateParameters(Utf8StringLiteral("$columns"), columns), SqlStatementBuilderException);
+    ASSERT_THROW(sqlStatementBuilder.bind("$columns", ""), SqlStatementBuilderException);
+    ASSERT_THROW(sqlStatementBuilder.bind("columns", "test"), SqlStatementBuilderException);
+    ASSERT_THROW(sqlStatementBuilder.bind("$columns", columns), SqlStatementBuilderException);
+    ASSERT_THROW(sqlStatementBuilder.bindWithInsertTemplateParameters("$columns", columns), SqlStatementBuilderException);
+    ASSERT_THROW(sqlStatementBuilder.bindWithUpdateTemplateParameters("$columns", columns), SqlStatementBuilderException);
 }
 
 TEST(SqlStatementBuilder, BindWithInsertTemplateParameters)
 {
-    Utf8StringVector columns({Utf8StringLiteral("name"), Utf8StringLiteral("number")});
+    Utils::SmallStringVector columns = {"name", "number"};
 
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("INSERT OR IGNORE INTO $table ($columns) VALUES ($values)"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$table"), Utf8StringLiteral("test"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$columns"), columns);
-    sqlStatementBuilder.bindWithInsertTemplateParameters(Utf8StringLiteral("$values"), columns);
+    SqlStatementBuilder sqlStatementBuilder("INSERT OR IGNORE INTO $table ($columns) VALUES ($values)");
+    sqlStatementBuilder.bind("$table", "test");
+    sqlStatementBuilder.bind("$columns", columns);
+    sqlStatementBuilder.bindWithInsertTemplateParameters("$values", columns);
 
-    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), Utf8StringLiteral("INSERT OR IGNORE INTO test (name, number) VALUES (?, ?)"));
+    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), "INSERT OR IGNORE INTO test (name, number) VALUES (?, ?)");
 }
 
 TEST(SqlStatementBuilder, BindWithUpdateTemplateParameters)
 {
-    Utf8StringVector columns({Utf8StringLiteral("name"), Utf8StringLiteral("number")});
+    Utils::SmallStringVector columns = {"name", "number"};
 
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("UPDATE $table SET $columnValues WHERE id=?"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$table"), Utf8StringLiteral("test"));
-    sqlStatementBuilder.bindWithUpdateTemplateParameters(Utf8StringLiteral("$columnValues"), columns);
+    SqlStatementBuilder sqlStatementBuilder("UPDATE $table SET $columnValues WHERE id=?");
+    sqlStatementBuilder.bind("$table", "test");
+    sqlStatementBuilder.bindWithUpdateTemplateParameters("$columnValues", columns);
 
-    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), Utf8StringLiteral("UPDATE test SET name=?, number=? WHERE id=?"));
+    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), "UPDATE test SET name=?, number=? WHERE id=?");
 }
 
 TEST(SqlStatementBuilder, BindWithUpdateTemplateNames)
 {
-    Utf8StringVector columns({Utf8StringLiteral("name"), Utf8StringLiteral("number")});
+    Utils::SmallStringVector columns = {"name", "number"};
 
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("UPDATE $table SET $columnValues WHERE id=@id"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$table"), Utf8StringLiteral("test"));
-    sqlStatementBuilder.bindWithUpdateTemplateNames(Utf8StringLiteral("$columnValues"), columns);
+    SqlStatementBuilder sqlStatementBuilder("UPDATE $table SET $columnValues WHERE id=@id");
+    sqlStatementBuilder.bind("$table", "test");
+    sqlStatementBuilder.bindWithUpdateTemplateNames("$columnValues", columns);
 
-    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), Utf8StringLiteral("UPDATE test SET name=@name, number=@number WHERE id=@id"));
+    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), "UPDATE test SET name=@name, number=@number WHERE id=@id");
 }
 
 TEST(SqlStatementBuilder, ClearOnRebinding)
 {
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("SELECT $columns FROM $table"));
+    SqlStatementBuilder sqlStatementBuilder("SELECT $columns FROM $table");
 
-    sqlStatementBuilder.bind(Utf8StringLiteral("$columns"), Utf8StringLiteral("name, number"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$table"), Utf8StringLiteral("test"));
+    sqlStatementBuilder.bind("$columns", "name, number");
+    sqlStatementBuilder.bind("$table", "test");
 
-    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), Utf8StringLiteral("SELECT name, number FROM test"));
+    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), "SELECT name, number FROM test");
 
-    sqlStatementBuilder.bind(Utf8StringLiteral("$table"), Utf8StringLiteral("test2"));
+    sqlStatementBuilder.bind("$table", "test2");
 
-    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), Utf8StringLiteral("SELECT name, number FROM test2"));
+    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), "SELECT name, number FROM test2");
 }
 
 TEST(SqlStatementBuilder, ClearBinding)
 {
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("SELECT $columns FROM $table"));
+    SqlStatementBuilder sqlStatementBuilder("SELECT $columns FROM $table");
 
-    sqlStatementBuilder.bind(Utf8StringLiteral("$columns"), Utf8StringLiteral("name, number"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$table"), Utf8StringLiteral("test"));
+    sqlStatementBuilder.bind("$columns", "name, number");
+    sqlStatementBuilder.bind("$table", "test");
 
-    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), Utf8StringLiteral("SELECT name, number FROM test"));
+    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), "SELECT name, number FROM test");
 
     sqlStatementBuilder.clear();
 
@@ -137,32 +136,32 @@ TEST(SqlStatementBuilder, ClearBinding)
 
 TEST(SqlStatementBuilder, ColumnType)
 {
-    ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Numeric), Utf8StringLiteral("NUMERIC"));
-    ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Integer), Utf8StringLiteral("INTEGER"));
-    ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Real), Utf8StringLiteral("REAL"));
-    ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Text), Utf8StringLiteral("TEXT"));
+    ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Numeric), "NUMERIC");
+    ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Integer), "INTEGER");
+    ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Real), "REAL");
+    ASSERT_THAT(SqlStatementBuilder::columnTypeToString(ColumnType::Text), "TEXT");
     ASSERT_TRUE(SqlStatementBuilder::columnTypeToString(ColumnType::None).isEmpty());
 }
 
 TEST(SqlStatementBuilder, SqlStatementFailure)
 {
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("SELECT $columns FROM $table"));
+    SqlStatementBuilder sqlStatementBuilder("SELECT $columns FROM $table");
 
-    sqlStatementBuilder.bind(Utf8StringLiteral("$columns"), Utf8StringLiteral("name, number"));
+    sqlStatementBuilder.bind("$columns", "name, number");
 
     ASSERT_THROW(sqlStatementBuilder.sqlStatement(), SqlStatementBuilderException);
 }
 
 TEST(SqlStatementBuilder, IsBuild)
 {
-    SqlStatementBuilder sqlStatementBuilder(Utf8StringLiteral("SELECT $columns FROM $table"));
+    SqlStatementBuilder sqlStatementBuilder("SELECT $columns FROM $table");
 
-    sqlStatementBuilder.bind(Utf8StringLiteral("$columns"), Utf8StringLiteral("name, number"));
-    sqlStatementBuilder.bind(Utf8StringLiteral("$table"), Utf8StringLiteral("test"));
+    sqlStatementBuilder.bind("$columns", "name, number");
+    sqlStatementBuilder.bind("$table", "test");
 
     ASSERT_FALSE(sqlStatementBuilder.isBuild());
 
-    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), Utf8StringLiteral("SELECT name, number FROM test"));
+    ASSERT_THAT(sqlStatementBuilder.sqlStatement(), "SELECT name, number FROM test");
 
     ASSERT_TRUE(sqlStatementBuilder.isBuild());