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;
for (const SqliteColumn &columns : m_columns) {
for (const Column &columns : m_columns) {
Utils::SmallString columnDefinitionString = {columns.name(), " ", columns.typeString()};
switch (columns.constraint()) {

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

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

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

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

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

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

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

@@ -40,25 +40,25 @@
namespace Sqlite {
SqliteDatabaseBackend::SqliteDatabaseBackend(SqliteDatabase &database)
DatabaseBackend::DatabaseBackend(Database &database)
: m_database(database),
m_databaseHandle(nullptr),
m_cachedTextEncoding(Utf8)
{
}
SqliteDatabaseBackend::~SqliteDatabaseBackend()
DatabaseBackend::~DatabaseBackend()
{
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);
checkMmapSizeIsSet(resultCode);
}
void SqliteDatabaseBackend::activateMultiThreading()
void DatabaseBackend::activateMultiThreading()
{
int resultCode = sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
checkIfMultithreadingIsActivated(resultCode);
@@ -69,31 +69,31 @@ static void sqliteLog(void*,int errorCode,const char *errorMessage)
qWarning() << sqlite3_errstr(errorCode) << errorMessage;
}
void SqliteDatabaseBackend::activateLogging()
void DatabaseBackend::activateLogging()
{
int resultCode = sqlite3_config(SQLITE_CONFIG_LOG, sqliteLog, nullptr);
checkIfLoogingIsActivated(resultCode);
}
void SqliteDatabaseBackend::initializeSqliteLibrary()
void DatabaseBackend::initializeSqliteLibrary()
{
int resultCode = sqlite3_initialize();
checkInitializeSqliteLibraryWasSuccesful(resultCode);
}
void SqliteDatabaseBackend::shutdownSqliteLibrary()
void DatabaseBackend::shutdownSqliteLibrary()
{
int resultCode = sqlite3_shutdown();
checkShutdownSqliteLibraryWasSuccesful(resultCode);
}
void SqliteDatabaseBackend::checkpointFullWalLog()
void DatabaseBackend::checkpointFullWalLog()
{
int resultCode = sqlite3_wal_checkpoint_v2(sqliteDatabaseHandle(), nullptr, SQLITE_CHECKPOINT_FULL, nullptr, nullptr);
checkIfLogCouldBeCheckpointed(resultCode);
}
void SqliteDatabaseBackend::open(Utils::SmallStringView databaseFilePath, OpenMode mode)
void DatabaseBackend::open(Utils::SmallStringView databaseFilePath, OpenMode mode)
{
checkCanOpenDatabase(databaseFilePath);
@@ -109,13 +109,13 @@ void SqliteDatabaseBackend::open(Utils::SmallStringView databaseFilePath, OpenMo
cacheTextEncoding();
}
sqlite3 *SqliteDatabaseBackend::sqliteDatabaseHandle()
sqlite3 *DatabaseBackend::sqliteDatabaseHandle()
{
checkDatabaseHandleIsNotNull();
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, "'"});
Utils::SmallString pragmeValueInDatabase = toValue<Utils::SmallString>("PRAGMA " + pragmaKey);
@@ -123,56 +123,56 @@ void SqliteDatabaseBackend::setPragmaValue(Utils::SmallStringView pragmaKey, Uti
checkPragmaValue(pragmeValueInDatabase, newPragmaValue);
}
Utils::SmallString SqliteDatabaseBackend::pragmaValue(Utils::SmallStringView pragma)
Utils::SmallString DatabaseBackend::pragmaValue(Utils::SmallStringView pragma)
{
return toValue<Utils::SmallString>("PRAGMA " + pragma);
}
void SqliteDatabaseBackend::setJournalMode(JournalMode journalMode)
void DatabaseBackend::setJournalMode(JournalMode journalMode)
{
setPragmaValue("journal_mode", journalModeToPragma(journalMode));
}
JournalMode SqliteDatabaseBackend::journalMode()
JournalMode DatabaseBackend::journalMode()
{
return pragmaToJournalMode(pragmaValue("journal_mode"));
}
void SqliteDatabaseBackend::setTextEncoding(TextEncoding textEncoding)
void DatabaseBackend::setTextEncoding(TextEncoding textEncoding)
{
setPragmaValue("encoding", textEncodingToPragma(textEncoding));
cacheTextEncoding();
}
TextEncoding SqliteDatabaseBackend::textEncoding()
TextEncoding DatabaseBackend::textEncoding()
{
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();
}
int SqliteDatabaseBackend::changesCount()
int DatabaseBackend::changesCount()
{
return sqlite3_changes(sqliteDatabaseHandle());
}
int SqliteDatabaseBackend::totalChangesCount()
int DatabaseBackend::totalChangesCount()
{
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();
}
void SqliteDatabaseBackend::close()
void DatabaseBackend::close()
{
checkForOpenDatabaseWhichCanBeClosed();
@@ -184,12 +184,12 @@ void SqliteDatabaseBackend::close()
}
bool SqliteDatabaseBackend::databaseIsOpen() const
bool DatabaseBackend::databaseIsOpen() const
{
return m_databaseHandle != nullptr;
}
void SqliteDatabaseBackend::closeWithoutException()
void DatabaseBackend::closeWithoutException()
{
if (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);
}
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_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);
}
int SqliteDatabaseBackend::busyHandlerCallback(void *, int counter)
int DatabaseBackend::busyHandlerCallback(void *, int counter)
{
Q_UNUSED(counter);
#ifdef QT_DEBUG
@@ -222,18 +222,18 @@ int SqliteDatabaseBackend::busyHandlerCallback(void *, int counter)
return true;
}
void SqliteDatabaseBackend::cacheTextEncoding()
void DatabaseBackend::cacheTextEncoding()
{
m_cachedTextEncoding = pragmaToTextEncoding(pragmaValue("encoding"));
}
void SqliteDatabaseBackend::checkForOpenDatabaseWhichCanBeClosed()
void DatabaseBackend::checkForOpenDatabaseWhichCanBeClosed()
{
if (m_databaseHandle == nullptr)
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) {
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())
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())
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) {
case SQLITE_OK:
return;
default:
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)
{
if (databaseValue != expectedValue)
throwException("SqliteDatabaseBackend::setPragmaValue: pragma value is not set!");
}
void SqliteDatabaseBackend::checkDatabaseHandleIsNotNull()
void DatabaseBackend::checkDatabaseHandleIsNotNull()
{
if (m_databaseHandle == nullptr)
throwException("SqliteDatabaseBackend: database is not open!");
}
void SqliteDatabaseBackend::checkIfMultithreadingIsActivated(int resultCode)
void DatabaseBackend::checkIfMultithreadingIsActivated(int resultCode)
{
if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::activateMultiThreading: multithreading can't be activated!");
}
void SqliteDatabaseBackend::checkIfLoogingIsActivated(int resultCode)
void DatabaseBackend::checkIfLoogingIsActivated(int resultCode)
{
if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::activateLogging: logging can't be activated!");
}
void SqliteDatabaseBackend::checkMmapSizeIsSet(int resultCode)
void DatabaseBackend::checkMmapSizeIsSet(int resultCode)
{
if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::checkMmapSizeIsSet: mmap size can't be changed!");
}
void SqliteDatabaseBackend::checkInitializeSqliteLibraryWasSuccesful(int resultCode)
void DatabaseBackend::checkInitializeSqliteLibraryWasSuccesful(int resultCode)
{
if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::initializeSqliteLibrary: SqliteLibrary cannot initialized!");
}
void SqliteDatabaseBackend::checkShutdownSqliteLibraryWasSuccesful(int resultCode)
void DatabaseBackend::checkShutdownSqliteLibraryWasSuccesful(int resultCode)
{
if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::shutdownSqliteLibrary: SqliteLibrary cannot be shutdowned!");
}
void SqliteDatabaseBackend::checkIfLogCouldBeCheckpointed(int resultCode)
void DatabaseBackend::checkIfLogCouldBeCheckpointed(int resultCode)
{
if (resultCode != SQLITE_OK)
throwException("SqliteDatabaseBackend::checkpointFullWalLog: WAL log could not be checkpointed!");
@@ -331,12 +331,12 @@ constexpr const Utils::SmallStringView journalModeStrings[] = {
"wal"
};
Utils::SmallStringView SqliteDatabaseBackend::journalModeToPragma(JournalMode journalMode)
Utils::SmallStringView DatabaseBackend::journalModeToPragma(JournalMode journalMode)
{
return journalModeStrings[int(journalMode)];
}
JournalMode SqliteDatabaseBackend::pragmaToJournalMode(Utils::SmallStringView pragma)
JournalMode DatabaseBackend::pragmaToJournalMode(Utils::SmallStringView pragma)
{
int index = indexOfPragma(pragma, journalModeStrings);
@@ -352,12 +352,12 @@ constexpr const Utils::SmallStringView textEncodingStrings[] = {
"UTF-16be"
};
Utils::SmallStringView SqliteDatabaseBackend::textEncodingToPragma(TextEncoding textEncoding)
Utils::SmallStringView DatabaseBackend::textEncodingToPragma(TextEncoding textEncoding)
{
return textEncodingStrings[textEncoding];
}
TextEncoding SqliteDatabaseBackend::pragmaToTextEncoding(Utils::SmallStringView pragma)
TextEncoding DatabaseBackend::pragmaToTextEncoding(Utils::SmallStringView pragma)
{
int index = indexOfPragma(pragma, textEncodingStrings);
@@ -367,7 +367,7 @@ TextEncoding SqliteDatabaseBackend::pragmaToTextEncoding(Utils::SmallStringView
return static_cast<TextEncoding>(index);
}
int SqliteDatabaseBackend::openMode(OpenMode mode)
int DatabaseBackend::openMode(OpenMode mode)
{
int sqliteMode = SQLITE_OPEN_CREATE;
@@ -379,23 +379,23 @@ int SqliteDatabaseBackend::openMode(OpenMode mode)
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)
throw SqliteException(whatHasHappens, sqlite3_errmsg(m_databaseHandle));
throw Exception(whatHasHappens, sqlite3_errmsg(m_databaseHandle));
else
throw SqliteException(whatHasHappens);
throw Exception(whatHasHappens);
}
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();

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

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

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

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

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

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

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

@@ -34,10 +34,10 @@
namespace Sqlite {
class SqliteIndex
class Index
{
public:
SqliteIndex(Utils::SmallString &&tableName, Utils::SmallStringVector &&columnNames)
Index(Utils::SmallString &&tableName, Utils::SmallStringVector &&columnNames)
: m_tableName(std::move(tableName)),
m_columnNames(std::move(columnNames))
{
@@ -63,13 +63,13 @@ public:
void checkTableName() const
{
if (m_tableName.isEmpty())
throw SqliteException("SqliteIndex has not table name!");
throw Exception("SqliteIndex has not table name!");
}
void checkColumns() const
{
if (m_columnNames.empty())
throw SqliteException("SqliteIndex has no columns!");
throw Exception("SqliteIndex has no columns!");
}
private:
@@ -77,6 +77,6 @@ private:
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 {
SqliteReadStatement::SqliteReadStatement(Utils::SmallStringView sqlStatement,
SqliteDatabase &database)
: SqliteStatement(sqlStatement, database)
ReadStatement::ReadStatement(Utils::SmallStringView sqlStatement,
Database &database)
: Statement(sqlStatement, database)
{
checkIsReadOnlyStatement();
}
void SqliteReadStatement::checkIsReadOnlyStatement()
void ReadStatement::checkIsReadOnlyStatement()
{
if (!isReadOnlyStatement())
throwException("SqliteStatement::SqliteReadStatement: is not read only statement!");

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

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

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

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

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

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

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

@@ -40,7 +40,7 @@
namespace Sqlite {
SqliteStatement::SqliteStatement(Utils::SmallStringView sqlStatement, SqliteDatabase &database)
Statement::Statement(Utils::SmallStringView sqlStatement, Database &database)
: m_compiledStatement(nullptr, deleteCompiledStatement),
m_database(database),
m_bindingParameterCount(0),
@@ -53,7 +53,7 @@ SqliteStatement::SqliteStatement(Utils::SmallStringView sqlStatement, SqliteData
setColumnCount();
}
void SqliteStatement::deleteCompiledStatement(sqlite3_stmt *compiledStatement)
void Statement::deleteCompiledStatement(sqlite3_stmt *compiledStatement)
{
if (compiledStatement)
sqlite3_finalize(compiledStatement);
@@ -92,7 +92,7 @@ private:
std::mutex m_mutex;
};
void SqliteStatement::waitForUnlockNotify() const
void Statement::waitForUnlockNotify() const
{
UnlockNotification 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!");
}
void SqliteStatement::reset() const
void Statement::reset() const
{
int resultCode = sqlite3_reset(m_compiledStatement.get());
if (resultCode != SQLITE_OK)
@@ -112,7 +112,7 @@ void SqliteStatement::reset() const
m_isReadyToFetchValues = false;
}
bool SqliteStatement::next() const
bool Statement::next() const
{
int resultCode;
@@ -130,26 +130,26 @@ bool SqliteStatement::next() const
return checkForStepError(resultCode);
}
void SqliteStatement::step() const
void Statement::step() const
{
next();
}
void SqliteStatement::execute() const
void Statement::execute() const
{
next();
reset();
}
int SqliteStatement::columnCount() const
int Statement::columnCount() const
{
return m_columnCount;
}
Utils::SmallStringVector SqliteStatement::columnNames() const
Utils::SmallStringVector Statement::columnNames() const
{
Utils::SmallStringVector columnNames;
int columnCount = SqliteStatement::columnCount();
int columnCount = Statement::columnCount();
columnNames.reserve(std::size_t(columnCount));
for (int columnIndex = 0; columnIndex < columnCount; columnIndex++)
columnNames.emplace_back(sqlite3_column_origin_name(m_compiledStatement.get(), columnIndex));
@@ -157,28 +157,28 @@ Utils::SmallStringVector SqliteStatement::columnNames() const
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);
if (resultCode != SQLITE_OK)
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);
if (resultCode != SQLITE_OK)
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);
if (resultCode != SQLITE_OK)
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);
if (resultCode != SQLITE_OK)
@@ -186,35 +186,35 @@ void SqliteStatement::bind(int index, Utils::SmallStringView text)
}
template <typename Type>
void SqliteStatement::bind(Utils::SmallStringView name, Type value)
void Statement::bind(Utils::SmallStringView name, Type value)
{
int index = bindingIndexForName(name);
checkBindingName(index);
bind(index, value);
}
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, int value);
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, long value);
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, long long value);
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, double value);
template SQLITE_EXPORT void SqliteStatement::bind(Utils::SmallStringView name, Utils::SmallStringView text);
template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, int value);
template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, long value);
template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, long long value);
template SQLITE_EXPORT void Statement::bind(Utils::SmallStringView name, double value);
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());
}
void SqliteStatement::setBindingColumnNames(const Utils::SmallStringVector &bindingColumnNames)
void Statement::setBindingColumnNames(const Utils::SmallStringVector &bindingColumnNames)
{
m_bindingColumnNames = bindingColumnNames;
}
const Utils::SmallStringVector &SqliteStatement::bindingColumnNames() const
const Utils::SmallStringVector &Statement::bindingColumnNames() const
{
return m_bindingColumnNames;
}
void SqliteStatement::prepare(Utils::SmallStringView sqlStatement)
void Statement::prepare(Utils::SmallStringView sqlStatement)
{
int resultCode;
@@ -235,17 +235,17 @@ void SqliteStatement::prepare(Utils::SmallStringView sqlStatement)
checkForPrepareError(resultCode);
}
sqlite3 *SqliteStatement::sqliteDatabaseHandle() const
sqlite3 *Statement::sqliteDatabaseHandle() const
{
return m_database.backend().sqliteDatabaseHandle();
}
TextEncoding SqliteStatement::databaseTextEncoding()
TextEncoding Statement::databaseTextEncoding()
{
return m_database.backend().textEncoding();
}
bool SqliteStatement::checkForStepError(int resultCode) const
bool Statement::checkForStepError(int resultCode) const
{
switch (resultCode) {
case SQLITE_ROW: return true;
@@ -261,7 +261,7 @@ bool SqliteStatement::checkForStepError(int resultCode) const
Q_UNREACHABLE();
}
void SqliteStatement::checkForPrepareError(int resultCode) const
void Statement::checkForPrepareError(int resultCode) const
{
switch (resultCode) {
case SQLITE_OK: return;
@@ -273,7 +273,7 @@ void SqliteStatement::checkForPrepareError(int resultCode) const
throwException("SqliteStatement::prepareStatement: unknown error has happened");
}
void SqliteStatement::setIfIsReadyToFetchValues(int resultCode) const
void Statement::setIfIsReadyToFetchValues(int resultCode) const
{
if (resultCode == SQLITE_ROW)
m_isReadyToFetchValues = true;
@@ -282,13 +282,13 @@ void SqliteStatement::setIfIsReadyToFetchValues(int resultCode) const
}
void SqliteStatement::checkIfIsReadyToFetchValues() const
void Statement::checkIfIsReadyToFetchValues() const
{
if (!m_isReadyToFetchValues)
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) {
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)
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)
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)
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());
}
@@ -327,7 +327,7 @@ Utils::SmallStringView chopFirstLetter(const char *rawBindingName)
return Utils::SmallStringView("");
}
void SqliteStatement::setBindingColumnNamesFromStatement()
void Statement::setBindingColumnNamesFromStatement()
{
for (int index = 1; index <= m_bindingParameterCount; 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());
}
bool SqliteStatement::isReadOnlyStatement() const
bool Statement::isReadOnlyStatement() const
{
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));
}
SqliteDatabase &SqliteStatement::database() const
Database &Statement::database() const
{
return m_database;
}
@@ -385,7 +385,7 @@ static StringType convertToTextForColumn(sqlite3_stmt *sqlStatment, int column)
}
template<>
int SqliteStatement::value<int>(int column) const
int Statement::value<int>(int column) const
{
checkIfIsReadyToFetchValues();
checkColumnIsValid(column);
@@ -393,13 +393,13 @@ int SqliteStatement::value<int>(int column) const
}
template<>
long SqliteStatement::value<long>(int column) const
long Statement::value<long>(int column) const
{
return long(value<long long>(column));
}
template<>
long long SqliteStatement::value<long long>(int column) const
long long Statement::value<long long>(int column) const
{
checkIfIsReadyToFetchValues();
checkColumnIsValid(column);
@@ -407,7 +407,7 @@ long long SqliteStatement::value<long long>(int column) const
}
template<>
double SqliteStatement::value<double>(int column) const
double Statement::value<double>(int column) const
{
checkIfIsReadyToFetchValues();
checkColumnIsValid(column);
@@ -415,23 +415,23 @@ double SqliteStatement::value<double>(int column) const
}
template<typename StringType>
StringType SqliteStatement::value(int column) const
StringType Statement::value(int column) const
{
checkIfIsReadyToFetchValues();
checkColumnIsValid(column);
return convertToTextForColumn<StringType>(m_compiledStatement.get(), column);
}
template SQLITE_EXPORT Utils::SmallString SqliteStatement::value<Utils::SmallString>(int column) const;
template SQLITE_EXPORT Utils::PathString SqliteStatement::value<Utils::PathString>(int column) const;
template SQLITE_EXPORT Utils::SmallString Statement::value<Utils::SmallString>(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);
}
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;
ContainerType valueContainer;
@@ -443,18 +443,18 @@ ContainerType SqliteStatement::columnValues(const std::vector<int> &columnIndice
}
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();
return statement.value<Type>(0);
}
template SQLITE_EXPORT int SqliteStatement::toValue<int>(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
template SQLITE_EXPORT long long SqliteStatement::toValue<long long>(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
template SQLITE_EXPORT double SqliteStatement::toValue<double>(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
template SQLITE_EXPORT Utils::SmallString SqliteStatement::toValue<Utils::SmallString>(Utils::SmallStringView sqlStatement, SqliteDatabase &database);
template SQLITE_EXPORT int Statement::toValue<int>(Utils::SmallStringView sqlStatement, Database &database);
template SQLITE_EXPORT long long Statement::toValue<long long>(Utils::SmallStringView sqlStatement, Database &database);
template SQLITE_EXPORT double Statement::toValue<double>(Utils::SmallStringView sqlStatement, Database &database);
template SQLITE_EXPORT Utils::SmallString Statement::toValue<Utils::SmallString>(Utils::SmallStringView sqlStatement, Database &database);
} // namespace Sqlite

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -43,9 +43,9 @@ namespace ClangBackEnd {
class SymbolIndexing final : public SymbolIndexingInterface
{
public:
using StatementFactory = ClangBackEnd::StorageSqliteStatementFactory<Sqlite::SqliteDatabase,
Sqlite::SqliteReadStatement,
Sqlite::SqliteWriteStatement>;
using StatementFactory = ClangBackEnd::StorageSqliteStatementFactory<Sqlite::Database,
Sqlite::ReadStatement,
Sqlite::WriteStatement>;
using Storage = ClangBackEnd::SymbolStorage<StatementFactory>;
SymbolIndexing(FilePathCache<std::mutex> &filePathCache,
@@ -61,7 +61,7 @@ public:
return m_indexer;
}
Sqlite::SqliteDatabase &database()
Sqlite::Database &database()
{
return m_database;
}
@@ -74,7 +74,7 @@ public:
private:
FilePathCache<std::mutex> &m_filePathCache;
Sqlite::SqliteDatabase m_database;
Sqlite::Database m_database;
SymbolsCollector m_collector{m_filePathCache};
StatementFactory m_statementFactory{m_database};
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>
class SymbolStorage : public SymbolStorageInterface
{
using Transaction = Sqlite::SqliteImmediateTransaction<typename StatementFactory::DatabaseType>;
using Transaction = Sqlite::ImmediateTransaction<typename StatementFactory::DatabaseType>;
using ReadStatement = typename StatementFactory::ReadStatementType;
using WriteStatement = typename StatementFactory::WriteStatementType;
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::JournalMode;
using Sqlite::OpenMode;
using Sqlite::SqliteColumn;
using Sqlite::Column;
using Sqlite::SqliteColumns;
using Sqlite::SqlStatementBuilderException;

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

@@ -37,7 +37,7 @@ using Sqlite::ColumnType;
using Sqlite::Contraint;
using Sqlite::JournalMode;
using Sqlite::OpenMode;
using Column = Sqlite::SqliteColumn;
using Column = Sqlite::Column;
using Sqlite::SqliteColumns;
class SqliteColumn : public ::testing::Test
@@ -45,7 +45,7 @@ class SqliteColumn : public ::testing::Test
protected:
void SetUp() override;
Sqlite::SqliteColumn column;
Sqlite::Column column;
};
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::JournalMode;
using Sqlite::OpenMode;
using Sqlite::SqliteTable;
using Sqlite::Table;
class SqliteDatabase : public ::testing::Test
{
@@ -51,7 +51,7 @@ protected:
SpyDummy spyDummy;
QString databaseFilePath = QStringLiteral(":memory:");
Sqlite::SqliteDatabase database;
Sqlite::Database database;
};
TEST_F(SqliteDatabase, SetDatabaseFilePath)

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

@@ -36,15 +36,15 @@
namespace {
using Backend = Sqlite::SqliteDatabaseBackend;
using Backend = Sqlite::DatabaseBackend;
using Sqlite::ColumnType;
using Sqlite::Contraint;
using Sqlite::JournalMode;
using Sqlite::OpenMode;
using Sqlite::TextEncoding;
using Sqlite::SqliteException;
using Sqlite::SqliteWriteStatement;
using Sqlite::Exception;
using Sqlite::WriteStatement;
class SqliteDatabaseBackend : public ::testing::Test
{
@@ -53,27 +53,27 @@ protected:
void TearDown() override;
Utils::PathString databaseFilePath = QDir::tempPath() + "/SqliteDatabaseBackendTest.db";
Sqlite::SqliteDatabase database;
Sqlite::SqliteDatabaseBackend &databaseBackend = database.backend();
Sqlite::Database database;
Sqlite::DatabaseBackend &databaseBackend = database.backend();
};
using SqliteDatabaseBackendSlowTest = SqliteDatabaseBackend;
TEST_F(SqliteDatabaseBackend, OpenAlreadyOpenDatabase)
{
ASSERT_THROW(databaseBackend.open(databaseFilePath, OpenMode::ReadWrite), SqliteException);
ASSERT_THROW(databaseBackend.open(databaseFilePath, OpenMode::ReadWrite), Exception);
}
TEST_F(SqliteDatabaseBackend, CloseAlreadyClosedDatabase)
{
databaseBackend.close();
ASSERT_THROW(databaseBackend.close(), SqliteException);
ASSERT_THROW(databaseBackend.close(), Exception);
}
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)
@@ -148,7 +148,7 @@ TEST_F(SqliteDatabaseBackend, TextEncodingCannotBeChangedAfterTouchingDatabase)
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)

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

@@ -29,38 +29,38 @@
namespace {
using Sqlite::SqliteException;
using Sqlite::SqliteIndex;
using Sqlite::Exception;
using Sqlite::Index;
TEST(SqliteIndex, OneColumn)
TEST(Index, OneColumn)
{
SqliteIndex index{"tableName", {"column1"}};
Index index{"tableName", {"column1"}};
auto sqlStatement = index.sqlStatement();
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();
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 {
using Sqlite::JournalMode;
using Sqlite::SqliteException;
using Sqlite::SqliteDatabase;
using Sqlite::SqliteReadStatement;
using Sqlite::SqliteReadWriteStatement;
using Sqlite::SqliteWriteStatement;
using Sqlite::Exception;
using Sqlite::Database;
using Sqlite::ReadStatement;
using Sqlite::ReadWriteStatement;
using Sqlite::WriteStatement;
MATCHER_P3(HasValues, value1, value2, rowid,
std::string(negation ? "isn't" : "is")
@@ -52,9 +52,9 @@ MATCHER_P3(HasValues, value1, value2, 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.next();
@@ -69,7 +69,7 @@ protected:
void TearDown() override;
protected:
SqliteDatabase database;
Database database;
};
struct Output
@@ -89,27 +89,27 @@ struct Output
TEST_F(SqliteStatement, PrepareFailure)
{
ASSERT_THROW(SqliteReadStatement("blah blah blah", database), SqliteException);
ASSERT_THROW(SqliteWriteStatement("blah blah blah", database), SqliteException);
ASSERT_THROW(SqliteReadStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), SqliteException);
ASSERT_THROW(SqliteWriteStatement("SELECT name, number FROM test '", database), SqliteException);
ASSERT_THROW(ReadStatement("blah blah blah", database), Exception);
ASSERT_THROW(WriteStatement("blah blah blah", database), Exception);
ASSERT_THROW(ReadStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), Exception);
ASSERT_THROW(WriteStatement("SELECT name, number FROM test '", database), Exception);
}
TEST_F(SqliteStatement, CountRows)
{
SqliteReadStatement statement("SELECT * FROM test", database);
ReadStatement statement("SELECT * FROM test", database);
int nextCount = 0;
while (statement.next())
++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);
}
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();
@@ -126,46 +126,46 @@ TEST_F(SqliteStatement, Value)
TEST_F(SqliteStatement, ValueFailure)
{
SqliteReadStatement statement("SELECT name, number FROM test", database);
ASSERT_THROW(statement.value<int>(0), SqliteException);
ReadStatement statement("SELECT name, number FROM test", database);
ASSERT_THROW(statement.value<int>(0), Exception);
statement.reset();
while (statement.next()) {}
ASSERT_THROW(statement.value<int>(0), SqliteException);
ASSERT_THROW(statement.value<int>(0), Exception);
statement.reset();
statement.next();
ASSERT_THROW(statement.value<int>(-1), SqliteException);
ASSERT_THROW(statement.value<int>(2), SqliteException);
ASSERT_THROW(statement.value<int>(-1), Exception);
ASSERT_THROW(statement.value<int>(2), Exception);
}
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);
}
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)
{
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)
{
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)
{
SqliteReadStatement statement("SELECT name, number FROM test", database);
ReadStatement statement("SELECT name, number FROM test", database);
auto columnNames = statement.columnNames();
@@ -175,7 +175,7 @@ TEST_F(SqliteStatement, ColumnNames)
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");
@@ -187,7 +187,7 @@ TEST_F(SqliteStatement, BindString)
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.next();
@@ -197,7 +197,7 @@ TEST_F(SqliteStatement, BindInteger)
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.next();
@@ -207,7 +207,7 @@ TEST_F(SqliteStatement, BindLongInteger)
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.next();
@@ -217,7 +217,7 @@ TEST_F(SqliteStatement, BindDouble)
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.next();
@@ -227,7 +227,7 @@ TEST_F(SqliteStatement, BindIntegerByParameter)
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.next();
@@ -237,7 +237,7 @@ TEST_F(SqliteStatement, BindLongIntegerByParameter)
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.next();
@@ -247,23 +247,23 @@ TEST_F(SqliteStatement, BindDoubleByIndex)
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(2, 40), SqliteException);
ASSERT_THROW(statement.bind("@name", 40), SqliteException);
ASSERT_THROW(statement.bind(0, 40), Exception);
ASSERT_THROW(statement.bind(2, 40), Exception);
ASSERT_THROW(statement.bind("@name", 40), Exception);
}
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"));
}
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.execute();
@@ -273,7 +273,7 @@ TEST_F(SqliteStatement, BindValues)
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);
@@ -282,7 +282,7 @@ TEST_F(SqliteStatement, WriteValues)
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.execute();
@@ -292,7 +292,7 @@ TEST_F(SqliteStatement, BindNamedValues)
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);
@@ -302,16 +302,16 @@ TEST_F(SqliteStatement, WriteNamedValues)
TEST_F(SqliteStatement, ClosedDatabase)
{
database.close();
ASSERT_THROW(SqliteWriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), SqliteException);
ASSERT_THROW(SqliteReadStatement("SELECT * FROM test", database), SqliteException);
ASSERT_THROW(SqliteReadWriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), SqliteException);
ASSERT_THROW(WriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), Exception);
ASSERT_THROW(ReadStatement("SELECT * FROM test", database), Exception);
ASSERT_THROW(ReadWriteStatement("INSERT INTO test(name, number) VALUES (?, ?)", database), Exception);
database.open(QDir::tempPath() + QStringLiteral("/SqliteStatementTest.db"));
}
TEST_F(SqliteStatement, GetTupleValuesWithoutArguments)
{
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);
@@ -322,7 +322,7 @@ TEST_F(SqliteStatement, GetTupleValuesWithoutArguments)
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);
@@ -331,7 +331,7 @@ TEST_F(SqliteStatement, GetSingleValuesWithoutArguments)
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);
@@ -342,7 +342,7 @@ TEST_F(SqliteStatement, GetStructValuesWithoutArguments)
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);
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>;
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);
@@ -365,7 +365,7 @@ TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndContainerQueryValues)
TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryValues)
{
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);
@@ -377,7 +377,7 @@ TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndContainerQueryTupleVa
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, int>;
using Tuple2 = std::tuple<Utils::SmallString, double, int>;
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);
@@ -389,7 +389,7 @@ TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryTupleValu
{
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString>;
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);
@@ -399,7 +399,7 @@ TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryTupleValu
TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndMultipleQueryValue)
{
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);
@@ -409,7 +409,7 @@ TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndMultipleQueryValue)
TEST_F(SqliteStatement, CallGetValuesForMultipleOutputValuesAndMultipleQueryValueMultipleTimes)
{
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");
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)
{
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);
@@ -429,7 +429,7 @@ TEST_F(SqliteStatement, GetStructOutputValuesAndMultipleQueryValue)
TEST_F(SqliteStatement, GetStructOutputValuesAndContainerQueryValues)
{
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);
@@ -441,7 +441,7 @@ TEST_F(SqliteStatement, GetStructOutputValuesAndContainerQueryTupleValues)
{
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, int>;
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);

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

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

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

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

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

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

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

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

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

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