feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Sqlite: Remove the Sqlite Prefix

Browse Source 
We use a name space now, so the prefix is not of much use.

Change-Id: I2b077576f94dab778add6ab2e54870f7ca18da78
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
This commit is contained in:
Marco Bubke
2017-09-18 10:21:45 +02:00
committed by Tim Jenssen
parent d2aaa26653
commit 382c9647e8
35 changed files with 413 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/libs/sqlite/createtablesqlstatementbuilder.cpp
View File

@@ -101,7 +101,7 @@ void CreateTableSqlStatementBuilder::bindColumnDefinitions() const
{ {
Utils::SmallStringVector columnDefinitionStrings; Utils::SmallStringVector columnDefinitionStrings;
for (const SqliteColumn &columns : m_columns) { for (const Column &columns : m_columns) {
Utils::SmallString columnDefinitionString = {columns.name(), " ", columns.typeString()}; Utils::SmallString columnDefinitionString = {columns.name(), " ", columns.typeString()};
switch (columns.constraint()) { switch (columns.constraint()) {

12
src/libs/sqlite/sqlitecolumn.h
View File

@@ -33,12 +33,12 @@
namespace Sqlite { namespace Sqlite {
class SqliteColumn class Column
{ {
public: public:
SqliteColumn() = default; Column() = default;
SqliteColumn(Utils::SmallString &&name, Column(Utils::SmallString &&name,
ColumnType type = ColumnType::Numeric, ColumnType type = ColumnType::Numeric,
Contraint constraint = Contraint::NoConstraint) Contraint constraint = Contraint::NoConstraint)
: m_name(std::move(name)), : m_name(std::move(name)),
@@ -96,7 +96,7 @@ public:
Q_UNREACHABLE(); Q_UNREACHABLE();
} }
friend bool operator==(const SqliteColumn &first, const SqliteColumn &second) friend bool operator==(const Column &first, const Column &second)
{ {
return first.m_name == second.m_name return first.m_name == second.m_name
&& first.m_type == second.m_type && first.m_type == second.m_type
@@ -109,8 +109,8 @@ private:
Contraint m_constraint = Contraint::NoConstraint; Contraint m_constraint = Contraint::NoConstraint;
}; };
using SqliteColumns = std::vector<SqliteColumn>; using SqliteColumns = std::vector<Column>;
using SqliteColumnConstReference = std::reference_wrapper<const SqliteColumn>; using SqliteColumnConstReference = std::reference_wrapper<const Column>;
using SqliteColumnConstReferences = std::vector<SqliteColumnConstReference>; using SqliteColumnConstReferences = std::vector<SqliteColumnConstReference>;
} // namespace Sqlite } // namespace Sqlite

42
src/libs/sqlite/sqlitedatabase.cpp
View File

@@ -30,18 +30,18 @@
namespace Sqlite { namespace Sqlite {
SqliteDatabase::SqliteDatabase() Database::Database()
: m_databaseBackend(*this) : m_databaseBackend(*this)
{ {
} }
SqliteDatabase::SqliteDatabase(Utils::PathString &&databaseFilePath) Database::Database(Utils::PathString &&databaseFilePath)
: m_databaseBackend(*this) : m_databaseBackend(*this)
{ {
open(std::move(databaseFilePath)); open(std::move(databaseFilePath));
} }
void SqliteDatabase::open() void Database::open()
{ {
m_databaseBackend.open(m_databaseFilePath, m_openMode); m_databaseBackend.open(m_databaseFilePath, m_openMode);
m_databaseBackend.setJournalMode(m_journalMode); m_databaseBackend.setJournalMode(m_journalMode);
@@ -49,91 +49,91 @@ void SqliteDatabase::open()
m_isOpen = true; m_isOpen = true;
} }
void SqliteDatabase::open(Utils::PathString &&databaseFilePath) void Database::open(Utils::PathString &&databaseFilePath)
{ {
setDatabaseFilePath(std::move(databaseFilePath)); setDatabaseFilePath(std::move(databaseFilePath));
open(); open();
} }
void SqliteDatabase::close() void Database::close()
{ {
m_isOpen = false; m_isOpen = false;
m_databaseBackend.close(); m_databaseBackend.close();
} }
bool SqliteDatabase::isOpen() const bool Database::isOpen() const
{ {
return m_isOpen; return m_isOpen;
} }
SqliteTable &SqliteDatabase::addTable() Table &Database::addTable()
{ {
m_sqliteTables.emplace_back(); m_sqliteTables.emplace_back();
return m_sqliteTables.back(); return m_sqliteTables.back();
} }
const std::vector<SqliteTable> &SqliteDatabase::tables() const const std::vector<Table> &Database::tables() const
{ {
return m_sqliteTables; return m_sqliteTables;
} }
void SqliteDatabase::setDatabaseFilePath(Utils::PathString &&databaseFilePath) void Database::setDatabaseFilePath(Utils::PathString &&databaseFilePath)
{ {
m_databaseFilePath = std::move(databaseFilePath); m_databaseFilePath = std::move(databaseFilePath);
} }
const Utils::PathString &SqliteDatabase::databaseFilePath() const const Utils::PathString &Database::databaseFilePath() const
{ {
return m_databaseFilePath; return m_databaseFilePath;
} }
void SqliteDatabase::setJournalMode(JournalMode journalMode) void Database::setJournalMode(JournalMode journalMode)
{ {
m_journalMode = journalMode; m_journalMode = journalMode;
} }
JournalMode SqliteDatabase::journalMode() const JournalMode Database::journalMode() const
{ {
return m_journalMode; return m_journalMode;
} }
void SqliteDatabase::setOpenMode(OpenMode openMode) void Database::setOpenMode(OpenMode openMode)
{ {
m_openMode = openMode; m_openMode = openMode;
} }
OpenMode SqliteDatabase::openMode() const OpenMode Database::openMode() const
{ {
return m_openMode; return m_openMode;
} }
int SqliteDatabase::changesCount() int Database::changesCount()
{ {
return m_databaseBackend.changesCount(); return m_databaseBackend.changesCount();
} }
int SqliteDatabase::totalChangesCount() int Database::totalChangesCount()
{ {
return m_databaseBackend.totalChangesCount(); return m_databaseBackend.totalChangesCount();
} }
void SqliteDatabase::execute(Utils::SmallStringView sqlStatement) void Database::execute(Utils::SmallStringView sqlStatement)
{ {
m_databaseBackend.execute(sqlStatement); m_databaseBackend.execute(sqlStatement);
} }
void SqliteDatabase::initializeTables() void Database::initializeTables()
{ {
SqliteImmediateTransaction<SqliteDatabase> transaction(*this); ImmediateTransaction<Database> transaction(*this);
for (SqliteTable &table : m_sqliteTables) for (Table &table : m_sqliteTables)
table.initialize(*this); table.initialize(*this);
transaction.commit(); transaction.commit();
} }
SqliteDatabaseBackend &SqliteDatabase::backend() DatabaseBackend &Database::backend()
{ {
return m_databaseBackend; return m_databaseBackend;
} }

24
src/libs/sqlite/sqlitedatabase.h
View File

@@ -35,7 +35,7 @@
namespace Sqlite { namespace Sqlite {
class SQLITE_EXPORT SqliteDatabase class SQLITE_EXPORT Database
{ {
template <typename Database> template <typename Database>
friend class SqliteAbstractTransaction; friend class SqliteAbstractTransaction;
@@ -43,14 +43,14 @@ class SQLITE_EXPORT SqliteDatabase
friend class SqliteBackend; friend class SqliteBackend;
public: public:
SqliteDatabase(); Database();
SqliteDatabase(Utils::PathString &&databaseFilePath); Database(Utils::PathString &&databaseFilePath);
SqliteDatabase(const SqliteDatabase &) = delete; Database(const Database &) = delete;
bool operator=(const SqliteDatabase &) = delete; bool operator=(const Database &) = delete;
SqliteDatabase(SqliteDatabase &&) = delete; Database(Database &&) = delete;
bool operator=(SqliteDatabase &&) = delete; bool operator=(Database &&) = delete;
void open(); void open();
void open(Utils::PathString &&databaseFilePath); void open(Utils::PathString &&databaseFilePath);
@@ -58,8 +58,8 @@ public:
bool isOpen() const; bool isOpen() const;
SqliteTable &addTable(); Table &addTable();
const std::vector<SqliteTable> &tables() const; const std::vector<Table> &tables() const;
void setDatabaseFilePath(Utils::PathString &&databaseFilePath); void setDatabaseFilePath(Utils::PathString &&databaseFilePath);
const Utils::PathString &databaseFilePath() const; const Utils::PathString &databaseFilePath() const;
@@ -75,15 +75,15 @@ public:
void execute(Utils::SmallStringView sqlStatement); void execute(Utils::SmallStringView sqlStatement);
SqliteDatabaseBackend &backend(); DatabaseBackend &backend();
private: private:
void initializeTables(); void initializeTables();
private: private:
SqliteDatabaseBackend m_databaseBackend; DatabaseBackend m_databaseBackend;
std::vector<SqliteTable> m_sqliteTables; std::vector<Table> m_sqliteTables;
Utils::PathString m_databaseFilePath; Utils::PathString m_databaseFilePath;
JournalMode m_journalMode = JournalMode::Wal; JournalMode m_journalMode = JournalMode::Wal;
OpenMode m_openMode = OpenMode::ReadWrite; OpenMode m_openMode = OpenMode::ReadWrite;

112
src/libs/sqlite/sqlitedatabasebackend.cpp
View File

@@ -40,25 +40,25 @@
namespace Sqlite { namespace Sqlite {
SqliteDatabaseBackend::SqliteDatabaseBackend(SqliteDatabase &database) DatabaseBackend::DatabaseBackend(Database &database)
: m_database(database), : m_database(database),
m_databaseHandle(nullptr), m_databaseHandle(nullptr),
m_cachedTextEncoding(Utf8) m_cachedTextEncoding(Utf8)
{ {
} }
SqliteDatabaseBackend::~SqliteDatabaseBackend() DatabaseBackend::~DatabaseBackend()
{ {
closeWithoutException(); closeWithoutException();
} }
void SqliteDatabaseBackend::setMmapSize(qint64 defaultSize, qint64 maximumSize) void DatabaseBackend::setMmapSize(qint64 defaultSize, qint64 maximumSize)
{ {
int resultCode = sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, defaultSize, maximumSize); int resultCode = sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, defaultSize, maximumSize);
checkMmapSizeIsSet(resultCode); checkMmapSizeIsSet(resultCode);
} }
void SqliteDatabaseBackend::activateMultiThreading() void DatabaseBackend::activateMultiThreading()
{ {
int resultCode = sqlite3_config(SQLITE_CONFIG_MULTITHREAD); int resultCode = sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
checkIfMultithreadingIsActivated(resultCode); checkIfMultithreadingIsActivated(resultCode);
@@ -69,31 +69,31 @@ static void sqliteLog(void*,int errorCode,const char *errorMessage)
qWarning() << sqlite3_errstr(errorCode) << errorMessage; qWarning() << sqlite3_errstr(errorCode) << errorMessage;
} }
void SqliteDatabaseBackend::activateLogging() void DatabaseBackend::activateLogging()
{ {
int resultCode = sqlite3_config(SQLITE_CONFIG_LOG, sqliteLog, nullptr); int resultCode = sqlite3_config(SQLITE_CONFIG_LOG, sqliteLog, nullptr);
checkIfLoogingIsActivated(resultCode); checkIfLoogingIsActivated(resultCode);
} }
void SqliteDatabaseBackend::initializeSqliteLibrary() void DatabaseBackend::initializeSqliteLibrary()
{ {
int resultCode = sqlite3_initialize(); int resultCode = sqlite3_initialize();
checkInitializeSqliteLibraryWasSuccesful(resultCode); checkInitializeSqliteLibraryWasSuccesful(resultCode);
} }
void SqliteDatabaseBackend::shutdownSqliteLibrary() void DatabaseBackend::shutdownSqliteLibrary()
{ {
int resultCode = sqlite3_shutdown(); int resultCode = sqlite3_shutdown();
checkShutdownSqliteLibraryWasSuccesful(resultCode); checkShutdownSqliteLibraryWasSuccesful(resultCode);
} }
void SqliteDatabaseBackend::checkpointFullWalLog() void DatabaseBackend::checkpointFullWalLog()
{ {
int resultCode = sqlite3_wal_checkpoint_v2(sqliteDatabaseHandle(), nullptr, SQLITE_CHECKPOINT_FULL, nullptr, nullptr); int resultCode = sqlite3_wal_checkpoint_v2(sqliteDatabaseHandle(), nullptr, SQLITE_CHECKPOINT_FULL, nullptr, nullptr);
checkIfLogCouldBeCheckpointed(resultCode); checkIfLogCouldBeCheckpointed(resultCode);
} }
void SqliteDatabaseBackend::open(Utils::SmallStringView databaseFilePath, OpenMode mode) void DatabaseBackend::open(Utils::SmallStringView databaseFilePath, OpenMode mode)
{ {
checkCanOpenDatabase(databaseFilePath); checkCanOpenDatabase(databaseFilePath);
@@ -109,13 +109,13 @@ void SqliteDatabaseBackend::open(Utils::SmallStringView databaseFilePath, OpenMo
cacheTextEncoding(); cacheTextEncoding();
} }
sqlite3 *SqliteDatabaseBackend::sqliteDatabaseHandle() sqlite3 *DatabaseBackend::sqliteDatabaseHandle()
{ {
checkDatabaseHandleIsNotNull(); checkDatabaseHandleIsNotNull();
return m_databaseHandle; return m_databaseHandle;
} }
void SqliteDatabaseBackend::setPragmaValue(Utils::SmallStringView pragmaKey, Utils::SmallStringView newPragmaValue) void DatabaseBackend::setPragmaValue(Utils::SmallStringView pragmaKey, Utils::SmallStringView newPragmaValue)
{ {
execute(Utils::SmallString{"PRAGMA ", pragmaKey, "='", newPragmaValue, "'"}); execute(Utils::SmallString{"PRAGMA ", pragmaKey, "='", newPragmaValue, "'"});
Utils::SmallString pragmeValueInDatabase = toValue<Utils::SmallString>("PRAGMA " + pragmaKey); Utils::SmallString pragmeValueInDatabase = toValue<Utils::SmallString>("PRAGMA " + pragmaKey);
@@ -123,56 +123,56 @@ void SqliteDatabaseBackend::setPragmaValue(Utils::SmallStringView pragmaKey, Uti
checkPragmaValue(pragmeValueInDatabase, newPragmaValue); checkPragmaValue(pragmeValueInDatabase, newPragmaValue);
} }
Utils::SmallString SqliteDatabaseBackend::pragmaValue(Utils::SmallStringView pragma) Utils::SmallString DatabaseBackend::pragmaValue(Utils::SmallStringView pragma)
{ {
return toValue<Utils::SmallString>("PRAGMA " + pragma); return toValue<Utils::SmallString>("PRAGMA " + pragma);
} }
void SqliteDatabaseBackend::setJournalMode(JournalMode journalMode) void DatabaseBackend::setJournalMode(JournalMode journalMode)
{ {
setPragmaValue("journal_mode", journalModeToPragma(journalMode)); setPragmaValue("journal_mode", journalModeToPragma(journalMode));
} }
JournalMode SqliteDatabaseBackend::journalMode() JournalMode DatabaseBackend::journalMode()
{ {
return pragmaToJournalMode(pragmaValue("journal_mode")); return pragmaToJournalMode(pragmaValue("journal_mode"));
} }
void SqliteDatabaseBackend::setTextEncoding(TextEncoding textEncoding) void DatabaseBackend::setTextEncoding(TextEncoding textEncoding)
{ {
setPragmaValue("encoding", textEncodingToPragma(textEncoding)); setPragmaValue("encoding", textEncodingToPragma(textEncoding));
cacheTextEncoding(); cacheTextEncoding();
} }
TextEncoding SqliteDatabaseBackend::textEncoding() TextEncoding DatabaseBackend::textEncoding()
{ {
return m_cachedTextEncoding; return m_cachedTextEncoding;
} }
Utils::SmallStringVector SqliteDatabaseBackend::columnNames(Utils::SmallStringView tableName) Utils::SmallStringVector DatabaseBackend::columnNames(Utils::SmallStringView tableName)
{ {
SqliteReadWriteStatement statement("SELECT * FROM " + tableName, m_database); ReadWriteStatement statement("SELECT * FROM " + tableName, m_database);
return statement.columnNames(); return statement.columnNames();
} }
int SqliteDatabaseBackend::changesCount() int DatabaseBackend::changesCount()
{ {
return sqlite3_changes(sqliteDatabaseHandle()); return sqlite3_changes(sqliteDatabaseHandle());
} }
int SqliteDatabaseBackend::totalChangesCount() int DatabaseBackend::totalChangesCount()
{ {
return sqlite3_total_changes(sqliteDatabaseHandle()); return sqlite3_total_changes(sqliteDatabaseHandle());
} }
void SqliteDatabaseBackend::execute(Utils::SmallStringView sqlStatement) void DatabaseBackend::execute(Utils::SmallStringView sqlStatement)
{ {
SqliteReadWriteStatement statement(sqlStatement, m_database); ReadWriteStatement statement(sqlStatement, m_database);
statement.step(); statement.step();
} }
void SqliteDatabaseBackend::close() void DatabaseBackend::close()
{ {
checkForOpenDatabaseWhichCanBeClosed(); checkForOpenDatabaseWhichCanBeClosed();
@@ -184,12 +184,12 @@ void SqliteDatabaseBackend::close()
} }
bool SqliteDatabaseBackend::databaseIsOpen() const bool DatabaseBackend::databaseIsOpen() const
{ {
return m_databaseHandle != nullptr; return m_databaseHandle != nullptr;
} }
void SqliteDatabaseBackend::closeWithoutException() void DatabaseBackend::closeWithoutException()
{ {
if (m_databaseHandle) { if (m_databaseHandle) {
int resultCode = sqlite3_close_v2(m_databaseHandle); int resultCode = sqlite3_close_v2(m_databaseHandle);
@@ -199,19 +199,19 @@ void SqliteDatabaseBackend::closeWithoutException()
} }
} }
void SqliteDatabaseBackend::registerBusyHandler() void DatabaseBackend::registerBusyHandler()
{ {
sqlite3_busy_handler(sqliteDatabaseHandle(), &busyHandlerCallback, nullptr); sqlite3_busy_handler(sqliteDatabaseHandle(), &busyHandlerCallback, nullptr);
} }
void SqliteDatabaseBackend::registerRankingFunction() void DatabaseBackend::registerRankingFunction()
{ {
sqlite3_create_function_v2(sqliteDatabaseHandle(), "okapi_bm25", -1, SQLITE_ANY, 0, okapi_bm25, 0, 0, 0); sqlite3_create_function_v2(sqliteDatabaseHandle(), "okapi_bm25", -1, SQLITE_ANY, 0, okapi_bm25, 0, 0, 0);
sqlite3_create_function_v2(sqliteDatabaseHandle(), "okapi_bm25f", -1, SQLITE_UTF8, 0, okapi_bm25f, 0, 0, 0); sqlite3_create_function_v2(sqliteDatabaseHandle(), "okapi_bm25f", -1, SQLITE_UTF8, 0, okapi_bm25f, 0, 0, 0);
sqlite3_create_function_v2(sqliteDatabaseHandle(), "okapi_bm25f_kb", -1, SQLITE_UTF8, 0, okapi_bm25f_kb, 0, 0, 0); sqlite3_create_function_v2(sqliteDatabaseHandle(), "okapi_bm25f_kb", -1, SQLITE_UTF8, 0, okapi_bm25f_kb, 0, 0, 0);
} }
int SqliteDatabaseBackend::busyHandlerCallback(void *, int counter) int DatabaseBackend::busyHandlerCallback(void *, int counter)
{ {
Q_UNUSED(counter); Q_UNUSED(counter);
#ifdef QT_DEBUG #ifdef QT_DEBUG
@@ -222,18 +222,18 @@ int SqliteDatabaseBackend::busyHandlerCallback(void *, int counter)
return true; return true;
} }
void SqliteDatabaseBackend::cacheTextEncoding() void DatabaseBackend::cacheTextEncoding()
{ {
m_cachedTextEncoding = pragmaToTextEncoding(pragmaValue("encoding")); m_cachedTextEncoding = pragmaToTextEncoding(pragmaValue("encoding"));
} }
void SqliteDatabaseBackend::checkForOpenDatabaseWhichCanBeClosed() void DatabaseBackend::checkForOpenDatabaseWhichCanBeClosed()
{ {
if (m_databaseHandle == nullptr) if (m_databaseHandle == nullptr)
throwException("SqliteDatabaseBackend::close: database is not open so it can not be closed."); throwException("SqliteDatabaseBackend::close: database is not open so it can not be closed.");
} }
void SqliteDatabaseBackend::checkDatabaseClosing(int resultCode) void DatabaseBackend::checkDatabaseClosing(int resultCode)
{ {
switch (resultCode) { switch (resultCode) {
case SQLITE_OK: return; case SQLITE_OK: return;
@@ -241,70 +241,70 @@ void SqliteDatabaseBackend::checkDatabaseClosing(int resultCode)
} }
} }
void SqliteDatabaseBackend::checkCanOpenDatabase(Utils::SmallStringView databaseFilePath) void DatabaseBackend::checkCanOpenDatabase(Utils::SmallStringView databaseFilePath)
{ {
if (databaseFilePath.isEmpty()) if (databaseFilePath.isEmpty())
throw SqliteException("SqliteDatabaseBackend::SqliteDatabaseBackend: database cannot be opened:", "database file path is empty!"); throw Exception("SqliteDatabaseBackend::SqliteDatabaseBackend: database cannot be opened:", "database file path is empty!");
if (databaseIsOpen()) if (databaseIsOpen())
throw SqliteException("SqliteDatabaseBackend::SqliteDatabaseBackend: database cannot be opened:", "database is already open!"); throw Exception("SqliteDatabaseBackend::SqliteDatabaseBackend: database cannot be opened:", "database is already open!");
} }
void SqliteDatabaseBackend::checkDatabaseCouldBeOpened(int resultCode) void DatabaseBackend::checkDatabaseCouldBeOpened(int resultCode)
{ {
switch (resultCode) { switch (resultCode) {
case SQLITE_OK: case SQLITE_OK:
return; return;
default: default:
closeWithoutException(); closeWithoutException();
throw SqliteException("SqliteDatabaseBackend::SqliteDatabaseBackend: database cannot be opened:", sqlite3_errmsg(sqliteDatabaseHandle())); throw Exception("SqliteDatabaseBackend::SqliteDatabaseBackend: database cannot be opened:", sqlite3_errmsg(sqliteDatabaseHandle()));
} }
} }
void SqliteDatabaseBackend::checkPragmaValue(Utils::SmallStringView databaseValue, void DatabaseBackend::checkPragmaValue(Utils::SmallStringView databaseValue,
Utils::SmallStringView expectedValue) Utils::SmallStringView expectedValue)
{ {
if (databaseValue != expectedValue) if (databaseValue != expectedValue)
throwException("SqliteDatabaseBackend::setPragmaValue: pragma value is not set!"); throwException("SqliteDatabaseBackend::setPragmaValue: pragma value is not set!");
} }
void SqliteDatabaseBackend::checkDatabaseHandleIsNotNull() void DatabaseBackend::checkDatabaseHandleIsNotNull()
{ {
if (m_databaseHandle == nullptr) if (m_databaseHandle == nullptr)
throwException("SqliteDatabaseBackend: database is not open!"); throwException("SqliteDatabaseBackend: database is not open!");
} }
void SqliteDatabaseBackend::checkIfMultithreadingIsActivated(int resultCode) void DatabaseBackend::checkIfMultithreadingIsActivated(int resultCode)
{ {
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::activateMultiThreading: multithreading can't be activated!"); throwException("SqliteDatabaseBackend::activateMultiThreading: multithreading can't be activated!");
} }
void SqliteDatabaseBackend::checkIfLoogingIsActivated(int resultCode) void DatabaseBackend::checkIfLoogingIsActivated(int resultCode)
{ {
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::activateLogging: logging can't be activated!"); throwException("SqliteDatabaseBackend::activateLogging: logging can't be activated!");
} }
void SqliteDatabaseBackend::checkMmapSizeIsSet(int resultCode) void DatabaseBackend::checkMmapSizeIsSet(int resultCode)
{ {
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::checkMmapSizeIsSet: mmap size can't be changed!"); throwException("SqliteDatabaseBackend::checkMmapSizeIsSet: mmap size can't be changed!");
} }
void SqliteDatabaseBackend::checkInitializeSqliteLibraryWasSuccesful(int resultCode) void DatabaseBackend::checkInitializeSqliteLibraryWasSuccesful(int resultCode)
{ {
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::initializeSqliteLibrary: SqliteLibrary cannot initialized!"); throwException("SqliteDatabaseBackend::initializeSqliteLibrary: SqliteLibrary cannot initialized!");
} }
void SqliteDatabaseBackend::checkShutdownSqliteLibraryWasSuccesful(int resultCode) void DatabaseBackend::checkShutdownSqliteLibraryWasSuccesful(int resultCode)
{ {
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::shutdownSqliteLibrary: SqliteLibrary cannot be shutdowned!"); throwException("SqliteDatabaseBackend::shutdownSqliteLibrary: SqliteLibrary cannot be shutdowned!");
} }
void SqliteDatabaseBackend::checkIfLogCouldBeCheckpointed(int resultCode) void DatabaseBackend::checkIfLogCouldBeCheckpointed(int resultCode)
{ {
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::checkpointFullWalLog: WAL log could not be checkpointed!"); throwException("SqliteDatabaseBackend::checkpointFullWalLog: WAL log could not be checkpointed!");
@@ -331,12 +331,12 @@ constexpr const Utils::SmallStringView journalModeStrings[] = {
"wal" "wal"
}; };
Utils::SmallStringView SqliteDatabaseBackend::journalModeToPragma(JournalMode journalMode) Utils::SmallStringView DatabaseBackend::journalModeToPragma(JournalMode journalMode)
{ {
return journalModeStrings[int(journalMode)]; return journalModeStrings[int(journalMode)];
} }
JournalMode SqliteDatabaseBackend::pragmaToJournalMode(Utils::SmallStringView pragma) JournalMode DatabaseBackend::pragmaToJournalMode(Utils::SmallStringView pragma)
{ {
int index = indexOfPragma(pragma, journalModeStrings); int index = indexOfPragma(pragma, journalModeStrings);
@@ -352,12 +352,12 @@ constexpr const Utils::SmallStringView textEncodingStrings[] = {
"UTF-16be" "UTF-16be"
}; };
Utils::SmallStringView SqliteDatabaseBackend::textEncodingToPragma(TextEncoding textEncoding) Utils::SmallStringView DatabaseBackend::textEncodingToPragma(TextEncoding textEncoding)
{ {
return textEncodingStrings[textEncoding]; return textEncodingStrings[textEncoding];
} }
TextEncoding SqliteDatabaseBackend::pragmaToTextEncoding(Utils::SmallStringView pragma) TextEncoding DatabaseBackend::pragmaToTextEncoding(Utils::SmallStringView pragma)
{ {
int index = indexOfPragma(pragma, textEncodingStrings); int index = indexOfPragma(pragma, textEncodingStrings);
@@ -367,7 +367,7 @@ TextEncoding SqliteDatabaseBackend::pragmaToTextEncoding(Utils::SmallStringView
return static_cast<TextEncoding>(index); return static_cast<TextEncoding>(index);
} }
int SqliteDatabaseBackend::openMode(OpenMode mode) int DatabaseBackend::openMode(OpenMode mode)
{ {
int sqliteMode = SQLITE_OPEN_CREATE; int sqliteMode = SQLITE_OPEN_CREATE;
@@ -379,23 +379,23 @@ int SqliteDatabaseBackend::openMode(OpenMode mode)
return sqliteMode; return sqliteMode;
} }
void SqliteDatabaseBackend::throwExceptionStatic(const char *whatHasHappens) void DatabaseBackend::throwExceptionStatic(const char *whatHasHappens)
{ {
throw SqliteException(whatHasHappens); throw Exception(whatHasHappens);
} }
void SqliteDatabaseBackend::throwException(const char *whatHasHappens) const void DatabaseBackend::throwException(const char *whatHasHappens) const
{ {
if (m_databaseHandle) if (m_databaseHandle)
throw SqliteException(whatHasHappens, sqlite3_errmsg(m_databaseHandle)); throw Exception(whatHasHappens, sqlite3_errmsg(m_databaseHandle));
else else
throw SqliteException(whatHasHappens); throw Exception(whatHasHappens);
} }
template <typename Type> template <typename Type>
Type SqliteDatabaseBackend::toValue(Utils::SmallStringView sqlStatement) Type DatabaseBackend::toValue(Utils::SmallStringView sqlStatement)
{ {
SqliteReadWriteStatement statement(sqlStatement, m_database); ReadWriteStatement statement(sqlStatement, m_database);
statement.next(); statement.next();

18
src/libs/sqlite/sqlitedatabasebackend.h
View File

@@ -33,19 +33,19 @@ struct sqlite3;
namespace Sqlite { namespace Sqlite {
class SqliteDatabase; class Database;
class SQLITE_EXPORT SqliteDatabaseBackend class SQLITE_EXPORT DatabaseBackend
{ {
public: public:
SqliteDatabaseBackend(SqliteDatabase &database); DatabaseBackend(Database &database);
~SqliteDatabaseBackend(); ~DatabaseBackend();
SqliteDatabaseBackend(const SqliteDatabase &) = delete; DatabaseBackend(const Database &) = delete;
SqliteDatabase &operator=(const SqliteDatabase &) = delete; Database &operator=(const Database &) = delete;
SqliteDatabaseBackend(SqliteDatabase &&) = delete; DatabaseBackend(Database &&) = delete;
SqliteDatabase &operator=(SqliteDatabase &&) = delete; Database &operator=(Database &&) = delete;
void setMmapSize(qint64 defaultSize, qint64 maximumSize); void setMmapSize(qint64 defaultSize, qint64 maximumSize);
void activateMultiThreading(); void activateMultiThreading();
@@ -114,7 +114,7 @@ protected:
private: private:
SqliteDatabase &m_database; Database &m_database;
sqlite3 *m_databaseHandle; sqlite3 *m_databaseHandle;
TextEncoding m_cachedTextEncoding; TextEncoding m_cachedTextEncoding;

2
src/libs/sqlite/sqliteexception.cpp
View File

@@ -31,7 +31,7 @@
namespace Sqlite { namespace Sqlite {
void SqliteException::printWarning() const void Exception::printWarning() const
{ {
if (!m_sqliteErrorMessage.isEmpty()) if (!m_sqliteErrorMessage.isEmpty())
qWarning() << m_whatErrorHasHappen << m_sqliteErrorMessage; qWarning() << m_whatErrorHasHappen << m_sqliteErrorMessage;

4
src/libs/sqlite/sqliteexception.h
View File

@@ -31,10 +31,10 @@
namespace Sqlite { namespace Sqlite {
class SQLITE_EXPORT SqliteException class SQLITE_EXPORT Exception
{ {
public: public:
SqliteException(const char *whatErrorHasHappen, Exception(const char *whatErrorHasHappen,
Utils::SmallString &&sqliteErrorMessage = Utils::SmallString()) Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
: m_whatErrorHasHappen(whatErrorHasHappen), : m_whatErrorHasHappen(whatErrorHasHappen),
m_sqliteErrorMessage(std::move(sqliteErrorMessage)) m_sqliteErrorMessage(std::move(sqliteErrorMessage))

10
src/libs/sqlite/sqliteindex.h
View File

@@ -34,10 +34,10 @@
namespace Sqlite { namespace Sqlite {
class SqliteIndex class Index
{ {
public: public:
SqliteIndex(Utils::SmallString &&tableName, Utils::SmallStringVector &&columnNames) Index(Utils::SmallString &&tableName, Utils::SmallStringVector &&columnNames)
: m_tableName(std::move(tableName)), : m_tableName(std::move(tableName)),
m_columnNames(std::move(columnNames)) m_columnNames(std::move(columnNames))
{ {
@@ -63,13 +63,13 @@ public:
void checkTableName() const void checkTableName() const
{ {
if (m_tableName.isEmpty()) if (m_tableName.isEmpty())
throw SqliteException("SqliteIndex has not table name!"); throw Exception("SqliteIndex has not table name!");
} }
void checkColumns() const void checkColumns() const
{ {
if (m_columnNames.empty()) if (m_columnNames.empty())
throw SqliteException("SqliteIndex has no columns!"); throw Exception("SqliteIndex has no columns!");
} }
private: private:
@@ -77,6 +77,6 @@ private:
Utils::SmallStringVector m_columnNames; Utils::SmallStringVector m_columnNames;
}; };
using SqliteIndices = std::vector<SqliteIndex>; using SqliteIndices = std::vector<Index>;
} // } //

8
src/libs/sqlite/sqlitereadstatement.cpp
View File

@@ -29,14 +29,14 @@
namespace Sqlite { namespace Sqlite {
SqliteReadStatement::SqliteReadStatement(Utils::SmallStringView sqlStatement, ReadStatement::ReadStatement(Utils::SmallStringView sqlStatement,
SqliteDatabase &database) Database &database)
: SqliteStatement(sqlStatement, database) : Statement(sqlStatement, database)
{ {
checkIsReadOnlyStatement(); checkIsReadOnlyStatement();
} }
void SqliteReadStatement::checkIsReadOnlyStatement() void ReadStatement::checkIsReadOnlyStatement()
{ {
if (!isReadOnlyStatement()) if (!isReadOnlyStatement())
throwException("SqliteStatement::SqliteReadStatement: is not read only statement!"); throwException("SqliteStatement::SqliteReadStatement: is not read only statement!");

38
src/libs/sqlite/sqlitereadstatement.h
View File

@@ -29,28 +29,28 @@
namespace Sqlite { namespace Sqlite {
class SQLITE_EXPORT SqliteReadStatement final : private SqliteStatement class SQLITE_EXPORT ReadStatement final : private Statement
{ {
public: public:
explicit SqliteReadStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database); explicit ReadStatement(Utils::SmallStringView sqlStatement, Database &database);
using SqliteStatement::next; using Statement::next;
using SqliteStatement::reset; using Statement::reset;
using SqliteStatement::value; using Statement::value;
using SqliteStatement::structValues; using Statement::structValues;
using SqliteStatement::tupleValues; using Statement::tupleValues;
using SqliteStatement::text; using Statement::text;
using SqliteStatement::values; using Statement::values;
using SqliteStatement::columnCount; using Statement::columnCount;
using SqliteStatement::columnNames; using Statement::columnNames;
using SqliteStatement::bind; using Statement::bind;
using SqliteStatement::bindValues; using Statement::bindValues;
using SqliteStatement::bindNameValues; using Statement::bindNameValues;
using SqliteStatement::bindingIndexForName; using Statement::bindingIndexForName;
using SqliteStatement::setBindingColumnNames; using Statement::setBindingColumnNames;
using SqliteStatement::bindingColumnNames; using Statement::bindingColumnNames;
using SqliteStatement::toValue; using Statement::toValue;
using SqliteStatement::database; using Statement::database;
protected: protected:
void checkIsReadOnlyStatement(); void checkIsReadOnlyStatement();

6
src/libs/sqlite/sqlitereadwritestatement.cpp
View File

@@ -27,9 +27,9 @@
namespace Sqlite { namespace Sqlite {
SqliteReadWriteStatement::SqliteReadWriteStatement(Utils::SmallStringView sqlStatement, ReadWriteStatement::ReadWriteStatement(Utils::SmallStringView sqlStatement,
SqliteDatabase &database) Database &database)
: SqliteStatement(sqlStatement, database) : Statement(sqlStatement, database)
{ {
} }

46
src/libs/sqlite/sqlitereadwritestatement.h
View File

@@ -29,33 +29,33 @@
namespace Sqlite { namespace Sqlite {
class SQLITE_EXPORT SqliteReadWriteStatement final : private SqliteStatement class SQLITE_EXPORT ReadWriteStatement final : private Statement
{ {
friend class SqliteDatabaseBackend; friend class DatabaseBackend;
public: public:
SqliteReadWriteStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database); ReadWriteStatement(Utils::SmallStringView sqlStatement, Database &database);
using SqliteStatement::next; using Statement::next;
using SqliteStatement::execute; using Statement::execute;
using SqliteStatement::reset; using Statement::reset;
using SqliteStatement::bind; using Statement::bind;
using SqliteStatement::bindValues; using Statement::bindValues;
using SqliteStatement::bindNameValues; using Statement::bindNameValues;
using SqliteStatement::bindingIndexForName; using Statement::bindingIndexForName;
using SqliteStatement::setBindingColumnNames; using Statement::setBindingColumnNames;
using SqliteStatement::bindingColumnNames; using Statement::bindingColumnNames;
using SqliteStatement::value; using Statement::value;
using SqliteStatement::text; using Statement::text;
using SqliteStatement::values; using Statement::values;
using SqliteStatement::structValues; using Statement::structValues;
using SqliteStatement::tupleValues; using Statement::tupleValues;
using SqliteStatement::columnCount; using Statement::columnCount;
using SqliteStatement::columnNames; using Statement::columnNames;
using SqliteStatement::toValue; using Statement::toValue;
using SqliteStatement::database; using Statement::database;
using SqliteStatement::write; using Statement::write;
using SqliteStatement::writeNamed; using Statement::writeNamed;
}; };
} // namespace Sqlite } // namespace Sqlite

114
src/libs/sqlite/sqlitestatement.cpp
View File

@@ -40,7 +40,7 @@
namespace Sqlite { namespace Sqlite {
SqliteStatement::SqliteStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database) Statement::Statement(Utils::SmallStringView sqlStatement, Database &database)
: m_compiledStatement(nullptr, deleteCompiledStatement), : m_compiledStatement(nullptr, deleteCompiledStatement),
m_database(database), m_database(database),
m_bindingParameterCount(0), m_bindingParameterCount(0),
@@ -53,7 +53,7 @@ SqliteStatement::SqliteStatement(Utils::SmallStringView sqlStatement, SqliteData
setColumnCount(); setColumnCount();
} }
void SqliteStatement::deleteCompiledStatement(sqlite3_stmt *compiledStatement) void Statement::deleteCompiledStatement(sqlite3_stmt *compiledStatement)
{ {
if (compiledStatement) if (compiledStatement)
sqlite3_finalize(compiledStatement); sqlite3_finalize(compiledStatement);
@@ -92,7 +92,7 @@ private:
std::mutex m_mutex; std::mutex m_mutex;
}; };
void SqliteStatement::waitForUnlockNotify() const void Statement::waitForUnlockNotify() const
{ {
UnlockNotification unlockNotification; UnlockNotification unlockNotification;
int resultCode = sqlite3_unlock_notify(sqliteDatabaseHandle(), UnlockNotification::unlockNotifyCallBack, &unlockNotification); int resultCode = sqlite3_unlock_notify(sqliteDatabaseHandle(), UnlockNotification::unlockNotifyCallBack, &unlockNotification);
@@ -103,7 +103,7 @@ void SqliteStatement::waitForUnlockNotify() const
throwException("SqliteStatement::waitForUnlockNotify: database is in a dead lock!"); throwException("SqliteStatement::waitForUnlockNotify: database is in a dead lock!");
} }
void SqliteStatement::reset() const void Statement::reset() const
{ {
int resultCode = sqlite3_reset(m_compiledStatement.get()); int resultCode = sqlite3_reset(m_compiledStatement.get());
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
@@ -112,7 +112,7 @@ void SqliteStatement::reset() const
m_isReadyToFetchValues = false; m_isReadyToFetchValues = false;
} }
bool SqliteStatement::next() const bool Statement::next() const
{ {
int resultCode; int resultCode;
@@ -130,26 +130,26 @@ bool SqliteStatement::next() const
return checkForStepError(resultCode); return checkForStepError(resultCode);
} }
void SqliteStatement::step() const void Statement::step() const
{ {
next(); next();
} }
void SqliteStatement::execute() const void Statement::execute() const
{ {
next(); next();
reset(); reset();
} }
int SqliteStatement::columnCount() const int Statement::columnCount() const
{ {
return m_columnCount; return m_columnCount;
} }
Utils::SmallStringVector SqliteStatement::columnNames() const Utils::SmallStringVector Statement::columnNames() const
{ {
Utils::SmallStringVector columnNames; Utils::SmallStringVector columnNames;
int columnCount = SqliteStatement::columnCount(); int columnCount = Statement::columnCount();
columnNames.reserve(std::size_t(columnCount)); columnNames.reserve(std::size_t(columnCount));
for (int columnIndex = 0; columnIndex < columnCount; columnIndex++) for (int columnIndex = 0; columnIndex < columnCount; columnIndex++)
columnNames.emplace_back(sqlite3_column_origin_name(m_compiledStatement.get(), columnIndex)); columnNames.emplace_back(sqlite3_column_origin_name(m_compiledStatement.get(), columnIndex));
@@ -157,28 +157,28 @@ Utils::SmallStringVector SqliteStatement::columnNames() const
return columnNames; return columnNames;
} }
void SqliteStatement::bind(int index, int value) void Statement::bind(int index, int value)
{ {
int resultCode = sqlite3_bind_int(m_compiledStatement.get(), index, value); int resultCode = sqlite3_bind_int(m_compiledStatement.get(), index, value);
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
throwException("SqliteStatement::bind: cant' bind 32 bit integer!"); throwException("SqliteStatement::bind: cant' bind 32 bit integer!");
} }
void SqliteStatement::bind(int index, long long value) void Statement::bind(int index, long long value)
{ {
int resultCode = sqlite3_bind_int64(m_compiledStatement.get(), index, value); int resultCode = sqlite3_bind_int64(m_compiledStatement.get(), index, value);
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
throwException("SqliteStatement::bind: cant' bind 64 bit integer!"); throwException("SqliteStatement::bind: cant' bind 64 bit integer!");
} }
void SqliteStatement::bind(int index, double value) void Statement::bind(int index, double value)
{ {
int resultCode = sqlite3_bind_double(m_compiledStatement.get(), index, value); int resultCode = sqlite3_bind_double(m_compiledStatement.get(), index, value);
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
throwException("SqliteStatement::bind: cant' bind double!"); throwException("SqliteStatement::bind: cant' bind double!");
} }
void SqliteStatement::bind(int index, Utils::SmallStringView text) void Statement::bind(int index, Utils::SmallStringView text)
{ {
int resultCode = sqlite3_bind_text(m_compiledStatement.get(), index, text.data(), int(text.size()), SQLITE_TRANSIENT); int resultCode = sqlite3_bind_text(m_compiledStatement.get(), index, text.data(), int(text.size()), SQLITE_TRANSIENT);
if (resultCode != SQLITE_OK) if (resultCode != SQLITE_OK)
@@ -186,35 +186,35 @@ void SqliteStatement::bind(int index, Utils::SmallStringView text)
} }
template <typename Type> template <typename Type>
void SqliteStatement::bind(Utils::SmallStringView name, Type value) void Statement::bind(Utils::SmallStringView name, Type value)
{ {
int index = bindingIndexForName(name); int index = bindingIndexForName(name);
checkBindingName(index); checkBindingName(index);
bind(index, value); bind(index, value);
} }
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, int value); template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, int value);
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, long value); template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, long value);
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, long long value); template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, long long value);
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, double value); template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, double value);
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, Utils::SmallStringView text); template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, Utils::SmallStringView text);
int SqliteStatement::bindingIndexForName(Utils::SmallStringView name) const int Statement::bindingIndexForName(Utils::SmallStringView name) const
{ {
return sqlite3_bind_parameter_index(m_compiledStatement.get(), name.data()); return sqlite3_bind_parameter_index(m_compiledStatement.get(), name.data());
} }
void SqliteStatement::setBindingColumnNames(const Utils::SmallStringVector &bindingColumnNames) void Statement::setBindingColumnNames(const Utils::SmallStringVector &bindingColumnNames)
{ {
m_bindingColumnNames = bindingColumnNames; m_bindingColumnNames = bindingColumnNames;
} }
const Utils::SmallStringVector &SqliteStatement::bindingColumnNames() const const Utils::SmallStringVector &Statement::bindingColumnNames() const
{ {
return m_bindingColumnNames; return m_bindingColumnNames;
} }
void SqliteStatement::prepare(Utils::SmallStringView sqlStatement) void Statement::prepare(Utils::SmallStringView sqlStatement)
{ {
int resultCode; int resultCode;
@@ -235,17 +235,17 @@ void SqliteStatement::prepare(Utils::SmallStringView sqlStatement)
checkForPrepareError(resultCode); checkForPrepareError(resultCode);
} }
sqlite3 *SqliteStatement::sqliteDatabaseHandle() const sqlite3 *Statement::sqliteDatabaseHandle() const
{ {
return m_database.backend().sqliteDatabaseHandle(); return m_database.backend().sqliteDatabaseHandle();
} }
TextEncoding SqliteStatement::databaseTextEncoding() TextEncoding Statement::databaseTextEncoding()
{ {
return m_database.backend().textEncoding(); return m_database.backend().textEncoding();
} }
bool SqliteStatement::checkForStepError(int resultCode) const bool Statement::checkForStepError(int resultCode) const
{ {
switch (resultCode) { switch (resultCode) {
case SQLITE_ROW: return true; case SQLITE_ROW: return true;
@@ -261,7 +261,7 @@ bool SqliteStatement::checkForStepError(int resultCode) const
Q_UNREACHABLE(); Q_UNREACHABLE();
} }
void SqliteStatement::checkForPrepareError(int resultCode) const void Statement::checkForPrepareError(int resultCode) const
{ {
switch (resultCode) { switch (resultCode) {
case SQLITE_OK: return; case SQLITE_OK: return;
@@ -273,7 +273,7 @@ void SqliteStatement::checkForPrepareError(int resultCode) const
throwException("SqliteStatement::prepareStatement: unknown error has happened"); throwException("SqliteStatement::prepareStatement: unknown error has happened");
} }
void SqliteStatement::setIfIsReadyToFetchValues(int resultCode) const void Statement::setIfIsReadyToFetchValues(int resultCode) const
{ {
if (resultCode == SQLITE_ROW) if (resultCode == SQLITE_ROW)
m_isReadyToFetchValues = true; m_isReadyToFetchValues = true;
@@ -282,13 +282,13 @@ void SqliteStatement::setIfIsReadyToFetchValues(int resultCode) const
} }
void SqliteStatement::checkIfIsReadyToFetchValues() const void Statement::checkIfIsReadyToFetchValues() const
{ {
if (!m_isReadyToFetchValues) if (!m_isReadyToFetchValues)
throwException("SqliteStatement::value: there are no values to fetch!"); throwException("SqliteStatement::value: there are no values to fetch!");
} }
void SqliteStatement::checkColumnsAreValid(const std::vector<int> &columns) const void Statement::checkColumnsAreValid(const std::vector<int> &columns) const
{ {
for (int column : columns) { for (int column : columns) {
if (column < 0 || column >= m_columnCount) if (column < 0 || column >= m_columnCount)
@@ -296,25 +296,25 @@ void SqliteStatement::checkColumnsAreValid(const std::vector<int> &columns) cons
} }
} }
void SqliteStatement::checkColumnIsValid(int column) const void Statement::checkColumnIsValid(int column) const
{ {
if (column < 0 || column >= m_columnCount) if (column < 0 || column >= m_columnCount)
throwException("SqliteStatement::values: column index out of bound!"); throwException("SqliteStatement::values: column index out of bound!");
} }
void SqliteStatement::checkBindingIndex(int index) const void Statement::checkBindingIndex(int index) const
{ {
if (index <= 0 || index > m_bindingParameterCount) if (index <= 0 || index > m_bindingParameterCount)
throwException("SqliteStatement::bind: binding index is out of bound!"); throwException("SqliteStatement::bind: binding index is out of bound!");
} }
void SqliteStatement::checkBindingName(int index) const void Statement::checkBindingName(int index) const
{ {
if (index <= 0 || index > m_bindingParameterCount) if (index <= 0 || index > m_bindingParameterCount)
throwException("SqliteStatement::bind: binding name are not exists in this statement!"); throwException("SqliteStatement::bind: binding name are not exists in this statement!");
} }
void SqliteStatement::setBindingParameterCount() void Statement::setBindingParameterCount()
{ {
m_bindingParameterCount = sqlite3_bind_parameter_count(m_compiledStatement.get()); m_bindingParameterCount = sqlite3_bind_parameter_count(m_compiledStatement.get());
} }
@@ -327,7 +327,7 @@ Utils::SmallStringView chopFirstLetter(const char *rawBindingName)
return Utils::SmallStringView(""); return Utils::SmallStringView("");
} }
void SqliteStatement::setBindingColumnNamesFromStatement() void Statement::setBindingColumnNamesFromStatement()
{ {
for (int index = 1; index <= m_bindingParameterCount; index++) { for (int index = 1; index <= m_bindingParameterCount; index++) {
Utils::SmallStringView bindingName = chopFirstLetter(sqlite3_bind_parameter_name(m_compiledStatement.get(), index)); Utils::SmallStringView bindingName = chopFirstLetter(sqlite3_bind_parameter_name(m_compiledStatement.get(), index));
@@ -335,27 +335,27 @@ void SqliteStatement::setBindingColumnNamesFromStatement()
} }
} }
void SqliteStatement::setColumnCount() void Statement::setColumnCount()
{ {
m_columnCount = sqlite3_column_count(m_compiledStatement.get()); m_columnCount = sqlite3_column_count(m_compiledStatement.get());
} }
bool SqliteStatement::isReadOnlyStatement() const bool Statement::isReadOnlyStatement() const
{ {
return sqlite3_stmt_readonly(m_compiledStatement.get()); return sqlite3_stmt_readonly(m_compiledStatement.get());
} }
void SqliteStatement::throwException(const char *whatHasHappened) const void Statement::throwException(const char *whatHasHappened) const
{ {
throw SqliteException(whatHasHappened, sqlite3_errmsg(sqliteDatabaseHandle())); throw Exception(whatHasHappened, sqlite3_errmsg(sqliteDatabaseHandle()));
} }
QString SqliteStatement::columnName(int column) const QString Statement::columnName(int column) const
{ {
return QString::fromUtf8(sqlite3_column_name(m_compiledStatement.get(), column)); return QString::fromUtf8(sqlite3_column_name(m_compiledStatement.get(), column));
} }
SqliteDatabase &SqliteStatement::database() const Database &Statement::database() const
{ {
return m_database; return m_database;
} }
@@ -385,7 +385,7 @@ static StringType convertToTextForColumn(sqlite3_stmt *sqlStatment, int column)
} }
template<> template<>
int SqliteStatement::value<int>(int column) const int Statement::value<int>(int column) const
{ {
checkIfIsReadyToFetchValues(); checkIfIsReadyToFetchValues();
checkColumnIsValid(column); checkColumnIsValid(column);
@@ -393,13 +393,13 @@ int SqliteStatement::value<int>(int column) const
} }
template<> template<>
long SqliteStatement::value<long>(int column) const long Statement::value<long>(int column) const
{ {
return long(value<long long>(column)); return long(value<long long>(column));
} }
template<> template<>
long long SqliteStatement::value<long long>(int column) const long long Statement::value<long long>(int column) const
{ {
checkIfIsReadyToFetchValues(); checkIfIsReadyToFetchValues();
checkColumnIsValid(column); checkColumnIsValid(column);
@@ -407,7 +407,7 @@ long long SqliteStatement::value<long long>(int column) const
} }
template<> template<>
double SqliteStatement::value<double>(int column) const double Statement::value<double>(int column) const
{ {
checkIfIsReadyToFetchValues(); checkIfIsReadyToFetchValues();
checkColumnIsValid(column); checkColumnIsValid(column);
@@ -415,23 +415,23 @@ double SqliteStatement::value<double>(int column) const
} }
template<typename StringType> template<typename StringType>
StringType SqliteStatement::value(int column) const StringType Statement::value(int column) const
{ {
checkIfIsReadyToFetchValues(); checkIfIsReadyToFetchValues();
checkColumnIsValid(column); checkColumnIsValid(column);
return convertToTextForColumn<StringType>(m_compiledStatement.get(), column); return convertToTextForColumn<StringType>(m_compiledStatement.get(), column);
} }
template SQLITE_EXPORT Utils::SmallString SqliteStatement::value<Utils::SmallString>(int column) const; template SQLITE_EXPORT Utils::SmallString Statement::value<Utils::SmallString>(int column) const;
template SQLITE_EXPORT Utils::PathString SqliteStatement::value<Utils::PathString>(int column) const; template SQLITE_EXPORT Utils::PathString Statement::value<Utils::PathString>(int column) const;
Utils::SmallString SqliteStatement::text(int column) const Utils::SmallString Statement::text(int column) const
{ {
return value<Utils::SmallString>(column); return value<Utils::SmallString>(column);
} }
template <typename ContainerType> template <typename ContainerType>
ContainerType SqliteStatement::columnValues(const std::vector<int> &columnIndices) const ContainerType Statement::columnValues(const std::vector<int> &columnIndices) const
{ {
using ElementType = typename ContainerType::value_type; using ElementType = typename ContainerType::value_type;
ContainerType valueContainer; ContainerType valueContainer;
@@ -443,18 +443,18 @@ ContainerType SqliteStatement::columnValues(const std::vector<int> &columnIndice
} }
template <typename Type> template <typename Type>
Type SqliteStatement::toValue(Utils::SmallStringView sqlStatement, SqliteDatabase &database) Type Statement::toValue(Utils::SmallStringView sqlStatement, Database &database)
{ {
SqliteStatement statement(sqlStatement, database); Statement statement(sqlStatement, database);
statement.next(); statement.next();
return statement.value<Type>(0); return statement.value<Type>(0);
} }
template SQLITE_EXPORT int SqliteStatement::toValue<int>(Utils::SmallStringView sqlStatement, SqliteDatabase &database); template SQLITE_EXPORT int Statement::toValue<int>(Utils::SmallStringView sqlStatement, Database &database);
template SQLITE_EXPORT long long SqliteStatement::toValue<long long>(Utils::SmallStringView sqlStatement, SqliteDatabase &database); template SQLITE_EXPORT long long Statement::toValue<long long>(Utils::SmallStringView sqlStatement, Database &database);
template SQLITE_EXPORT double SqliteStatement::toValue<double>(Utils::SmallStringView sqlStatement, SqliteDatabase &database); template SQLITE_EXPORT double Statement::toValue<double>(Utils::SmallStringView sqlStatement, Database &database);
template SQLITE_EXPORT Utils::SmallString SqliteStatement::toValue<Utils::SmallString>(Utils::SmallStringView sqlStatement, SqliteDatabase &database); template SQLITE_EXPORT Utils::SmallString Statement::toValue<Utils::SmallString>(Utils::SmallStringView sqlStatement, Database &database);
} // namespace Sqlite } // namespace Sqlite

48
src/libs/sqlite/sqlitestatement.h
View File

@@ -43,13 +43,13 @@ struct sqlite3;
namespace Sqlite { namespace Sqlite {
class SqliteDatabase; class Database;
class SqliteDatabaseBackend; class DatabaseBackend;
class SQLITE_EXPORT SqliteStatement class SQLITE_EXPORT Statement
{ {
protected: protected:
explicit SqliteStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database); explicit Statement(Utils::SmallStringView sqlStatement, Database &database);
static void deleteCompiledStatement(sqlite3_stmt *m_compiledStatement); static void deleteCompiledStatement(sqlite3_stmt *m_compiledStatement);
@@ -344,7 +344,7 @@ protected:
} }
template <typename Type> template <typename Type>
static Type toValue(Utils::SmallStringView sqlStatement, SqliteDatabase &database); static Type toValue(Utils::SmallStringView sqlStatement, Database &database);
void prepare(Utils::SmallStringView sqlStatement); void prepare(Utils::SmallStringView sqlStatement);
void waitForUnlockNotify() const; void waitForUnlockNotify() const;
@@ -372,11 +372,11 @@ protected:
QString columnName(int column) const; QString columnName(int column) const;
SqliteDatabase &database() const; Database &database() const;
protected: protected:
explicit SqliteStatement(Utils::SmallStringView sqlStatement, explicit Statement(Utils::SmallStringView sqlStatement,
SqliteDatabaseBackend &databaseBackend); DatabaseBackend &databaseBackend);
private: private:
template <typename ContainerType, template <typename ContainerType,
@@ -452,27 +452,27 @@ private:
private: private:
std::unique_ptr<sqlite3_stmt, void (*)(sqlite3_stmt*)> m_compiledStatement; std::unique_ptr<sqlite3_stmt, void (*)(sqlite3_stmt*)> m_compiledStatement;
Utils::SmallStringVector m_bindingColumnNames; Utils::SmallStringVector m_bindingColumnNames;
SqliteDatabase &m_database; Database &m_database;
int m_bindingParameterCount; int m_bindingParameterCount;
int m_columnCount; int m_columnCount;
mutable bool m_isReadyToFetchValues; mutable bool m_isReadyToFetchValues;
}; };
extern template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, int value); extern template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, int value);
extern template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, long value); extern template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, long value);
extern template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, long long value); extern template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, long long value);
extern template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, double value); extern template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, double value);
extern template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, Utils::SmallStringView text); extern template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, Utils::SmallStringView text);
extern template SQLITE_EXPORT int SqliteStatement::toValue<int>(Utils::SmallStringView sqlStatement, SqliteDatabase &database); extern template SQLITE_EXPORT int Statement::toValue<int>(Utils::SmallStringView sqlStatement, Database &database);
extern template SQLITE_EXPORT long long SqliteStatement::toValue<long long>(Utils::SmallStringView sqlStatement, SqliteDatabase &database); extern template SQLITE_EXPORT long long Statement::toValue<long long>(Utils::SmallStringView sqlStatement, Database &database);
extern template SQLITE_EXPORT double SqliteStatement::toValue<double>(Utils::SmallStringView sqlStatement, SqliteDatabase &database); extern template SQLITE_EXPORT double Statement::toValue<double>(Utils::SmallStringView sqlStatement, Database &database);
extern template SQLITE_EXPORT Utils::SmallString SqliteStatement::toValue<Utils::SmallString>(Utils::SmallStringView sqlStatement, SqliteDatabase &database); extern template SQLITE_EXPORT Utils::SmallString Statement::toValue<Utils::SmallString>(Utils::SmallStringView sqlStatement, Database &database);
template <> SQLITE_EXPORT int SqliteStatement::value<int>(int column) const; template <> SQLITE_EXPORT int Statement::value<int>(int column) const;
template <> SQLITE_EXPORT long SqliteStatement::value<long>(int column) const; template <> SQLITE_EXPORT long Statement::value<long>(int column) const;
template <> SQLITE_EXPORT long long SqliteStatement::value<long long>(int column) const; template <> SQLITE_EXPORT long long Statement::value<long long>(int column) const;
template <> SQLITE_EXPORT double SqliteStatement::value<double>(int column) const; template <> SQLITE_EXPORT double Statement::value<double>(int column) const;
extern template SQLITE_EXPORT Utils::SmallString SqliteStatement::value<Utils::SmallString>(int column) const; extern template SQLITE_EXPORT Utils::SmallString Statement::value<Utils::SmallString>(int column) const;
extern template SQLITE_EXPORT Utils::PathString SqliteStatement::value<Utils::PathString>(int column) const; extern template SQLITE_EXPORT Utils::PathString Statement::value<Utils::PathString>(int column) const;
} // namespace Sqlite } // namespace Sqlite

16
src/libs/sqlite/sqlitetable.h
View File

@@ -33,12 +33,12 @@
namespace Sqlite { namespace Sqlite {
class SqliteDatabase; class Database;
class SqliteTable class Table
{ {
public: public:
SqliteTable(std::size_t reserve = 10) Table(std::size_t reserve = 10)
{ {
m_sqliteColumns.reserve(reserve); m_sqliteColumns.reserve(reserve);
m_sqliteIndices.reserve(reserve); m_sqliteIndices.reserve(reserve);
@@ -74,7 +74,7 @@ public:
m_useTemporaryTable = useTemporaryTable; m_useTemporaryTable = useTemporaryTable;
} }
SqliteColumn &addColumn(Utils::SmallString &&name, Column &addColumn(Utils::SmallString &&name,
ColumnType type = ColumnType::Numeric, ColumnType type = ColumnType::Numeric,
Contraint constraint = Contraint::NoConstraint) Contraint constraint = Contraint::NoConstraint)
{ {
@@ -83,7 +83,7 @@ public:
return m_sqliteColumns.back(); return m_sqliteColumns.back();
} }
SqliteIndex &addIndex(const SqliteColumnConstReferences &columns) Index &addIndex(const SqliteColumnConstReferences &columns)
{ {
m_sqliteIndices.emplace_back(m_tableName.clone(), sqliteColumnNames(columns)); m_sqliteIndices.emplace_back(m_tableName.clone(), sqliteColumnNames(columns));
@@ -120,11 +120,11 @@ public:
template <typename Database> template <typename Database>
void initializeIndices(Database &database) void initializeIndices(Database &database)
{ {
for (const SqliteIndex &index : m_sqliteIndices) for (const Index &index : m_sqliteIndices)
database.execute(index.sqlStatement()); database.execute(index.sqlStatement());
} }
friend bool operator==(const SqliteTable &first, const SqliteTable &second) friend bool operator==(const Table &first, const Table &second)
{ {
return first.m_tableName == second.m_tableName return first.m_tableName == second.m_tableName
&& first.m_withoutRowId == second.m_withoutRowId && first.m_withoutRowId == second.m_withoutRowId
@@ -138,7 +138,7 @@ private:
{ {
Utils::SmallStringVector columnNames; Utils::SmallStringVector columnNames;
for (const SqliteColumn &column : columns) for (const Column &column : columns)
columnNames.push_back(column.name()); columnNames.push_back(column.name());
return columnNames; return columnNames;

28
src/libs/sqlite/sqlitetransaction.h
View File

@@ -29,14 +29,14 @@
namespace Sqlite { namespace Sqlite {
class SqliteDatabaseBackend; class DatabaseBackend;
class SqliteDatabase; class Database;
template <typename Database> template <typename Database>
class SqliteAbstractTransaction class AbstractTransaction
{ {
public: public:
~SqliteAbstractTransaction() ~AbstractTransaction()
{ {
if (!m_isAlreadyCommited) if (!m_isAlreadyCommited)
m_database.execute("ROLLBACK"); m_database.execute("ROLLBACK");
@@ -49,7 +49,7 @@ public:
} }
protected: protected:
SqliteAbstractTransaction(Database &database) AbstractTransaction(Database &database)
: m_database(database) : m_database(database)
{ {
} }
@@ -60,33 +60,33 @@ private:
}; };
template <typename Database> template <typename Database>
class SqliteTransaction final : public SqliteAbstractTransaction<Database> class DeferredTransaction final : public AbstractTransaction<Database>
{ {
public: public:
SqliteTransaction(Database &database) DeferredTransaction(Database &database)
: SqliteAbstractTransaction<Database>(database) : AbstractTransaction<Database>(database)
{ {
database.execute("BEGIN"); database.execute("BEGIN");
} }
}; };
template <typename Database> template <typename Database>
class SqliteImmediateTransaction final : public SqliteAbstractTransaction<Database> class ImmediateTransaction final : public AbstractTransaction<Database>
{ {
public: public:
SqliteImmediateTransaction(Database &database) ImmediateTransaction(Database &database)
: SqliteAbstractTransaction<Database>(database) : AbstractTransaction<Database>(database)
{ {
database.execute("BEGIN IMMEDIATE"); database.execute("BEGIN IMMEDIATE");
} }
}; };
template <typename Database> template <typename Database>
class SqliteExclusiveTransaction final : public SqliteAbstractTransaction<Database> class ExclusiveTransaction final : public AbstractTransaction<Database>
{ {
public: public:
SqliteExclusiveTransaction(Database &database) ExclusiveTransaction(Database &database)
: SqliteAbstractTransaction<Database>(database) : AbstractTransaction<Database>(database)
{ {
database.execute("BEGIN EXCLUSIVE"); database.execute("BEGIN EXCLUSIVE");
} }

8
src/libs/sqlite/sqlitewritestatement.cpp
View File

@@ -27,14 +27,14 @@
namespace Sqlite { namespace Sqlite {
SqliteWriteStatement::SqliteWriteStatement(Utils::SmallStringView sqlStatement, WriteStatement::WriteStatement(Utils::SmallStringView sqlStatement,
SqliteDatabase &database) Database &database)
: SqliteStatement(sqlStatement, database) : Statement(sqlStatement, database)
{ {
checkIsWritableStatement(); checkIsWritableStatement();
} }
void SqliteWriteStatement::checkIsWritableStatement() void WriteStatement::checkIsWritableStatement()
{ {
if (isReadOnlyStatement()) if (isReadOnlyStatement())
throwException("SqliteStatement::SqliteWriteStatement: is not a writable statement!"); throwException("SqliteStatement::SqliteWriteStatement: is not a writable statement!");

26
src/libs/sqlite/sqlitewritestatement.h
View File

@@ -29,22 +29,22 @@
namespace Sqlite { namespace Sqlite {
class SQLITE_EXPORT SqliteWriteStatement : private SqliteStatement class SQLITE_EXPORT WriteStatement : private Statement
{ {
public: public:
explicit SqliteWriteStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database); explicit WriteStatement(Utils::SmallStringView sqlStatement, Database &database);
using SqliteStatement::execute; using Statement::execute;
using SqliteStatement::reset; using Statement::reset;
using SqliteStatement::bind; using Statement::bind;
using SqliteStatement::bindValues; using Statement::bindValues;
using SqliteStatement::bindNameValues; using Statement::bindNameValues;
using SqliteStatement::bindingIndexForName; using Statement::bindingIndexForName;
using SqliteStatement::setBindingColumnNames; using Statement::setBindingColumnNames;
using SqliteStatement::bindingColumnNames; using Statement::bindingColumnNames;
using SqliteStatement::database; using Statement::database;
using SqliteStatement::write; using Statement::write;
using SqliteStatement::writeNamed; using Statement::writeNamed;
protected: protected:
void checkIsWritableStatement(); void checkIsWritableStatement();

4
src/libs/sqlite/sqlstatementbuilderexception.h
View File

@@ -29,10 +29,10 @@
namespace Sqlite { namespace Sqlite {
class SQLITE_EXPORT SqlStatementBuilderException : public SqliteException class SQLITE_EXPORT SqlStatementBuilderException : public Exception
{ {
public: public:
using SqliteException::SqliteException; using Exception::Exception;
}; };
} // namespace Sqlite } // namespace Sqlite

2
src/tools/clangrefactoringbackend/clangrefactoringbackendmain.cpp
View File

@@ -78,7 +78,7 @@ try {
return application.exec(); return application.exec();
} catch (const Sqlite::SqliteException &exception) { } catch (const Sqlite::Exception &exception) {
exception.printWarning(); exception.printWarning();
} }

52
src/tools/clangrefactoringbackend/source/storagesqlitestatementfactory.h
View File

@@ -47,88 +47,88 @@ public:
{ {
} }
Sqlite::SqliteTable createSymbolsTable() Sqlite::Table createSymbolsTable()
{ {
Sqlite::SqliteTable table; Sqlite::Table table;
table.setUseIfNotExists(true); table.setUseIfNotExists(true);
table.setName("symbols"); table.setName("symbols");
table.addColumn("symbolId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey); table.addColumn("symbolId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey);
const Sqlite::SqliteColumn &usrColumn = table.addColumn("usr", Sqlite::ColumnType::Text); const Sqlite::Column &usrColumn = table.addColumn("usr", Sqlite::ColumnType::Text);
table.addColumn("symbolName", Sqlite::ColumnType::Text); table.addColumn("symbolName", Sqlite::ColumnType::Text);
table.addIndex({usrColumn}); table.addIndex({usrColumn});
Sqlite::SqliteImmediateTransaction<DatabaseType> transaction(database); Sqlite::ImmediateTransaction<DatabaseType> transaction(database);
table.initialize(database); table.initialize(database);
transaction.commit(); transaction.commit();
return table; return table;
} }
Sqlite::SqliteTable createLocationsTable() Sqlite::Table createLocationsTable()
{ {
Sqlite::SqliteTable table; Sqlite::Table table;
table.setUseIfNotExists(true); table.setUseIfNotExists(true);
table.setName("locations"); table.setName("locations");
table.addColumn("symbolId", Sqlite::ColumnType::Integer); table.addColumn("symbolId", Sqlite::ColumnType::Integer);
table.addColumn("line", Sqlite::ColumnType::Integer); table.addColumn("line", Sqlite::ColumnType::Integer);
table.addColumn("column", Sqlite::ColumnType::Integer); table.addColumn("column", Sqlite::ColumnType::Integer);
const Sqlite::SqliteColumn &sourceIdColumn = table.addColumn("sourceId", Sqlite::ColumnType::Integer); const Sqlite::Column &sourceIdColumn = table.addColumn("sourceId", Sqlite::ColumnType::Integer);
table.addIndex({sourceIdColumn}); table.addIndex({sourceIdColumn});
Sqlite::SqliteImmediateTransaction<DatabaseType> transaction(database); Sqlite::ImmediateTransaction<DatabaseType> transaction(database);
table.initialize(database); table.initialize(database);
transaction.commit(); transaction.commit();
return table; return table;
} }
Sqlite::SqliteTable createSourcesTable() Sqlite::Table createSourcesTable()
{ {
Sqlite::SqliteTable table; Sqlite::Table table;
table.setUseIfNotExists(true); table.setUseIfNotExists(true);
table.setName("sources"); table.setName("sources");
table.addColumn("sourceId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey); table.addColumn("sourceId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey);
table.addColumn("sourcePath", Sqlite::ColumnType::Text); table.addColumn("sourcePath", Sqlite::ColumnType::Text);
Sqlite::SqliteImmediateTransaction<DatabaseType> transaction(database); Sqlite::ImmediateTransaction<DatabaseType> transaction(database);
table.initialize(database); table.initialize(database);
transaction.commit(); transaction.commit();
return table; return table;
} }
Sqlite::SqliteTable createNewSymbolsTable() const Sqlite::Table createNewSymbolsTable() const
{ {
Sqlite::SqliteTable table; Sqlite::Table table;
table.setName("newSymbols"); table.setName("newSymbols");
table.setUseTemporaryTable(true); table.setUseTemporaryTable(true);
table.addColumn("temporarySymbolId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey); table.addColumn("temporarySymbolId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey);
const Sqlite::SqliteColumn &symbolIdColumn = table.addColumn("symbolId", Sqlite::ColumnType::Integer); const Sqlite::Column &symbolIdColumn = table.addColumn("symbolId", Sqlite::ColumnType::Integer);
const Sqlite::SqliteColumn &usrColumn = table.addColumn("usr", Sqlite::ColumnType::Text); const Sqlite::Column &usrColumn = table.addColumn("usr", Sqlite::ColumnType::Text);
const Sqlite::SqliteColumn &symbolNameColumn = table.addColumn("symbolName", Sqlite::ColumnType::Text); const Sqlite::Column &symbolNameColumn = table.addColumn("symbolName", Sqlite::ColumnType::Text);
table.addIndex({usrColumn, symbolNameColumn}); table.addIndex({usrColumn, symbolNameColumn});
table.addIndex({symbolIdColumn}); table.addIndex({symbolIdColumn});
Sqlite::SqliteImmediateTransaction<DatabaseType> transaction(database); Sqlite::ImmediateTransaction<DatabaseType> transaction(database);
table.initialize(database); table.initialize(database);
transaction.commit(); transaction.commit();
return table; return table;
} }
Sqlite::SqliteTable createNewLocationsTable() const Sqlite::Table createNewLocationsTable() const
{ {
Sqlite::SqliteTable table; Sqlite::Table table;
table.setName("newLocations"); table.setName("newLocations");
table.setUseTemporaryTable(true); table.setUseTemporaryTable(true);
table.addColumn("temporarySymbolId", Sqlite::ColumnType::Integer); table.addColumn("temporarySymbolId", Sqlite::ColumnType::Integer);
table.addColumn("symbolId", Sqlite::ColumnType::Integer); table.addColumn("symbolId", Sqlite::ColumnType::Integer);
table.addColumn("line", Sqlite::ColumnType::Integer); table.addColumn("line", Sqlite::ColumnType::Integer);
table.addColumn("column", Sqlite::ColumnType::Integer); table.addColumn("column", Sqlite::ColumnType::Integer);
const Sqlite::SqliteColumn &sourceIdColumn = table.addColumn("sourceId", Sqlite::ColumnType::Integer); const Sqlite::Column &sourceIdColumn = table.addColumn("sourceId", Sqlite::ColumnType::Integer);
table.addIndex({sourceIdColumn}); table.addIndex({sourceIdColumn});
Sqlite::SqliteImmediateTransaction<DatabaseType> transaction(database); Sqlite::ImmediateTransaction<DatabaseType> transaction(database);
table.initialize(database); table.initialize(database);
transaction.commit(); transaction.commit();
@@ -137,11 +137,11 @@ public:
public: public:
Database &database; Database &database;
Sqlite::SqliteTable symbolsTable{createSymbolsTable()}; Sqlite::Table symbolsTable{createSymbolsTable()};
Sqlite::SqliteTable locationsTable{createLocationsTable()}; Sqlite::Table locationsTable{createLocationsTable()};
Sqlite::SqliteTable sourcesTable{createSourcesTable()}; Sqlite::Table sourcesTable{createSourcesTable()};
Sqlite::SqliteTable newSymbolsTablet{createNewSymbolsTable()}; Sqlite::Table newSymbolsTablet{createNewSymbolsTable()};
Sqlite::SqliteTable newLocationsTable{createNewLocationsTable()}; Sqlite::Table newLocationsTable{createNewLocationsTable()};
WriteStatement insertSymbolsToNewSymbolsStatement{ WriteStatement insertSymbolsToNewSymbolsStatement{
"INSERT INTO newSymbols(temporarySymbolId, usr, symbolName) VALUES(?,?,?)", "INSERT INTO newSymbols(temporarySymbolId, usr, symbolName) VALUES(?,?,?)",
database}; database};

10
src/tools/clangrefactoringbackend/source/symbolindexing.h
View File

@@ -43,9 +43,9 @@ namespace ClangBackEnd {
class SymbolIndexing final : public SymbolIndexingInterface class SymbolIndexing final : public SymbolIndexingInterface
{ {
public: public:
using StatementFactory = ClangBackEnd::StorageSqliteStatementFactory<Sqlite::SqliteDatabase, using StatementFactory = ClangBackEnd::StorageSqliteStatementFactory<Sqlite::Database,
Sqlite::SqliteReadStatement, Sqlite::ReadStatement,
Sqlite::SqliteWriteStatement>; Sqlite::WriteStatement>;
using Storage = ClangBackEnd::SymbolStorage<StatementFactory>; using Storage = ClangBackEnd::SymbolStorage<StatementFactory>;
SymbolIndexing(FilePathCache<std::mutex> &filePathCache, SymbolIndexing(FilePathCache<std::mutex> &filePathCache,
@@ -61,7 +61,7 @@ public:
return m_indexer; return m_indexer;
} }
Sqlite::SqliteDatabase &database() Sqlite::Database &database()
{ {
return m_database; return m_database;
} }
@@ -74,7 +74,7 @@ public:
private: private:
FilePathCache<std::mutex> &m_filePathCache; FilePathCache<std::mutex> &m_filePathCache;
Sqlite::SqliteDatabase m_database; Sqlite::Database m_database;
SymbolsCollector m_collector{m_filePathCache}; SymbolsCollector m_collector{m_filePathCache};
StatementFactory m_statementFactory{m_database}; StatementFactory m_statementFactory{m_database};
Storage m_symbolStorage{m_statementFactory, m_filePathCache}; Storage m_symbolStorage{m_statementFactory, m_filePathCache};

2
src/tools/clangrefactoringbackend/source/symbolstorage.h
View File

@@ -38,7 +38,7 @@ namespace ClangBackEnd {
template <typename StatementFactory> template <typename StatementFactory>
class SymbolStorage : public SymbolStorageInterface class SymbolStorage : public SymbolStorageInterface
{ {
using Transaction = Sqlite::SqliteImmediateTransaction<typename StatementFactory::DatabaseType>; using Transaction = Sqlite::ImmediateTransaction<typename StatementFactory::DatabaseType>;
using ReadStatement = typename StatementFactory::ReadStatementType; using ReadStatement = typename StatementFactory::ReadStatementType;
using WriteStatement = typename StatementFactory::WriteStatementType; using WriteStatement = typename StatementFactory::WriteStatementType;
using Database = typename StatementFactory::DatabaseType; using Database = typename StatementFactory::DatabaseType;

2
tests/unit/unittest/createtablesqlstatementbuilder-test.cpp
View File

@@ -34,7 +34,7 @@ using Sqlite::ColumnType;
using Sqlite::Contraint; using Sqlite::Contraint;
using Sqlite::JournalMode; using Sqlite::JournalMode;
using Sqlite::OpenMode; using Sqlite::OpenMode;
using Sqlite::SqliteColumn; using Sqlite::Column;
using Sqlite::SqliteColumns; using Sqlite::SqliteColumns;
using Sqlite::SqlStatementBuilderException; using Sqlite::SqlStatementBuilderException;

4
tests/unit/unittest/sqlitecolumn-test.cpp
View File

@@ -37,7 +37,7 @@ using Sqlite::ColumnType;
using Sqlite::Contraint; using Sqlite::Contraint;
using Sqlite::JournalMode; using Sqlite::JournalMode;
using Sqlite::OpenMode; using Sqlite::OpenMode;
using Column = Sqlite::SqliteColumn; using Column = Sqlite::Column;
using Sqlite::SqliteColumns; using Sqlite::SqliteColumns;
class SqliteColumn : public ::testing::Test class SqliteColumn : public ::testing::Test
@@ -45,7 +45,7 @@ class SqliteColumn : public ::testing::Test
protected: protected:
void SetUp() override; void SetUp() override;
Sqlite::SqliteColumn column; Sqlite::Column column;
}; };
TEST_F(SqliteColumn, ChangeName) TEST_F(SqliteColumn, ChangeName)

4
tests/unit/unittest/sqlitedatabase-test.cpp
View File

@@ -41,7 +41,7 @@ using testing::Contains;
using Sqlite::ColumnType; using Sqlite::ColumnType;
using Sqlite::JournalMode; using Sqlite::JournalMode;
using Sqlite::OpenMode; using Sqlite::OpenMode;
using Sqlite::SqliteTable; using Sqlite::Table;
class SqliteDatabase : public ::testing::Test class SqliteDatabase : public ::testing::Test
{ {
@@ -51,7 +51,7 @@ protected:
SpyDummy spyDummy; SpyDummy spyDummy;
QString databaseFilePath = QStringLiteral(":memory:"); QString databaseFilePath = QStringLiteral(":memory:");
Sqlite::SqliteDatabase database; Sqlite::Database database;
}; };
TEST_F(SqliteDatabase, SetDatabaseFilePath) TEST_F(SqliteDatabase, SetDatabaseFilePath)

18
tests/unit/unittest/sqlitedatabasebackend-test.cpp
View File

@@ -36,15 +36,15 @@
namespace { namespace {
using Backend = Sqlite::SqliteDatabaseBackend; using Backend = Sqlite::DatabaseBackend;
using Sqlite::ColumnType; using Sqlite::ColumnType;
using Sqlite::Contraint; using Sqlite::Contraint;
using Sqlite::JournalMode; using Sqlite::JournalMode;
using Sqlite::OpenMode; using Sqlite::OpenMode;
using Sqlite::TextEncoding; using Sqlite::TextEncoding;
using Sqlite::SqliteException; using Sqlite::Exception;
using Sqlite::SqliteWriteStatement; using Sqlite::WriteStatement;
class SqliteDatabaseBackend : public ::testing::Test class SqliteDatabaseBackend : public ::testing::Test
{ {
@@ -53,27 +53,27 @@ protected:
void TearDown() override; void TearDown() override;
Utils::PathString databaseFilePath = QDir::tempPath() + "/SqliteDatabaseBackendTest.db"; Utils::PathString databaseFilePath = QDir::tempPath() + "/SqliteDatabaseBackendTest.db";
Sqlite::SqliteDatabase database; Sqlite::Database database;
Sqlite::SqliteDatabaseBackend &databaseBackend = database.backend(); Sqlite::DatabaseBackend &databaseBackend = database.backend();
}; };
using SqliteDatabaseBackendSlowTest = SqliteDatabaseBackend; using SqliteDatabaseBackendSlowTest = SqliteDatabaseBackend;
TEST_F(SqliteDatabaseBackend, OpenAlreadyOpenDatabase) TEST_F(SqliteDatabaseBackend, OpenAlreadyOpenDatabase)
{ {
ASSERT_THROW(databaseBackend.open(databaseFilePath, OpenMode::ReadWrite), SqliteException); ASSERT_THROW(databaseBackend.open(databaseFilePath, OpenMode::ReadWrite), Exception);
} }
TEST_F(SqliteDatabaseBackend, CloseAlreadyClosedDatabase) TEST_F(SqliteDatabaseBackend, CloseAlreadyClosedDatabase)
{ {
databaseBackend.close(); databaseBackend.close();
ASSERT_THROW(databaseBackend.close(), SqliteException); ASSERT_THROW(databaseBackend.close(), Exception);
} }
TEST_F(SqliteDatabaseBackend, OpenWithWrongPath) TEST_F(SqliteDatabaseBackend, OpenWithWrongPath)
{ {
ASSERT_THROW(databaseBackend.open("/xxx/SqliteDatabaseBackendTest.db", OpenMode::ReadWrite), SqliteException); ASSERT_THROW(databaseBackend.open("/xxx/SqliteDatabaseBackendTest.db", OpenMode::ReadWrite), Exception);
} }
TEST_F(SqliteDatabaseBackend, DefaultJournalMode) TEST_F(SqliteDatabaseBackend, DefaultJournalMode)
@@ -148,7 +148,7 @@ TEST_F(SqliteDatabaseBackend, TextEncodingCannotBeChangedAfterTouchingDatabase)
databaseBackend.execute("CREATE TABLE text(name, number)"); databaseBackend.execute("CREATE TABLE text(name, number)");
ASSERT_THROW(databaseBackend.setTextEncoding(TextEncoding::Utf16), SqliteException); ASSERT_THROW(databaseBackend.setTextEncoding(TextEncoding::Utf16), Exception);
} }
TEST_F(SqliteDatabaseBackend, OpenModeReadOnly) TEST_F(SqliteDatabaseBackend, OpenModeReadOnly)

24
tests/unit/unittest/sqliteindex-test.cpp
View File

@@ -29,38 +29,38 @@
namespace { namespace {
using Sqlite::SqliteException; using Sqlite::Exception;
using Sqlite::SqliteIndex; using Sqlite::Index;
TEST(SqliteIndex, OneColumn) TEST(Index, OneColumn)
{ {
SqliteIndex index{"tableName", {"column1"}}; Index index{"tableName", {"column1"}};
auto sqlStatement = index.sqlStatement(); auto sqlStatement = index.sqlStatement();
ASSERT_THAT(sqlStatement, Eq("CREATE INDEX IF NOT EXISTS index_tableName_column1 ON tableName(column1)")); ASSERT_THAT(sqlStatement, Eq("CREATE INDEX IF NOT EXISTS index_tableName_column1 ON tableName(column1)"));
} }
TEST(SqliteIndex, TwoColumn) TEST(Index, TwoColumn)
{ {
SqliteIndex index{"tableName", {"column1", "column2"}}; Index index{"tableName", {"column1", "column2"}};
auto sqlStatement = index.sqlStatement(); auto sqlStatement = index.sqlStatement();
ASSERT_THAT(sqlStatement, Eq("CREATE INDEX IF NOT EXISTS index_tableName_column1_column2 ON tableName(column1, column2)")); ASSERT_THAT(sqlStatement, Eq("CREATE INDEX IF NOT EXISTS index_tableName_column1_column2 ON tableName(column1, column2)"));
} }
TEST(SqliteIndex, EmptyTableName) TEST(Index, EmptyTableName)
{ {
SqliteIndex index{"", {"column1", "column2"}}; Index index{"", {"column1", "column2"}};
ASSERT_THROW(index.sqlStatement(), SqliteException); ASSERT_THROW(index.sqlStatement(), Exception);
} }
TEST(SqliteIndex, EmptyColumns) TEST(Index, EmptyColumns)
{ {
SqliteIndex index{"tableName", {}}; Index index{"tableName", {}};
ASSERT_THROW(index.sqlStatement(), SqliteException); ASSERT_THROW(index.sqlStatement(), Exception);
} }
} }

114
tests/unit/unittest/sqlitestatement-test.cpp
View File

@@ -39,11 +39,11 @@
namespace { namespace {
using Sqlite::JournalMode; using Sqlite::JournalMode;
using Sqlite::SqliteException; using Sqlite::Exception;
using Sqlite::SqliteDatabase; using Sqlite::Database;
using Sqlite::SqliteReadStatement; using Sqlite::ReadStatement;
using Sqlite::SqliteReadWriteStatement; using Sqlite::ReadWriteStatement;
using Sqlite::SqliteWriteStatement; using Sqlite::WriteStatement;
MATCHER_P3(HasValues, value1, value2, rowid, MATCHER_P3(HasValues, value1, value2, rowid,
std::string(negation ? "isn't" : "is") std::string(negation ? "isn't" : "is")
@@ -52,9 +52,9 @@ MATCHER_P3(HasValues, value1, value2, rowid,
+ " and " + PrintToString(rowid) + " and " + PrintToString(rowid)
) )
{ {
SqliteDatabase &database = arg.database(); Database &database = arg.database();
SqliteReadStatement statement("SELECT name, number FROM test WHERE rowid=?", database); ReadStatement statement("SELECT name, number FROM test WHERE rowid=?", database);
statement.bind(1, rowid); statement.bind(1, rowid);
statement.next(); statement.next();
@@ -69,7 +69,7 @@ protected:
void TearDown() override; void TearDown() override;
protected: protected:
SqliteDatabase database; Database database;
}; };
struct Output struct Output
@@ -89,27 +89,27 @@ struct Output
TEST_F(SqliteStatement, PrepareFailure) TEST_F(SqliteStatement, PrepareFailure)
{ {
ASSERT_THROW(SqliteReadStatement("blah blah blah", database), SqliteException); ASSERT_THROW(ReadStatement("blah blah blah", database), Exception);
ASSERT_THROW(SqliteWriteStatement("blah blah blah", database), SqliteException); ASSERT_THROW(WriteStatement("blah blah blah", database), Exception);
ASSERT_THROW(SqliteReadStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), SqliteException); ASSERT_THROW(ReadStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), Exception);
ASSERT_THROW(SqliteWriteStatement("SELECT name, number FROM test '", database), SqliteException); ASSERT_THROW(WriteStatement("SELECT name, number FROM test '", database), Exception);
} }
TEST_F(SqliteStatement, CountRows) TEST_F(SqliteStatement, CountRows)
{ {
SqliteReadStatement statement("SELECT * FROM test", database); ReadStatement statement("SELECT * FROM test", database);
int nextCount = 0; int nextCount = 0;
while (statement.next()) while (statement.next())
++nextCount; ++nextCount;
int sqlCount = SqliteReadStatement::toValue<int>("SELECT count(*) FROM test", database); int sqlCount = ReadStatement::toValue<int>("SELECT count(*) FROM test", database);
ASSERT_THAT(nextCount, sqlCount); ASSERT_THAT(nextCount, sqlCount);
} }
TEST_F(SqliteStatement, Value) TEST_F(SqliteStatement, Value)
{ {
SqliteReadStatement statement("SELECT name, number FROM test ORDER BY name", database); ReadStatement statement("SELECT name, number FROM test ORDER BY name", database);
statement.next(); statement.next();
statement.next(); statement.next();
@@ -126,46 +126,46 @@ TEST_F(SqliteStatement, Value)
TEST_F(SqliteStatement, ValueFailure) TEST_F(SqliteStatement, ValueFailure)
{ {
SqliteReadStatement statement("SELECT name, number FROM test", database); ReadStatement statement("SELECT name, number FROM test", database);
ASSERT_THROW(statement.value<int>(0), SqliteException); ASSERT_THROW(statement.value<int>(0), Exception);
statement.reset(); statement.reset();
while (statement.next()) {} while (statement.next()) {}
ASSERT_THROW(statement.value<int>(0), SqliteException); ASSERT_THROW(statement.value<int>(0), Exception);
statement.reset(); statement.reset();
statement.next(); statement.next();
ASSERT_THROW(statement.value<int>(-1), SqliteException); ASSERT_THROW(statement.value<int>(-1), Exception);
ASSERT_THROW(statement.value<int>(2), SqliteException); ASSERT_THROW(statement.value<int>(2), Exception);
} }
TEST_F(SqliteStatement, ToIntergerValue) TEST_F(SqliteStatement, ToIntergerValue)
{ {
auto value = SqliteReadStatement::toValue<int>("SELECT number FROM test WHERE name='foo'", database); auto value = ReadStatement::toValue<int>("SELECT number FROM test WHERE name='foo'", database);
ASSERT_THAT(value, 23); ASSERT_THAT(value, 23);
} }
TEST_F(SqliteStatement, ToLongIntergerValue) TEST_F(SqliteStatement, ToLongIntergerValue)
{ {
ASSERT_THAT(SqliteReadStatement::toValue<qint64>("SELECT number FROM test WHERE name='foo'", database), Eq(23)); ASSERT_THAT(ReadStatement::toValue<qint64>("SELECT number FROM test WHERE name='foo'", database), Eq(23));
} }
TEST_F(SqliteStatement, ToDoubleValue) TEST_F(SqliteStatement, ToDoubleValue)
{ {
ASSERT_THAT(SqliteReadStatement::toValue<double>("SELECT number FROM test WHERE name='foo'", database), 23.3); ASSERT_THAT(ReadStatement::toValue<double>("SELECT number FROM test WHERE name='foo'", database), 23.3);
} }
TEST_F(SqliteStatement, ToStringValue) TEST_F(SqliteStatement, ToStringValue)
{ {
ASSERT_THAT(SqliteReadStatement::toValue<Utils::SmallString>("SELECT name FROM test WHERE name='foo'", database), "foo"); ASSERT_THAT(ReadStatement::toValue<Utils::SmallString>("SELECT name FROM test WHERE name='foo'", database), "foo");
} }
TEST_F(SqliteStatement, ColumnNames) TEST_F(SqliteStatement, ColumnNames)
{ {
SqliteReadStatement statement("SELECT name, number FROM test", database); ReadStatement statement("SELECT name, number FROM test", database);
auto columnNames = statement.columnNames(); auto columnNames = statement.columnNames();
@@ -175,7 +175,7 @@ TEST_F(SqliteStatement, ColumnNames)
TEST_F(SqliteStatement, BindString) TEST_F(SqliteStatement, BindString)
{ {
SqliteReadStatement statement("SELECT name, number FROM test WHERE name=?", database); ReadStatement statement("SELECT name, number FROM test WHERE name=?", database);
statement.bind(1, "foo"); statement.bind(1, "foo");
@@ -187,7 +187,7 @@ TEST_F(SqliteStatement, BindString)
TEST_F(SqliteStatement, BindInteger) TEST_F(SqliteStatement, BindInteger)
{ {
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=?", database); ReadStatement statement("SELECT name, number FROM test WHERE number=?", database);
statement.bind(1, 40); statement.bind(1, 40);
statement.next(); statement.next();
@@ -197,7 +197,7 @@ TEST_F(SqliteStatement, BindInteger)
TEST_F(SqliteStatement, BindLongInteger) TEST_F(SqliteStatement, BindLongInteger)
{ {
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=?", database); ReadStatement statement("SELECT name, number FROM test WHERE number=?", database);
statement.bind(1, int64_t(40)); statement.bind(1, int64_t(40));
statement.next(); statement.next();
@@ -207,7 +207,7 @@ TEST_F(SqliteStatement, BindLongInteger)
TEST_F(SqliteStatement, BindDouble) TEST_F(SqliteStatement, BindDouble)
{ {
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=?", database); ReadStatement statement("SELECT name, number FROM test WHERE number=?", database);
statement.bind(1, 23.3); statement.bind(1, 23.3);
statement.next(); statement.next();
@@ -217,7 +217,7 @@ TEST_F(SqliteStatement, BindDouble)
TEST_F(SqliteStatement, BindIntegerByParameter) TEST_F(SqliteStatement, BindIntegerByParameter)
{ {
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=@number", database); ReadStatement statement("SELECT name, number FROM test WHERE number=@number", database);
statement.bind("@number", 40); statement.bind("@number", 40);
statement.next(); statement.next();
@@ -227,7 +227,7 @@ TEST_F(SqliteStatement, BindIntegerByParameter)
TEST_F(SqliteStatement, BindLongIntegerByParameter) TEST_F(SqliteStatement, BindLongIntegerByParameter)
{ {
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=@number", database); ReadStatement statement("SELECT name, number FROM test WHERE number=@number", database);
statement.bind("@number", int64_t(40)); statement.bind("@number", int64_t(40));
statement.next(); statement.next();
@@ -237,7 +237,7 @@ TEST_F(SqliteStatement, BindLongIntegerByParameter)
TEST_F(SqliteStatement, BindDoubleByIndex) TEST_F(SqliteStatement, BindDoubleByIndex)
{ {
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=@number", database); ReadStatement statement("SELECT name, number FROM test WHERE number=@number", database);
statement.bind(statement.bindingIndexForName("@number"), 23.3); statement.bind(statement.bindingIndexForName("@number"), 23.3);
statement.next(); statement.next();
@@ -247,23 +247,23 @@ TEST_F(SqliteStatement, BindDoubleByIndex)
TEST_F(SqliteStatement, BindFailure) TEST_F(SqliteStatement, BindFailure)
{ {
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=@number", database); ReadStatement statement("SELECT name, number FROM test WHERE number=@number", database);
ASSERT_THROW(statement.bind(0, 40), SqliteException); ASSERT_THROW(statement.bind(0, 40), Exception);
ASSERT_THROW(statement.bind(2, 40), SqliteException); ASSERT_THROW(statement.bind(2, 40), Exception);
ASSERT_THROW(statement.bind("@name", 40), SqliteException); ASSERT_THROW(statement.bind("@name", 40), Exception);
} }
TEST_F(SqliteStatement, RequestBindingNamesFromStatement) TEST_F(SqliteStatement, RequestBindingNamesFromStatement)
{ {
SqliteWriteStatement statement("UPDATE test SET name=@name, number=@number WHERE rowid=@id", database); WriteStatement statement("UPDATE test SET name=@name, number=@number WHERE rowid=@id", database);
ASSERT_THAT(statement.bindingColumnNames(), ElementsAre("name", "number", "id")); ASSERT_THAT(statement.bindingColumnNames(), ElementsAre("name", "number", "id"));
} }
TEST_F(SqliteStatement, BindValues) TEST_F(SqliteStatement, BindValues)
{ {
SqliteWriteStatement statement("UPDATE test SET name=?, number=? WHERE rowid=?", database); WriteStatement statement("UPDATE test SET name=?, number=? WHERE rowid=?", database);
statement.bindValues("see", 7.23, 1); statement.bindValues("see", 7.23, 1);
statement.execute(); statement.execute();
@@ -273,7 +273,7 @@ TEST_F(SqliteStatement, BindValues)
TEST_F(SqliteStatement, WriteValues) TEST_F(SqliteStatement, WriteValues)
{ {
SqliteWriteStatement statement("UPDATE test SET name=?, number=? WHERE rowid=?", database); WriteStatement statement("UPDATE test SET name=?, number=? WHERE rowid=?", database);
statement.write("see", 7.23, 1); statement.write("see", 7.23, 1);
@@ -282,7 +282,7 @@ TEST_F(SqliteStatement, WriteValues)
TEST_F(SqliteStatement, BindNamedValues) TEST_F(SqliteStatement, BindNamedValues)
{ {
SqliteWriteStatement statement("UPDATE test SET name=@name, number=@number WHERE rowid=@id", database); WriteStatement statement("UPDATE test SET name=@name, number=@number WHERE rowid=@id", database);
statement.bindNameValues("@name", "see", "@number", 7.23, "@id", 1); statement.bindNameValues("@name", "see", "@number", 7.23, "@id", 1);
statement.execute(); statement.execute();
@@ -292,7 +292,7 @@ TEST_F(SqliteStatement, BindNamedValues)
TEST_F(SqliteStatement, WriteNamedValues) TEST_F(SqliteStatement, WriteNamedValues)
{ {
SqliteWriteStatement statement("UPDATE test SET name=@name, number=@number WHERE rowid=@id", database); WriteStatement statement("UPDATE test SET name=@name, number=@number WHERE rowid=@id", database);
statement.writeNamed("@name", "see", "@number", 7.23, "@id", 1); statement.writeNamed("@name", "see", "@number", 7.23, "@id", 1);
@@ -302,16 +302,16 @@ TEST_F(SqliteStatement, WriteNamedValues)
TEST_F(SqliteStatement, ClosedDatabase) TEST_F(SqliteStatement, ClosedDatabase)
{ {
database.close(); database.close();
ASSERT_THROW(SqliteWriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), SqliteException); ASSERT_THROW(WriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), Exception);
ASSERT_THROW(SqliteReadStatement("SELECT * FROM test", database), SqliteException); ASSERT_THROW(ReadStatement("SELECT * FROM test", database), Exception);
ASSERT_THROW(SqliteReadWriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), SqliteException); ASSERT_THROW(ReadWriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), Exception);
database.open(QDir::tempPath() + QStringLiteral("/SqliteStatementTest.db")); database.open(QDir::tempPath() + QStringLiteral("/SqliteStatementTest.db"));
} }
TEST_F(SqliteStatement, GetTupleValuesWithoutArguments) TEST_F(SqliteStatement, GetTupleValuesWithoutArguments)
{ {
using Tuple = std::tuple<Utils::SmallString, double, int>; using Tuple = std::tuple<Utils::SmallString, double, int>;
SqliteReadStatement statement("SELECT name, number, value FROM test", database); ReadStatement statement("SELECT name, number, value FROM test", database);
auto values = statement.tupleValues<Utils::SmallString, double, int>(3); auto values = statement.tupleValues<Utils::SmallString, double, int>(3);
@@ -322,7 +322,7 @@ TEST_F(SqliteStatement, GetTupleValuesWithoutArguments)
TEST_F(SqliteStatement, GetSingleValuesWithoutArguments) TEST_F(SqliteStatement, GetSingleValuesWithoutArguments)
{ {
SqliteReadStatement statement("SELECT name FROM test", database); ReadStatement statement("SELECT name FROM test", database);
std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3); std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3);
@@ -331,7 +331,7 @@ TEST_F(SqliteStatement, GetSingleValuesWithoutArguments)
TEST_F(SqliteStatement, GetStructValuesWithoutArguments) TEST_F(SqliteStatement, GetStructValuesWithoutArguments)
{ {
SqliteReadStatement statement("SELECT name, number, value FROM test", database); ReadStatement statement("SELECT name, number, value FROM test", database);
auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3); auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3);
@@ -342,7 +342,7 @@ TEST_F(SqliteStatement, GetStructValuesWithoutArguments)
TEST_F(SqliteStatement, GetValuesForSingleOutputWithBindingMultipleTimes) TEST_F(SqliteStatement, GetValuesForSingleOutputWithBindingMultipleTimes)
{ {
SqliteReadStatement statement("SELECT name FROM test WHERE number=?", database); ReadStatement statement("SELECT name FROM test WHERE number=?", database);
statement.values<Utils::SmallString>(3, 40); statement.values<Utils::SmallString>(3, 40);
std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3, 40); std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3, 40);
@@ -354,7 +354,7 @@ TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndContainerQueryValues)
{ {
using Tuple = std::tuple<Utils::SmallString, double, double>; using Tuple = std::tuple<Utils::SmallString, double, double>;
std::vector<double> queryValues = {40, 23.3}; std::vector<double> queryValues = {40, 23.3};
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE number=?", database); ReadStatement statement("SELECT name, number, value FROM test WHERE number=?", database);
auto values = statement.tupleValues<Utils::SmallString, double, double>(3, queryValues); auto values = statement.tupleValues<Utils::SmallString, double, double>(3, queryValues);
@@ -365,7 +365,7 @@ TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndContainerQueryValues)
TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryValues) TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryValues)
{ {
std::vector<double> queryValues = {40, 23.3}; std::vector<double> queryValues = {40, 23.3};
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=?", database); ReadStatement statement("SELECT name, number FROM test WHERE number=?", database);
std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3, queryValues); std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3, queryValues);
@@ -377,7 +377,7 @@ TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndContainerQueryTupleVa
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, int>; using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, int>;
using Tuple2 = std::tuple<Utils::SmallString, double, int>; using Tuple2 = std::tuple<Utils::SmallString, double, int>;
std::vector<Tuple> queryValues = {{"poo", "40", 3}, {"bar", "blah", 1}}; std::vector<Tuple> queryValues = {{"poo", "40", 3}, {"bar", "blah", 1}};
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name= ? AND number=? AND value=?", database); ReadStatement statement("SELECT name, number, value FROM test WHERE name= ? AND number=? AND value=?", database);
auto values = statement.tupleValues<Utils::SmallString, double, int>(3, queryValues); auto values = statement.tupleValues<Utils::SmallString, double, int>(3, queryValues);
@@ -389,7 +389,7 @@ TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryTupleValu
{ {
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString>; using Tuple = std::tuple<Utils::SmallString, Utils::SmallString>;
std::vector<Tuple> queryValues = {{"poo", "40"}, {"bar", "blah"}}; std::vector<Tuple> queryValues = {{"poo", "40"}, {"bar", "blah"}};
SqliteReadStatement statement("SELECT name, number FROM test WHERE name= ? AND number=?", database); ReadStatement statement("SELECT name, number FROM test WHERE name= ? AND number=?", database);
std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3, queryValues); std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3, queryValues);
@@ -399,7 +399,7 @@ TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryTupleValu
TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndMultipleQueryValue) TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndMultipleQueryValue)
{ {
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, long long>; using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, long long>;
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database); ReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database);
auto values = statement.tupleValues<Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah", 1); auto values = statement.tupleValues<Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah", 1);
@@ -409,7 +409,7 @@ TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndMultipleQueryValue)
TEST_F(SqliteStatement, CallGetValuesForMultipleOutputValuesAndMultipleQueryValueMultipleTimes) TEST_F(SqliteStatement, CallGetValuesForMultipleOutputValuesAndMultipleQueryValueMultipleTimes)
{ {
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, long long>; using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, long long>;
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=?", database); ReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=?", database);
statement.tupleValues<Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah"); statement.tupleValues<Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah");
auto values = statement.tupleValues<Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah"); auto values = statement.tupleValues<Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah");
@@ -419,7 +419,7 @@ TEST_F(SqliteStatement, CallGetValuesForMultipleOutputValuesAndMultipleQueryValu
TEST_F(SqliteStatement, GetStructOutputValuesAndMultipleQueryValue) TEST_F(SqliteStatement, GetStructOutputValuesAndMultipleQueryValue)
{ {
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database); ReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database);
auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah", 1); auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah", 1);
@@ -429,7 +429,7 @@ TEST_F(SqliteStatement, GetStructOutputValuesAndMultipleQueryValue)
TEST_F(SqliteStatement, GetStructOutputValuesAndContainerQueryValues) TEST_F(SqliteStatement, GetStructOutputValuesAndContainerQueryValues)
{ {
std::vector<double> queryValues = {40, 23.3}; std::vector<double> queryValues = {40, 23.3};
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE number=?", database); ReadStatement statement("SELECT name, number, value FROM test WHERE number=?", database);
auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3, queryValues); auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3, queryValues);
@@ -441,7 +441,7 @@ TEST_F(SqliteStatement, GetStructOutputValuesAndContainerQueryTupleValues)
{ {
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, int>; using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, int>;
std::vector<Tuple> queryValues = {{"poo", "40", 3}, {"bar", "blah", 1}}; std::vector<Tuple> queryValues = {{"poo", "40", 3}, {"bar", "blah", 1}};
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name= ? AND number=? AND value=?", database); ReadStatement statement("SELECT name, number, value FROM test WHERE name= ? AND number=? AND value=?", database);
auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3, queryValues); auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3, queryValues);

6
tests/unit/unittest/sqlitetable-test.cpp
View File

@@ -35,14 +35,14 @@ namespace {
using Sqlite::ColumnType; using Sqlite::ColumnType;
using Sqlite::JournalMode; using Sqlite::JournalMode;
using Sqlite::OpenMode; using Sqlite::OpenMode;
using Sqlite::SqliteColumn; using Sqlite::Column;
using Sqlite::SqliteDatabase; using Sqlite::Database;
class SqliteTable : public ::testing::Test class SqliteTable : public ::testing::Test
{ {
protected: protected:
NiceMock<MockSqliteDatabase> mockDatabase; NiceMock<MockSqliteDatabase> mockDatabase;
Sqlite::SqliteTable table; Sqlite::Table table;
Utils::SmallString tableName = "testTable"; Utils::SmallString tableName = "testTable";
}; };

2
tests/unit/unittest/storagesqlitestatementfactory-test.cpp
View File

@@ -37,7 +37,7 @@ using StatementFactory = ClangBackEnd::StorageSqliteStatementFactory<NiceMock<Mo
MockSqliteReadStatement, MockSqliteReadStatement,
MockSqliteWriteStatement>; MockSqliteWriteStatement>;
using Sqlite::SqliteTable; using Sqlite::Table;
class StorageSqliteStatementFactory : public testing::Test class StorageSqliteStatementFactory : public testing::Test
{ {

6
tests/unit/unittest/symbolindexing-test.cpp
View File

@@ -35,8 +35,8 @@
namespace { namespace {
using Sqlite::SqliteDatabase; using Sqlite::Database;
using Sqlite::SqliteReadStatement; using Sqlite::ReadStatement;
using ClangBackEnd::SymbolIndexer; using ClangBackEnd::SymbolIndexer;
using ClangBackEnd::SymbolsCollector; using ClangBackEnd::SymbolsCollector;
using ClangBackEnd::SymbolStorage; using ClangBackEnd::SymbolStorage;
@@ -49,7 +49,7 @@ using ClangRefactoring::QuerySqliteStatementFactory;
using Utils::PathString; using Utils::PathString;
using SL = ClangRefactoring::SourceLocations; using SL = ClangRefactoring::SourceLocations;
using StatementFactory = QuerySqliteStatementFactory<SqliteDatabase, SqliteReadStatement>; using StatementFactory = QuerySqliteStatementFactory<Database, ReadStatement>;
using Query = SymbolQuery<StatementFactory>; using Query = SymbolQuery<StatementFactory>;
MATCHER_P3(IsLocation, sourceId, line, column, MATCHER_P3(IsLocation, sourceId, line, column,

2
tests/unit/unittest/symbolquery-test.cpp
View File

@@ -36,7 +36,7 @@
namespace { namespace {
using ClangRefactoring::QuerySqliteStatementFactory; using ClangRefactoring::QuerySqliteStatementFactory;
using Sqlite::SqliteDatabase; using Sqlite::Database;
using StatementFactory = QuerySqliteStatementFactory<MockSqliteDatabase, using StatementFactory = QuerySqliteStatementFactory<MockSqliteDatabase,
MockSqliteReadStatement>; MockSqliteReadStatement>;

4
tests/unit/unittest/symbolstorage-test.cpp
View File

@@ -44,8 +44,8 @@ using ClangBackEnd::SourceLocationEntries;
using ClangBackEnd::SourceLocationEntry; using ClangBackEnd::SourceLocationEntry;
using ClangBackEnd::StorageSqliteStatementFactory; using ClangBackEnd::StorageSqliteStatementFactory;
using ClangBackEnd::SymbolType; using ClangBackEnd::SymbolType;
using Sqlite::SqliteDatabase; using Sqlite::Database;
using Sqlite::SqliteTable; using Sqlite::Table;
using StatementFactory = StorageSqliteStatementFactory<MockSqliteDatabase, using StatementFactory = StorageSqliteStatementFactory<MockSqliteDatabase,
MockSqliteReadStatement, MockSqliteReadStatement,