Clang: Cleanup string interface of sqlite

We only will need the utf8 optimized SmallString for the indexer database.
So we remove all other string bindings, QByteArray and QVariant.

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

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

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

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;
 };
 

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;
 };

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;
 }

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;
 };

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"));
 }