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