diff --git a/src/libs/sqlite/sqlitedatabase.cpp b/src/libs/sqlite/sqlitedatabase.cpp index 14068712ce1..f36d14e73da 100644 --- a/src/libs/sqlite/sqlitedatabase.cpp +++ b/src/libs/sqlite/sqlitedatabase.cpp @@ -41,16 +41,22 @@ SqliteDatabase::~SqliteDatabase() void SqliteDatabase::open() { - m_sqliteDatabaseBackEnd.open(m_databaseFilePath); - m_sqliteDatabaseBackEnd.setJournalMode(journalMode()); + m_databaseBackend.open(m_databaseFilePath); + m_databaseBackend.setJournalMode(journalMode()); initializeTables(); m_isOpen = true; } +void SqliteDatabase::open(const QString &databaseFilePath) +{ + setDatabaseFilePath(databaseFilePath); + open(); +} + void SqliteDatabase::close() { m_isOpen = false; - m_sqliteDatabaseBackEnd.close(); + m_databaseBackend.close(); } bool SqliteDatabase::isOpen() const @@ -89,10 +95,25 @@ JournalMode SqliteDatabase::journalMode() const return m_journalMode; } +int SqliteDatabase::changesCount() +{ + return m_databaseBackend.changesCount(); +} + +int SqliteDatabase::totalChangesCount() +{ + return m_databaseBackend.totalChangesCount(); +} + void SqliteDatabase::initializeTables() { for (SqliteTable *table: tables()) table->initialize(); } +SqliteDatabaseBackend &SqliteDatabase::backend() +{ + return m_databaseBackend; +} + } // namespace Sqlite diff --git a/src/libs/sqlite/sqlitedatabase.h b/src/libs/sqlite/sqlitedatabase.h index 88c4f53a5ef..ca24e98fc06 100644 --- a/src/libs/sqlite/sqlitedatabase.h +++ b/src/libs/sqlite/sqlitedatabase.h @@ -34,14 +34,19 @@ namespace Sqlite { class SqliteTable; +class SqliteDatabaseBackend; class SQLITE_EXPORT SqliteDatabase { + friend class SqliteAbstractTransaction; + friend class SqliteStatement; + public: SqliteDatabase(); ~SqliteDatabase(); void open(); + void open(const QString &databaseFilePath); void close(); bool isOpen() const; @@ -55,12 +60,16 @@ public: void setJournalMode(JournalMode journalMode); JournalMode journalMode() const; + int changesCount(); + int totalChangesCount(); private: void initializeTables(); + SqliteDatabaseBackend &backend(); + private: - SqliteDatabaseBackend m_sqliteDatabaseBackEnd; + SqliteDatabaseBackend m_databaseBackend; QVector m_sqliteTables; QString m_databaseFilePath; JournalMode m_journalMode; diff --git a/src/libs/sqlite/sqlitedatabasebackend.cpp b/src/libs/sqlite/sqlitedatabasebackend.cpp index a3b8a56a67a..f31ccc766aa 100644 --- a/src/libs/sqlite/sqlitedatabasebackend.cpp +++ b/src/libs/sqlite/sqlitedatabasebackend.cpp @@ -48,19 +48,15 @@ namespace Sqlite { -QTC_THREAD_LOCAL SqliteDatabaseBackend *sqliteDatabaseBackend = nullptr; - SqliteDatabaseBackend::SqliteDatabaseBackend() : m_databaseHandle(nullptr), m_cachedTextEncoding(Utf8) { - sqliteDatabaseBackend = this; } SqliteDatabaseBackend::~SqliteDatabaseBackend() { closeWithoutException(); - sqliteDatabaseBackend = nullptr; } void SqliteDatabaseBackend::setMmapSize(qint64 defaultSize, qint64 maximumSize) @@ -123,22 +119,22 @@ void SqliteDatabaseBackend::open(const QString &databaseFilePath) sqlite3 *SqliteDatabaseBackend::sqliteDatabaseHandle() { - checkDatabaseBackendIsNotNull(); checkDatabaseHandleIsNotNull(); - return threadLocalInstance()->m_databaseHandle; + return m_databaseHandle; } void SqliteDatabaseBackend::setPragmaValue(const Utf8String &pragmaKey, const Utf8String &newPragmaValue) { - SqliteReadWriteStatement::execute(Utf8StringLiteral("PRAGMA ") + pragmaKey + Utf8StringLiteral("='") + newPragmaValue + Utf8StringLiteral("'")); - Utf8String pragmeValueInDatabase = SqliteReadWriteStatement::toValue(Utf8StringLiteral("PRAGMA ") + pragmaKey); + SqliteReadWriteStatement statement(Utf8StringLiteral("PRAGMA ") + pragmaKey + Utf8StringLiteral("='") + newPragmaValue + Utf8StringLiteral("'"), *this); + statement.step(); + Utf8String pragmeValueInDatabase = toValue(Utf8StringLiteral("PRAGMA ") + pragmaKey); checkPragmaValue(pragmeValueInDatabase, newPragmaValue); } -Utf8String SqliteDatabaseBackend::pragmaValue(const Utf8String &pragma) const +Utf8String SqliteDatabaseBackend::pragmaValue(const Utf8String &pragma) { - return SqliteReadWriteStatement::toValue(Utf8StringLiteral("PRAGMA ") + pragma); + return toValue(Utf8StringLiteral("PRAGMA ") + pragma); } void SqliteDatabaseBackend::setJournalMode(JournalMode journalMode) @@ -146,7 +142,7 @@ void SqliteDatabaseBackend::setJournalMode(JournalMode journalMode) setPragmaValue(Utf8StringLiteral("journal_mode"), journalModeToPragma(journalMode)); } -JournalMode SqliteDatabaseBackend::journalMode() const +JournalMode SqliteDatabaseBackend::journalMode() { return pragmaToJournalMode(pragmaValue(Utf8StringLiteral("journal_mode"))); } @@ -165,7 +161,7 @@ TextEncoding SqliteDatabaseBackend::textEncoding() Utf8StringVector SqliteDatabaseBackend::columnNames(const Utf8String &tableName) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT * FROM ") + tableName); + SqliteReadWriteStatement statement(Utf8StringLiteral("SELECT * FROM ") + tableName, *this); return statement.columnNames(); } @@ -179,6 +175,12 @@ int SqliteDatabaseBackend::totalChangesCount() return sqlite3_total_changes(sqliteDatabaseHandle()); } +void SqliteDatabaseBackend::execute(const Utf8String &sqlStatementUtf8) +{ + SqliteReadWriteStatement statement(sqlStatementUtf8, *this); + statement.step(); +} + void SqliteDatabaseBackend::close() { checkForOpenDatabaseWhichCanBeClosed(); @@ -191,12 +193,6 @@ void SqliteDatabaseBackend::close() } -SqliteDatabaseBackend *SqliteDatabaseBackend::threadLocalInstance() -{ - checkDatabaseBackendIsNotNull(); - return sqliteDatabaseBackend; -} - bool SqliteDatabaseBackend::databaseIsOpen() const { return m_databaseHandle != nullptr; @@ -282,16 +278,10 @@ void SqliteDatabaseBackend::checkPragmaValue(const Utf8String &databaseValue, co void SqliteDatabaseBackend::checkDatabaseHandleIsNotNull() { - if (sqliteDatabaseBackend->m_databaseHandle == nullptr) + if (m_databaseHandle == nullptr) throwException("SqliteDatabaseBackend: database is not open!"); } -void SqliteDatabaseBackend::checkDatabaseBackendIsNotNull() -{ - if (sqliteDatabaseBackend == nullptr) - throwException("SqliteDatabaseBackend: database backend is not initialized!"); -} - void SqliteDatabaseBackend::checkIfMultithreadingIsActivated(int resultCode) { if (resultCode != SQLITE_OK) @@ -357,7 +347,7 @@ JournalMode SqliteDatabaseBackend::pragmaToJournalMode(const Utf8String &pragma) int index = indexOfPragma(pragma, journalModeStrings, SIZE_OF_BYTEARRAY_ARRAY(journalModeStrings)); if (index < 0) - throwException("SqliteDatabaseBackend::pragmaToJournalMode: pragma can't be transformed in a journal mode enumeration!"); + throwExceptionStatic("SqliteDatabaseBackend::pragmaToJournalMode: pragma can't be transformed in a journal mode enumeration!"); return static_cast(index); } @@ -378,17 +368,32 @@ TextEncoding SqliteDatabaseBackend::pragmaToTextEncoding(const Utf8String &pragm int index = indexOfPragma(pragma, textEncodingStrings, SIZE_OF_BYTEARRAY_ARRAY(textEncodingStrings)); if (index < 0) - throwException("SqliteDatabaseBackend::pragmaToTextEncoding: pragma can't be transformed in a text encoding enumeration!"); + throwExceptionStatic("SqliteDatabaseBackend::pragmaToTextEncoding: pragma can't be transformed in a text encoding enumeration!"); return static_cast(index); } -void SqliteDatabaseBackend::throwException(const char *whatHasHappens) +void SqliteDatabaseBackend::throwExceptionStatic(const char *whatHasHappens) { - if (sqliteDatabaseBackend && sqliteDatabaseBackend->m_databaseHandle) - throw SqliteException(whatHasHappens, sqlite3_errmsg(sqliteDatabaseBackend->m_databaseHandle)); + throw SqliteException(whatHasHappens); +} + +void SqliteDatabaseBackend::throwException(const char *whatHasHappens) const +{ + if (m_databaseHandle) + throw SqliteException(whatHasHappens, sqlite3_errmsg(m_databaseHandle)); else throw SqliteException(whatHasHappens); } +template +Type SqliteDatabaseBackend::toValue(const Utf8String &sqlStatementUtf8) +{ + SqliteReadWriteStatement statement(sqlStatementUtf8, *this); + + statement.next(); + + return statement.value(0); +} + } // namespace Sqlite diff --git a/src/libs/sqlite/sqlitedatabasebackend.h b/src/libs/sqlite/sqlitedatabasebackend.h index f9a76228447..ae0944f9292 100644 --- a/src/libs/sqlite/sqlitedatabasebackend.h +++ b/src/libs/sqlite/sqlitedatabasebackend.h @@ -42,38 +42,42 @@ public: SqliteDatabaseBackend(); ~SqliteDatabaseBackend(); - static void setMmapSize(qint64 defaultSize, qint64 maximumSize); - static void activateMultiThreading(); - static void activateLogging(); - static void initializeSqliteLibrary(); - static void shutdownSqliteLibrary(); - static void checkpointFullWalLog(); + void setMmapSize(qint64 defaultSize, qint64 maximumSize); + void activateMultiThreading(); + void activateLogging(); + void initializeSqliteLibrary(); + void shutdownSqliteLibrary(); + void checkpointFullWalLog(); void open(const QString &databaseFilePath); void close(); void closeWithoutException(); - static SqliteDatabaseBackend *threadLocalInstance(); - static sqlite3* sqliteDatabaseHandle(); + sqlite3* sqliteDatabaseHandle(); void setJournalMode(JournalMode journalMode); - JournalMode journalMode() const; + JournalMode journalMode(); void setTextEncoding(TextEncoding textEncoding); TextEncoding textEncoding(); - static Utf8StringVector columnNames(const Utf8String &tableName); + Utf8StringVector columnNames(const Utf8String &tableName); - static int changesCount(); - static int totalChangesCount(); + int changesCount(); + int totalChangesCount(); + + void execute(const Utf8String &sqlStatementUtf8); + + template + Type toValue(const Utf8String &sqlStatementUtf8); protected: bool databaseIsOpen() const; void setPragmaValue(const Utf8String &pragma, const Utf8String &value); - Utf8String pragmaValue(const Utf8String &pragma) const; + Utf8String pragmaValue(const Utf8String &pragma); void registerBusyHandler(); void registerRankingFunction(); @@ -86,22 +90,22 @@ protected: void checkCanOpenDatabase(const QString &databaseFilePath); void checkDatabaseCouldBeOpened(int resultCode); void checkPragmaValue(const Utf8String &databaseValue, const Utf8String &expectedValue); - static void checkDatabaseHandleIsNotNull(); - static void checkDatabaseBackendIsNotNull(); - static void checkIfMultithreadingIsActivated(int resultCode); - static void checkIfLoogingIsActivated(int resultCode); - static void checkMmapSizeIsSet(int resultCode); - static void checkInitializeSqliteLibraryWasSuccesful(int resultCode); - static void checkShutdownSqliteLibraryWasSuccesful(int resultCode); - static void checkIfLogCouldBeCheckpointed(int resultCode); + void checkDatabaseHandleIsNotNull(); + void checkIfMultithreadingIsActivated(int resultCode); + void checkIfLoogingIsActivated(int resultCode); + void checkMmapSizeIsSet(int resultCode); + void checkInitializeSqliteLibraryWasSuccesful(int resultCode); + void checkShutdownSqliteLibraryWasSuccesful(int resultCode); + void checkIfLogCouldBeCheckpointed(int resultCode); static int indexOfPragma(const Utf8String pragma, const Utf8String pragmas[], size_t pragmaCount); static const Utf8String &journalModeToPragma(JournalMode journalMode); static JournalMode pragmaToJournalMode(const Utf8String &pragma); - static const Utf8String &textEncodingToPragma(TextEncoding textEncoding); + const Utf8String &textEncodingToPragma(TextEncoding textEncoding); static TextEncoding pragmaToTextEncoding(const Utf8String &pragma); - Q_NORETURN static void throwException(const char *whatHasHappens); + Q_NORETURN static void throwExceptionStatic(const char *whatHasHappens); + Q_NORETURN void throwException(const char *whatHasHappens) const; private: sqlite3 *m_databaseHandle; diff --git a/src/libs/sqlite/sqlitereadstatement.cpp b/src/libs/sqlite/sqlitereadstatement.cpp index 03e17f548cd..18bc8b6a2b7 100644 --- a/src/libs/sqlite/sqlitereadstatement.cpp +++ b/src/libs/sqlite/sqlitereadstatement.cpp @@ -29,8 +29,9 @@ namespace Sqlite { -SqliteReadStatement::SqliteReadStatement(const Utf8String &sqlStatementUtf8) - : SqliteStatement(sqlStatementUtf8) +SqliteReadStatement::SqliteReadStatement(const Utf8String &sqlStatementUtf8, + SqliteDatabase &database) + : SqliteStatement(sqlStatementUtf8, database) { checkIsReadOnlyStatement(); } diff --git a/src/libs/sqlite/sqlitereadstatement.h b/src/libs/sqlite/sqlitereadstatement.h index 97bba0e3ece..3795e5cf25f 100644 --- a/src/libs/sqlite/sqlitereadstatement.h +++ b/src/libs/sqlite/sqlitereadstatement.h @@ -32,7 +32,7 @@ namespace Sqlite { class SQLITE_EXPORT SqliteReadStatement final : private SqliteStatement { public: - explicit SqliteReadStatement(const Utf8String &sqlStatementUtf8); + explicit SqliteReadStatement(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); using SqliteStatement::next; using SqliteStatement::reset; diff --git a/src/libs/sqlite/sqlitereadwritestatement.cpp b/src/libs/sqlite/sqlitereadwritestatement.cpp index ec39b54193d..cf88143d9ea 100644 --- a/src/libs/sqlite/sqlitereadwritestatement.cpp +++ b/src/libs/sqlite/sqlitereadwritestatement.cpp @@ -27,8 +27,15 @@ namespace Sqlite { -SqliteReadWriteStatement::SqliteReadWriteStatement(const Utf8String &sqlStatementUft8) - : SqliteStatement(sqlStatementUft8) +SqliteReadWriteStatement::SqliteReadWriteStatement(const Utf8String &sqlStatementUft8, + SqliteDatabase &database) + : SqliteStatement(sqlStatementUft8, database) +{ +} + +SqliteReadWriteStatement::SqliteReadWriteStatement(const Utf8String &sqlStatementUft8, + SqliteDatabaseBackend &backend) + : SqliteStatement(sqlStatementUft8, backend) { } diff --git a/src/libs/sqlite/sqlitereadwritestatement.h b/src/libs/sqlite/sqlitereadwritestatement.h index 27d7b17d610..9d644fbaf2d 100644 --- a/src/libs/sqlite/sqlitereadwritestatement.h +++ b/src/libs/sqlite/sqlitereadwritestatement.h @@ -31,8 +31,10 @@ namespace Sqlite { class SQLITE_EXPORT SqliteReadWriteStatement final : private SqliteStatement { + friend class SqliteDatabaseBackend; + public: - explicit SqliteReadWriteStatement(const Utf8String &sqlStatementUft8); + explicit SqliteReadWriteStatement(const Utf8String &sqlStatementUft8, SqliteDatabase &database); using SqliteStatement::next; using SqliteStatement::step; @@ -48,7 +50,10 @@ public: using SqliteStatement::columnCount; using SqliteStatement::columnNames; using SqliteStatement::toValue; - using SqliteStatement::execute; + +private: + explicit SqliteReadWriteStatement(const Utf8String &sqlStatementUft8, + SqliteDatabaseBackend &backend); }; } // namespace Sqlite diff --git a/src/libs/sqlite/sqlitestatement.cpp b/src/libs/sqlite/sqlitestatement.cpp index fa4aa474f3a..d0fb886c14e 100644 --- a/src/libs/sqlite/sqlitestatement.cpp +++ b/src/libs/sqlite/sqlitestatement.cpp @@ -25,6 +25,7 @@ #include "sqlitestatement.h" +#include "sqlitedatabase.h" #include "sqlitedatabasebackend.h" #include "sqliteexception.h" @@ -41,8 +42,15 @@ namespace Sqlite { -SqliteStatement::SqliteStatement(const Utf8String &sqlStatementUtf8) +SqliteStatement::SqliteStatement(const Utf8String &sqlStatementUtf8, SqliteDatabase &database) + : SqliteStatement(sqlStatementUtf8, database.backend()) +{ + +} + +SqliteStatement::SqliteStatement(const Utf8String &sqlStatementUtf8, SqliteDatabaseBackend &databaseBackend) : m_compiledStatement(nullptr, deleteCompiledStatement), + m_databaseBackend(databaseBackend), m_bindingParameterCount(0), m_columnCount(0), m_isReadyToFetchValues(false) @@ -295,12 +303,6 @@ const Utf8StringVector &SqliteStatement::bindingColumnNames() const return m_bindingColumnNames; } -void SqliteStatement::execute(const Utf8String &sqlStatementUtf8) -{ - SqliteStatement statement(sqlStatementUtf8); - statement.step(); -} - void SqliteStatement::prepare(const Utf8String &sqlStatementUtf8) { int resultCode; @@ -318,19 +320,14 @@ void SqliteStatement::prepare(const Utf8String &sqlStatementUtf8) checkForPrepareError(resultCode); } -sqlite3 *SqliteStatement::sqliteDatabaseHandle() +sqlite3 *SqliteStatement::sqliteDatabaseHandle() const { -return SqliteDatabaseBackend::sqliteDatabaseHandle(); + return m_databaseBackend.sqliteDatabaseHandle(); } TextEncoding SqliteStatement::databaseTextEncoding() { - if (SqliteDatabaseBackend::threadLocalInstance()) - return SqliteDatabaseBackend::threadLocalInstance()->textEncoding(); - - throwException("SqliteStatement::databaseTextEncoding: database backend instance is null!"); - - Q_UNREACHABLE(); + return m_databaseBackend.textEncoding(); } bool SqliteStatement::checkForStepError(int resultCode) const @@ -445,7 +442,7 @@ bool SqliteStatement::isReadOnlyStatement() const return sqlite3_stmt_readonly(m_compiledStatement.get()); } -void SqliteStatement::throwException(const char *whatHasHappened) +void SqliteStatement::throwException(const char *whatHasHappened) const { throw SqliteException(whatHasHappened, sqlite3_errmsg(sqliteDatabaseHandle())); } @@ -654,21 +651,21 @@ template SQLITE_EXPORT Utf8StringVector SqliteStatement::values SqliteStatement::values>(int column) const; template -Type SqliteStatement::toValue(const Utf8String &sqlStatementUtf8) +Type SqliteStatement::toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database) { - SqliteStatement statement(sqlStatementUtf8); + SqliteStatement statement(sqlStatementUtf8, database); statement.next(); return statement.value(0); } -template SQLITE_EXPORT int SqliteStatement::toValue(const Utf8String &sqlStatementUtf8); -template SQLITE_EXPORT qint64 SqliteStatement::toValue(const Utf8String &sqlStatementUtf8); -template SQLITE_EXPORT double SqliteStatement::toValue(const Utf8String &sqlStatementUtf8); -template SQLITE_EXPORT QString SqliteStatement::toValue(const Utf8String &sqlStatementUtf8); -template SQLITE_EXPORT QByteArray SqliteStatement::toValue(const Utf8String &sqlStatementUtf8); -template SQLITE_EXPORT Utf8String SqliteStatement::toValue(const Utf8String &sqlStatementUtf8); -template SQLITE_EXPORT QVariant SqliteStatement::toValue(const Utf8String &sqlStatementUtf8); +template SQLITE_EXPORT int SqliteStatement::toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); +template SQLITE_EXPORT qint64 SqliteStatement::toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); +template SQLITE_EXPORT double SqliteStatement::toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); +template SQLITE_EXPORT QString SqliteStatement::toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); +template SQLITE_EXPORT QByteArray SqliteStatement::toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); +template SQLITE_EXPORT Utf8String SqliteStatement::toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); +template SQLITE_EXPORT QVariant SqliteStatement::toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); } // namespace Sqlite diff --git a/src/libs/sqlite/sqlitestatement.h b/src/libs/sqlite/sqlitestatement.h index ee9494a3e14..bda6b931000 100644 --- a/src/libs/sqlite/sqlitestatement.h +++ b/src/libs/sqlite/sqlitestatement.h @@ -42,10 +42,13 @@ struct sqlite3; namespace Sqlite { +class SqliteDatabase; +class SqliteDatabaseBackend; + class SQLITE_EXPORT SqliteStatement { protected: - explicit SqliteStatement(const Utf8String &sqlStatementUtf8); + explicit SqliteStatement(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); static void deleteCompiledStatement(sqlite3_stmt *m_compiledStatement); @@ -85,10 +88,8 @@ protected: QMap rowColumnValueMap() const; QMap twoColumnValueMap() const; - static void execute(const Utf8String &sqlStatementUtf8); - template - static Type toValue(const Utf8String &sqlStatementUtf8); + static Type toValue(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); void prepare(const Utf8String &sqlStatementUtf8); void waitForUnlockNotify() const; @@ -96,8 +97,8 @@ protected: void write(const RowDictionary &rowDictionary); void writeUnchecked(const RowDictionary &rowDictionary); - static sqlite3 *sqliteDatabaseHandle(); - static TextEncoding databaseTextEncoding(); + sqlite3 *sqliteDatabaseHandle() const; + TextEncoding databaseTextEncoding(); bool checkForStepError(int resultCode) const; @@ -114,16 +115,21 @@ protected: void setColumnCount(); void checkBindingValueMapIsEmpty(const RowDictionary &rowDictionary) const; bool isReadOnlyStatement() const; - Q_NORETURN static void throwException(const char *whatHasHappened); + Q_NORETURN void throwException(const char *whatHasHappened) const; template ContainerType columnValues(const QVector &columnIndices) const; QString columnName(int column) const; +protected: + explicit SqliteStatement(const Utf8String &sqlStatementUtf8, + SqliteDatabaseBackend &databaseBackend); + private: std::unique_ptr m_compiledStatement; Utf8StringVector m_bindingColumnNames; + SqliteDatabaseBackend &m_databaseBackend; int m_bindingParameterCount; int m_columnCount; mutable bool m_isReadyToFetchValues; diff --git a/src/libs/sqlite/sqlitetable.cpp b/src/libs/sqlite/sqlitetable.cpp index b025c545f9f..5f0eeba6bf3 100644 --- a/src/libs/sqlite/sqlitetable.cpp +++ b/src/libs/sqlite/sqlitetable.cpp @@ -88,8 +88,8 @@ void SqliteTable::initialize() createTableSqlStatementBuilder.setUseWithoutRowId(m_withoutRowId); createTableSqlStatementBuilder.setColumnDefinitions(createColumnDefintions()); - SqliteImmediateTransaction transaction; - SqliteWriteStatement::execute(createTableSqlStatementBuilder.sqlStatement()); + SqliteImmediateTransaction transaction(*m_sqliteDatabase); + SqliteWriteStatement(createTableSqlStatementBuilder.sqlStatement(), *m_sqliteDatabase).step(); transaction.commit(); m_isReady = true; diff --git a/src/libs/sqlite/sqlitetransaction.cpp b/src/libs/sqlite/sqlitetransaction.cpp index 00d362287a9..e66f39ca3e3 100644 --- a/src/libs/sqlite/sqlitetransaction.cpp +++ b/src/libs/sqlite/sqlitetransaction.cpp @@ -25,6 +25,8 @@ #include "sqlitetransaction.h" +#include "sqlitedatabase.h" +#include "sqlitedatabasebackend.h" #include "sqlitewritestatement.h" namespace Sqlite { @@ -32,28 +34,41 @@ namespace Sqlite { SqliteAbstractTransaction::~SqliteAbstractTransaction() { if (!m_isAlreadyCommited) - SqliteWriteStatement::execute(Utf8StringLiteral("ROLLBACK")); + m_databaseBackend.execute(Utf8StringLiteral("ROLLBACK")); } void SqliteAbstractTransaction::commit() { - SqliteWriteStatement::execute(Utf8StringLiteral("COMMIT")); + m_databaseBackend.execute(Utf8StringLiteral("COMMIT")); m_isAlreadyCommited = true; } -SqliteTransaction::SqliteTransaction() +SqliteAbstractTransaction::SqliteAbstractTransaction(SqliteDatabaseBackend &backend) + : m_databaseBackend(backend) { - SqliteWriteStatement::execute(Utf8StringLiteral("BEGIN")); } -SqliteImmediateTransaction::SqliteImmediateTransaction() +SqliteAbstractTransaction::SqliteAbstractTransaction(SqliteDatabase &database) + : SqliteAbstractTransaction(database.backend()) { - SqliteWriteStatement::execute(Utf8StringLiteral("BEGIN IMMEDIATE")); } -SqliteExclusiveTransaction::SqliteExclusiveTransaction() +SqliteTransaction::SqliteTransaction(SqliteDatabase &database) + : SqliteAbstractTransaction(database) { - SqliteWriteStatement::execute(Utf8StringLiteral("BEGIN EXCLUSIVE")); + m_databaseBackend.execute(Utf8StringLiteral("BEGIN")); +} + +SqliteImmediateTransaction::SqliteImmediateTransaction(SqliteDatabase &database) + : SqliteAbstractTransaction(database) +{ + m_databaseBackend.execute(Utf8StringLiteral("BEGIN IMMEDIATE")); +} + +SqliteExclusiveTransaction::SqliteExclusiveTransaction(SqliteDatabase &database) + : SqliteAbstractTransaction(database) +{ + m_databaseBackend.execute(Utf8StringLiteral("BEGIN EXCLUSIVE")); } } // namespace Sqlite diff --git a/src/libs/sqlite/sqlitetransaction.h b/src/libs/sqlite/sqlitetransaction.h index 13084c16899..994fbe2b1f5 100644 --- a/src/libs/sqlite/sqlitetransaction.h +++ b/src/libs/sqlite/sqlitetransaction.h @@ -29,6 +29,9 @@ namespace Sqlite { +class SqliteDatabaseBackend; +class SqliteDatabase; + class SQLITE_EXPORT SqliteAbstractTransaction { public: @@ -36,6 +39,13 @@ public: void commit(); +protected: + SqliteAbstractTransaction(SqliteDatabaseBackend &backend); + SqliteAbstractTransaction(SqliteDatabase &database); + +protected: + SqliteDatabaseBackend &m_databaseBackend; + private: bool m_isAlreadyCommited = false; }; @@ -44,21 +54,21 @@ private: class SQLITE_EXPORT SqliteTransaction final : public SqliteAbstractTransaction { public: - SqliteTransaction(); + SqliteTransaction(SqliteDatabase &database); }; class SQLITE_EXPORT SqliteImmediateTransaction final : public SqliteAbstractTransaction { public: - SqliteImmediateTransaction(); + SqliteImmediateTransaction(SqliteDatabase &database); }; class SQLITE_EXPORT SqliteExclusiveTransaction final : public SqliteAbstractTransaction { public: - SqliteExclusiveTransaction(); + SqliteExclusiveTransaction(SqliteDatabase &database); }; diff --git a/src/libs/sqlite/sqlitewritestatement.cpp b/src/libs/sqlite/sqlitewritestatement.cpp index d240067ebde..20eb0d03ec0 100644 --- a/src/libs/sqlite/sqlitewritestatement.cpp +++ b/src/libs/sqlite/sqlitewritestatement.cpp @@ -27,8 +27,9 @@ namespace Sqlite { -SqliteWriteStatement::SqliteWriteStatement(const Utf8String &sqlStatementUtf8) - : SqliteStatement(sqlStatementUtf8) +SqliteWriteStatement::SqliteWriteStatement(const Utf8String &sqlStatementUtf8, + SqliteDatabase &database) + : SqliteStatement(sqlStatementUtf8, database) { checkIsWritableStatement(); } diff --git a/src/libs/sqlite/sqlitewritestatement.h b/src/libs/sqlite/sqlitewritestatement.h index 50cdd5c4f0e..14341203d6e 100644 --- a/src/libs/sqlite/sqlitewritestatement.h +++ b/src/libs/sqlite/sqlitewritestatement.h @@ -32,7 +32,7 @@ namespace Sqlite { class SQLITE_EXPORT SqliteWriteStatement : private SqliteStatement { public: - explicit SqliteWriteStatement(const Utf8String &sqlStatementUtf8); + explicit SqliteWriteStatement(const Utf8String &sqlStatementUtf8, SqliteDatabase &database); using SqliteStatement::step; using SqliteStatement::reset; @@ -43,7 +43,6 @@ public: using SqliteStatement::bindingColumnNames; using SqliteStatement::write; using SqliteStatement::writeUnchecked; - using SqliteStatement::execute; protected: void checkIsWritableStatement(); diff --git a/tests/unit/unittest/sqlitedatabasebackend-test.cpp b/tests/unit/unittest/sqlitedatabasebackend-test.cpp index 96d49b17ba8..b15e5e1ea77 100644 --- a/tests/unit/unittest/sqlitedatabasebackend-test.cpp +++ b/tests/unit/unittest/sqlitedatabasebackend-test.cpp @@ -135,7 +135,7 @@ TEST_F(SqliteDatabaseBackend, TextEncodingCannotBeChangedAfterTouchingDatabase) { databaseBackend.setJournalMode(JournalMode::Memory); - SqliteWriteStatement::execute(Utf8StringLiteral("CREATE TABLE text(name, number)")); + databaseBackend.execute(Utf8StringLiteral("CREATE TABLE text(name, number)")); ASSERT_THROW(databaseBackend.setTextEncoding(Utf16), SqliteException); } diff --git a/tests/unit/unittest/sqlitestatement-test.cpp b/tests/unit/unittest/sqlitestatement-test.cpp index 54a14575ee8..0acb7d7635b 100644 --- a/tests/unit/unittest/sqlitestatement-test.cpp +++ b/tests/unit/unittest/sqlitestatement-test.cpp @@ -25,7 +25,7 @@ #include "googletest.h" -#include +#include #include #include #include @@ -41,7 +41,7 @@ namespace { using Sqlite::SqliteException; -using Sqlite::SqliteDatabaseBackend; +using Sqlite::SqliteDatabase; using Sqlite::SqliteReadStatement; using Sqlite::SqliteReadWriteStatement; using Sqlite::SqliteWriteStatement; @@ -52,32 +52,32 @@ protected: void SetUp() override; void TearDown() override; - SqliteDatabaseBackend databaseBackend; + SqliteDatabase database; }; TEST_F(SqliteStatement, PrepareFailure) { - ASSERT_THROW(SqliteReadStatement(Utf8StringLiteral("blah blah blah")), SqliteException); - ASSERT_THROW(SqliteWriteStatement(Utf8StringLiteral("blah blah blah")), SqliteException); - ASSERT_THROW(SqliteReadStatement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)")), SqliteException); - ASSERT_THROW(SqliteWriteStatement(Utf8StringLiteral("SELECT name, number FROM test '")), SqliteException); + ASSERT_THROW(SqliteReadStatement(Utf8StringLiteral("blah blah blah"), database), SqliteException); + ASSERT_THROW(SqliteWriteStatement(Utf8StringLiteral("blah blah blah"), database), SqliteException); + ASSERT_THROW(SqliteReadStatement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)"), database), SqliteException); + ASSERT_THROW(SqliteWriteStatement(Utf8StringLiteral("SELECT name, number FROM test '"), database), SqliteException); } TEST_F(SqliteStatement, CountRows) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT * FROM test")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT * FROM test"), database); int nextCount = 0; while (statement.next()) ++nextCount; - int sqlCount = SqliteReadStatement::toValue(Utf8StringLiteral("SELECT count(*) FROM test")); + int sqlCount = SqliteReadStatement::toValue(Utf8StringLiteral("SELECT count(*) FROM test"), database); ASSERT_THAT(nextCount, sqlCount); } TEST_F(SqliteStatement, Value) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER BY name")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER BY name"), database); statement.next(); @@ -108,7 +108,7 @@ TEST_F(SqliteStatement, Value) TEST_F(SqliteStatement, ValueFailure) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database); ASSERT_THROW(statement.value(0), SqliteException); statement.reset(); @@ -125,42 +125,42 @@ TEST_F(SqliteStatement, ValueFailure) TEST_F(SqliteStatement, ToIntergerValue) { - ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT number FROM test WHERE name='foo'")), 23); + ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT number FROM test WHERE name='foo'"), database), 23); } TEST_F(SqliteStatement, ToLongIntergerValue) { - ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT number FROM test WHERE name='foo'")), 23LL); + ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT number FROM test WHERE name='foo'"), database), 23LL); } TEST_F(SqliteStatement, ToDoubleValue) { - ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT number FROM test WHERE name='foo'")), 23.3); + ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT number FROM test WHERE name='foo'"), database), 23.3); } TEST_F(SqliteStatement, ToQStringValue) { - ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'")), QStringLiteral("foo")); + ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'"), database), QStringLiteral("foo")); } TEST_F(SqliteStatement, ToUtf8StringValue) { - ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'")), Utf8StringLiteral("foo")); + ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'"), database), Utf8StringLiteral("foo")); } TEST_F(SqliteStatement, ToQByteArrayValueIsNull) { - ASSERT_TRUE(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'")).isNull()); + ASSERT_TRUE(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'"), database).isNull()); } TEST_F(SqliteStatement, ToQVariantValue) { - ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'")), QVariant::fromValue(QStringLiteral("foo"))); + ASSERT_THAT(SqliteReadStatement::toValue(Utf8StringLiteral("SELECT name FROM test WHERE name='foo'"), database), QVariant::fromValue(QStringLiteral("foo"))); } TEST_F(SqliteStatement, Utf8Values) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER by name")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER by name"), database); Utf8StringVector values = statement.values(); ASSERT_THAT(values.count(), 3); @@ -170,7 +170,7 @@ TEST_F(SqliteStatement, Utf8Values) } TEST_F(SqliteStatement, DoubleValues) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER by name")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER by name"), database); QVector values = statement.values>(1); @@ -182,7 +182,7 @@ TEST_F(SqliteStatement, DoubleValues) TEST_F(SqliteStatement, QVariantValues) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER by name")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test ORDER by name"), database); QVector values = statement.values>(QVector() << 0 << 1); @@ -197,7 +197,7 @@ TEST_F(SqliteStatement, QVariantValues) TEST_F(SqliteStatement, RowColumnValueMapCountForValidRow) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE rowid=1")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE rowid=1"), database); QMap values = statement.rowColumnValueMap(); @@ -206,7 +206,7 @@ TEST_F(SqliteStatement, RowColumnValueMapCountForValidRow) TEST_F(SqliteStatement, RowColumnValueMapCountForInvalidRow) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE rowid=100")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE rowid=100"), database); QMap values = statement.rowColumnValueMap(); @@ -215,7 +215,7 @@ TEST_F(SqliteStatement, RowColumnValueMapCountForInvalidRow) TEST_F(SqliteStatement, RowColumnValueMapValues) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE rowid=2")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE rowid=2"), database); QMap values = statement.rowColumnValueMap(); @@ -225,7 +225,7 @@ TEST_F(SqliteStatement, RowColumnValueMapValues) TEST_F(SqliteStatement, TwoColumnValueMapCount) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database); QMap values = statement.twoColumnValueMap(); @@ -234,7 +234,7 @@ TEST_F(SqliteStatement, TwoColumnValueMapCount) TEST_F(SqliteStatement, TwoColumnValueMapValues) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database); QMap values = statement.twoColumnValueMap(); @@ -243,7 +243,7 @@ TEST_F(SqliteStatement, TwoColumnValueMapValues) TEST_F(SqliteStatement, ValuesFailure) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database); ASSERT_THROW(statement.values>(QVector() << 1 << 2);, SqliteException); ASSERT_THROW(statement.values>(QVector() << -1 << 1);, SqliteException); @@ -251,7 +251,7 @@ TEST_F(SqliteStatement, ValuesFailure) TEST_F(SqliteStatement, ColumnNames) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test"), database); Utf8StringVector columnNames = statement.columnNames(); @@ -264,7 +264,7 @@ TEST_F(SqliteStatement, ColumnNames) TEST_F(SqliteStatement, BindQString) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name=?")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name=?"), database); statement.bind(1, QStringLiteral("foo")); @@ -276,7 +276,7 @@ TEST_F(SqliteStatement, BindQString) TEST_F(SqliteStatement, BindInteger) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database); statement.bind(1, 40); statement.next(); @@ -286,7 +286,7 @@ TEST_F(SqliteStatement, BindInteger) TEST_F(SqliteStatement, BindLongInteger) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database); statement.bind(1, qint64(40)); statement.next(); @@ -296,7 +296,7 @@ TEST_F(SqliteStatement, BindLongInteger) TEST_F(SqliteStatement, BindByteArray) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database); statement.bind(1, QByteArray::fromHex("0500")); statement.next(); @@ -306,7 +306,7 @@ TEST_F(SqliteStatement, BindByteArray) TEST_F(SqliteStatement, BindDouble) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database); statement.bind(1, 23.3); statement.next(); @@ -316,7 +316,7 @@ TEST_F(SqliteStatement, BindDouble) TEST_F(SqliteStatement, BindIntergerQVariant) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database); statement.bind(1, QVariant::fromValue(40)); statement.next(); @@ -326,7 +326,7 @@ TEST_F(SqliteStatement, BindIntergerQVariant) TEST_F(SqliteStatement, BindLongIntergerQVariant) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database); statement.bind(1, QVariant::fromValue(qint64(40))); statement.next(); @@ -335,7 +335,7 @@ TEST_F(SqliteStatement, BindLongIntergerQVariant) TEST_F(SqliteStatement, BindDoubleQVariant) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database); statement.bind(1, QVariant::fromValue(23.3)); statement.next(); @@ -345,7 +345,7 @@ TEST_F(SqliteStatement, BindDoubleQVariant) TEST_F(SqliteStatement, BindByteArrayQVariant) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=?"), database); statement.bind(1, QVariant::fromValue(QByteArray::fromHex("0500"))); statement.next(); @@ -355,7 +355,7 @@ TEST_F(SqliteStatement, BindByteArrayQVariant) TEST_F(SqliteStatement, BindIntegerByParameter) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database); statement.bind(Utf8StringLiteral("@number"), 40); statement.next(); @@ -365,7 +365,7 @@ TEST_F(SqliteStatement, BindIntegerByParameter) TEST_F(SqliteStatement, BindLongIntegerByParameter) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database); statement.bind(Utf8StringLiteral("@number"), qint64(40)); statement.next(); @@ -375,7 +375,7 @@ TEST_F(SqliteStatement, BindLongIntegerByParameter) TEST_F(SqliteStatement, BindByteArrayByParameter) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database); statement.bind(Utf8StringLiteral("@number"), QByteArray::fromHex("0500")); statement.next(); @@ -385,7 +385,7 @@ TEST_F(SqliteStatement, BindByteArrayByParameter) TEST_F(SqliteStatement, BindDoubleByIndex) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database); statement.bind(statement.bindingIndexForName(Utf8StringLiteral("@number")), 23.3); statement.next(); @@ -395,7 +395,7 @@ TEST_F(SqliteStatement, BindDoubleByIndex) TEST_F(SqliteStatement, BindQVariantByIndex) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database); statement.bind(statement.bindingIndexForName(Utf8StringLiteral("@number")), QVariant::fromValue((40))); statement.next(); @@ -406,7 +406,7 @@ TEST_F(SqliteStatement, BindQVariantByIndex) TEST_F(SqliteStatement, BindFailure) { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE number=@number"), database); ASSERT_THROW(statement.bind(0, 40), SqliteException); ASSERT_THROW(statement.bind(2, 40), SqliteException); @@ -417,7 +417,7 @@ TEST_F(SqliteStatement, RequestBindingNamesFromStatement) { Utf8StringVector expectedValues({Utf8StringLiteral("name"), Utf8StringLiteral("number"), Utf8StringLiteral("id")}); - SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET name=@name, number=@number WHERE rowid=@id")); + SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET name=@name, number=@number WHERE rowid=@id"), database); ASSERT_THAT(statement.bindingColumnNames(), expectedValues); } @@ -425,7 +425,7 @@ TEST_F(SqliteStatement, RequestBindingNamesFromStatement) TEST_F(SqliteStatement, WriteUpdateWidthUnamedParameter) { { - int startTotalCount = databaseBackend.totalChangesCount(); + int startTotalCount = database.totalChangesCount(); RowDictionary firstValueMap; firstValueMap.insert(Utf8StringLiteral("name"), QStringLiteral("foo")); firstValueMap.insert(Utf8StringLiteral("number"), 66.6); @@ -434,24 +434,24 @@ TEST_F(SqliteStatement, WriteUpdateWidthUnamedParameter) secondValueMap.insert(Utf8StringLiteral("name"), QStringLiteral("bar")); secondValueMap.insert(Utf8StringLiteral("number"), 77.7); - SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET number=? WHERE name=?")); + SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET number=? WHERE name=?"), database); statement.setBindingColumnNames(Utf8StringVector() << Utf8StringLiteral("number") << Utf8StringLiteral("name")); statement.write(firstValueMap); - ASSERT_THAT(databaseBackend.totalChangesCount(), startTotalCount + 1); + ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1); statement.write(firstValueMap); - ASSERT_THAT(databaseBackend.totalChangesCount(), startTotalCount + 2); + ASSERT_THAT(database.totalChangesCount(), startTotalCount + 2); statement.write(secondValueMap); - ASSERT_THAT(databaseBackend.totalChangesCount(), startTotalCount + 3); + ASSERT_THAT(database.totalChangesCount(), startTotalCount + 3); } { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='foo'")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='foo'"), database); statement.next(); @@ -462,18 +462,18 @@ TEST_F(SqliteStatement, WriteUpdateWidthUnamedParameter) TEST_F(SqliteStatement, WriteUpdateWidthNamedParameter) { { - int startTotalCount = databaseBackend.totalChangesCount(); + int startTotalCount = database.totalChangesCount(); RowDictionary firstValueMap; firstValueMap.insert(Utf8StringLiteral("name"), QStringLiteral("foo")); firstValueMap.insert(Utf8StringLiteral("number"), 99.9); - SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET number=@number WHERE name=@name")); + SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET number=@number WHERE name=@name"), database); statement.write(firstValueMap); - ASSERT_THAT(databaseBackend.totalChangesCount(), startTotalCount + 1); + ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1); } { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='foo'")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='foo'"), database); statement.next(); ASSERT_THAT(statement.value(1), 99.9); } @@ -482,17 +482,17 @@ TEST_F(SqliteStatement, WriteUpdateWidthNamedParameter) TEST_F(SqliteStatement, WriteUpdateWidthNamedParameterAndBindNotAllParameter) { { - int startTotalCount = databaseBackend.totalChangesCount(); + int startTotalCount = database.totalChangesCount(); RowDictionary firstValueMap; firstValueMap.insert(Utf8StringLiteral("name"), QStringLiteral("foo")); - SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET number=@number WHERE name=@name")); + SqliteWriteStatement statement(Utf8StringLiteral("UPDATE test SET number=@number WHERE name=@name"), database); statement.writeUnchecked(firstValueMap); - ASSERT_THAT(databaseBackend.totalChangesCount(), startTotalCount + 1); + ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1); } { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='foo'")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='foo'"), database); statement.next(); ASSERT_THAT(statement.value(1), 0.0); } @@ -501,22 +501,22 @@ TEST_F(SqliteStatement, WriteUpdateWidthNamedParameterAndBindNotAllParameter) TEST_F(SqliteStatement, WriteInsert) { { - int startTotalCount = databaseBackend.totalChangesCount(); + int startTotalCount = database.totalChangesCount(); RowDictionary valueMap; valueMap.insert(Utf8StringLiteral("name"), QStringLiteral("jane")); valueMap.insert(Utf8StringLiteral("number"), 232.3); - SqliteWriteStatement statement(Utf8StringLiteral("INSERT OR IGNORE INTO test(name, number) VALUES (?, ?)")); + SqliteWriteStatement statement(Utf8StringLiteral("INSERT OR IGNORE INTO test(name, number) VALUES (?, ?)"), database); statement.setBindingColumnNames(Utf8StringVector() << Utf8StringLiteral("name") << Utf8StringLiteral("number")); statement.write(valueMap); - ASSERT_THAT(databaseBackend.totalChangesCount(), startTotalCount + 1); + ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1); statement.write(valueMap); - ASSERT_THAT(databaseBackend.totalChangesCount(), startTotalCount + 1); + ASSERT_THAT(database.totalChangesCount(), startTotalCount + 1); } { - SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='jane'")); + SqliteReadStatement statement(Utf8StringLiteral("SELECT name, number FROM test WHERE name='jane'"), database); statement.next(); ASSERT_THAT(statement.value(1), 232.3); } @@ -529,7 +529,7 @@ TEST_F(SqliteStatement, WriteFailure) valueMap.insert(Utf8StringLiteral("name"), QStringLiteral("foo")); valueMap.insert(Utf8StringLiteral("number"), 323.3); - SqliteWriteStatement statement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)")); + SqliteWriteStatement statement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)"), database); statement.setBindingColumnNames(Utf8StringVector() << Utf8StringLiteral("name") << Utf8StringLiteral("number")); ASSERT_THROW(statement.write(valueMap), SqliteException); } @@ -538,7 +538,7 @@ TEST_F(SqliteStatement, WriteFailure) RowDictionary valueMap; valueMap.insert(Utf8StringLiteral("name"), QStringLiteral("bar")); - SqliteWriteStatement statement(Utf8StringLiteral("INSERT OR IGNORE INTO test(name, number) VALUES (?, ?)")); + SqliteWriteStatement statement(Utf8StringLiteral("INSERT OR IGNORE INTO test(name, number) VALUES (?, ?)"), database); statement.setBindingColumnNames(Utf8StringVector() << Utf8StringLiteral("name") << Utf8StringLiteral("number")); ASSERT_THROW(statement.write(valueMap), SqliteException); } @@ -546,25 +546,26 @@ TEST_F(SqliteStatement, WriteFailure) TEST_F(SqliteStatement, ClosedDatabase) { - databaseBackend.close(); - ASSERT_THROW(SqliteWriteStatement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)")), SqliteException); - ASSERT_THROW(SqliteReadStatement(Utf8StringLiteral("SELECT * FROM test")), SqliteException); - ASSERT_THROW(SqliteReadWriteStatement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)")), SqliteException); - databaseBackend.open(QDir::tempPath() + QStringLiteral("/SqliteStatementTest.db")); + database.close(); + ASSERT_THROW(SqliteWriteStatement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)"), database), SqliteException); + ASSERT_THROW(SqliteReadStatement(Utf8StringLiteral("SELECT * FROM test"), database), SqliteException); + ASSERT_THROW(SqliteReadWriteStatement(Utf8StringLiteral("INSERT INTO test(name, number) VALUES (?, ?)"), database), SqliteException); + database.open(QDir::tempPath() + QStringLiteral("/SqliteStatementTest.db")); } void SqliteStatement::SetUp() { - databaseBackend.open(QStringLiteral(":memory:")); - SqliteWriteStatement::execute(Utf8StringLiteral("CREATE TABLE test(name TEXT UNIQUE, number NUMERIC)")); - SqliteWriteStatement::execute(Utf8StringLiteral("INSERT INTO test VALUES ('bar', x'0500')")); - SqliteWriteStatement::execute(Utf8StringLiteral("INSERT INTO test VALUES ('foo', 23.3)")); - SqliteWriteStatement::execute(Utf8StringLiteral("INSERT INTO test VALUES ('poo', 40)")); + database.setJournalMode(JournalMode::Memory); + database.open(QStringLiteral(":memory:")); + SqliteWriteStatement(Utf8StringLiteral("CREATE TABLE test(name TEXT UNIQUE, number NUMERIC)"), database).step(); + SqliteWriteStatement(Utf8StringLiteral("INSERT INTO test VALUES ('bar', x'0500')"), database).step(); + SqliteWriteStatement(Utf8StringLiteral("INSERT INTO test VALUES ('foo', 23.3)"), database).step(); + SqliteWriteStatement(Utf8StringLiteral("INSERT INTO test VALUES ('poo', 40)"), database).step(); } void SqliteStatement::TearDown() { - databaseBackend.close(); + database.close(); } }