diff options
Diffstat (limited to '3rdparty/sqlitecpp')
20 files changed, 3547 insertions, 0 deletions
diff --git a/3rdparty/sqlitecpp/CMakeLists.txt b/3rdparty/sqlitecpp/CMakeLists.txt new file mode 100644 index 0000000..1ba64db --- /dev/null +++ b/3rdparty/sqlitecpp/CMakeLists.txt @@ -0,0 +1,10 @@ +file(GLOB_RECURSE SQLiteCpp_SOURCE ${CMAKE_CURRENT_LIST_DIR}/source/*.cpp) +add_library(SQLiteCpp ${SQLiteCpp_SOURCE}) +target_include_directories(SQLiteCpp +PUBLIC + ${CMAKE_CURRENT_LIST_DIR}/source +) +target_link_libraries(SQLiteCpp +PRIVATE + sqlite3 # This comes from conan +) diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Assertion.h b/3rdparty/sqlitecpp/source/SQLiteCpp/Assertion.h new file mode 100644 index 0000000..b6d00be --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Assertion.h @@ -0,0 +1,46 @@ +/** + * @file Assertion.h + * @ingroup SQLiteCpp + * @brief Definition of the SQLITECPP_ASSERT() macro. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#include <cassert> + + +/** + * SQLITECPP_ASSERT SQLITECPP_ASSERT() is used in destructors, where exceptions shall not be thrown + * + * Define SQLITECPP_ENABLE_ASSERT_HANDLER at the project level + * and define a SQLite::assertion_failed() assertion handler + * to tell SQLiteC++ to use it instead of assert() when an assertion fail. +*/ +#ifdef SQLITECPP_ENABLE_ASSERT_HANDLER + +// if an assert handler is provided by user code, use it instead of assert() +namespace SQLite +{ + // declaration of the assert handler to define in user code + void assertion_failed(const char* apFile, const long apLine, const char* apFunc, + const char* apExpr, const char* apMsg); + +#ifdef _MSC_VER + #define __func__ __FUNCTION__ +#endif +// call the assert handler provided by user code +#define SQLITECPP_ASSERT(expression, message) \ + if (!(expression)) SQLite::assertion_failed(__FILE__, __LINE__, __func__, #expression, message) +} // namespace SQLite + +#else + +// if no assert handler provided by user code, use standard assert() +// (note: in release mode assert() does nothing) +#define SQLITECPP_ASSERT(expression, message) assert(expression && message) + +#endif diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Backup.cpp b/3rdparty/sqlitecpp/source/SQLiteCpp/Backup.cpp new file mode 100644 index 0000000..183d314 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Backup.cpp @@ -0,0 +1,83 @@ +/** + * @file Backup.cpp + * @ingroup SQLiteCpp + * @brief Backup is used to backup a database file in a safe and online way. + * + * Copyright (c) 2015 Shibao HONG ([email protected]) + * Copyright (c) 2015-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#include <SQLiteCpp/Backup.h> + +#include <SQLiteCpp/Exception.h> + +#include <sqlite3.h> + +namespace SQLite +{ + +// Initialize resource for SQLite database backup +Backup::Backup(Database& aDestDatabase, + const char* apDestDatabaseName, + Database& aSrcDatabase, + const char* apSrcDatabaseName) +{ + mpSQLiteBackup = sqlite3_backup_init(aDestDatabase.getHandle(), + apDestDatabaseName, + aSrcDatabase.getHandle(), + apSrcDatabaseName); + if (nullptr == mpSQLiteBackup) + { + // If an error occurs, the error code and message are attached to the destination database connection. + throw SQLite::Exception(aDestDatabase.getHandle()); + } +} + +Backup::Backup(Database& aDestDatabase, + const std::string& aDestDatabaseName, + Database& aSrcDatabase, + const std::string& aSrcDatabaseName) : + Backup(aDestDatabase, aDestDatabaseName.c_str(), aSrcDatabase, aSrcDatabaseName.c_str()) +{ +} + +Backup::Backup(Database &aDestDatabase, Database &aSrcDatabase) : + Backup(aDestDatabase, "main", aSrcDatabase, "main") +{ +} + +// Release resource for SQLite database backup +Backup::~Backup() +{ + if (mpSQLiteBackup) + { + sqlite3_backup_finish(mpSQLiteBackup); + } +} + +// Execute backup step with a given number of source pages to be copied +int Backup::executeStep(const int aNumPage /* = -1 */) +{ + const int res = sqlite3_backup_step(mpSQLiteBackup, aNumPage); + if (SQLITE_OK != res && SQLITE_DONE != res && SQLITE_BUSY != res && SQLITE_LOCKED != res) + { + throw SQLite::Exception(sqlite3_errstr(res), res); + } + return res; +} + +// Get the number of remaining source pages to be copied in this backup process +int Backup::getRemainingPageCount() +{ + return sqlite3_backup_remaining(mpSQLiteBackup); +} + +// Get the number of total source pages to be copied in this backup process +int Backup::getTotalPageCount() +{ + return sqlite3_backup_pagecount(mpSQLiteBackup); +} + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Backup.h b/3rdparty/sqlitecpp/source/SQLiteCpp/Backup.h new file mode 100644 index 0000000..21ad662 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Backup.h @@ -0,0 +1,127 @@ +/** + * @file Backup.h + * @ingroup SQLiteCpp + * @brief Backup is used to backup a database file in a safe and online way. + * + * Copyright (c) 2015 Shibao HONG ([email protected]) + * Copyright (c) 2015-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#include <SQLiteCpp/Database.h> + +#include <string> + +// Forward declaration to avoid inclusion of <sqlite3.h> in a header +struct sqlite3_backup; + +namespace SQLite +{ + +/** + * @brief RAII encapsulation of a SQLite Database Backup process. + * + * A Backup object is used to backup a source database file to a destination database file + * in a safe and online way. + * + * See also the a reference implementation of live backup taken from the official site: + * https://www.sqlite.org/backup.html + */ +class Backup +{ +public: + /** + * @brief Initialize a SQLite Backup object. + * + * Initialize a SQLite Backup object for the source database and destination database. + * The database name is "main" for the main database, "temp" for the temporary database, + * or the name specified after the AS keyword in an ATTACH statement for an attached database. + * + * Exception is thrown in case of error, then the Backup object is NOT constructed. + * + * @param[in] aDestDatabase Destination database connection + * @param[in] apDestDatabaseName Destination database name + * @param[in] aSrcDatabase Source database connection + * @param[in] apSrcDatabaseName Source database name + * + * @throw SQLite::Exception in case of error + */ + Backup(Database& aDestDatabase, + const char* apDestDatabaseName, + Database& aSrcDatabase, + const char* apSrcDatabaseName); + + /** + * @brief Initialize a SQLite Backup object. + * + * Initialize a SQLite Backup object for source database and destination database. + * The database name is "main" for the main database, "temp" for the temporary database, + * or the name specified after the AS keyword in an ATTACH statement for an attached database. + * + * Exception is thrown in case of error, then the Backup object is NOT constructed. + * + * @param[in] aDestDatabase Destination database connection + * @param[in] aDestDatabaseName Destination database name + * @param[in] aSrcDatabase Source database connection + * @param[in] aSrcDatabaseName Source database name + * + * @throw SQLite::Exception in case of error + */ + Backup(Database& aDestDatabase, + const std::string& aDestDatabaseName, + Database& aSrcDatabase, + const std::string& aSrcDatabaseName); + + /** + * @brief Initialize a SQLite Backup object for main databases. + * + * Initialize a SQLite Backup object for source database and destination database. + * Backup the main databases between the source and the destination. + * + * Exception is thrown in case of error, then the Backup object is NOT constructed. + * + * @param[in] aDestDatabase Destination database connection + * @param[in] aSrcDatabase Source database connection + * + * @throw SQLite::Exception in case of error + */ + Backup(Database& aDestDatabase, + Database& aSrcDatabase); + + // Backup is non-copyable + Backup(const Backup&) = delete; + Backup& operator=(const Backup&) = delete; + + /// Release the SQLite Backup resource. + ~Backup(); + + /** + * @brief Execute a step of backup with a given number of source pages to be copied + * + * Exception is thrown when SQLITE_IOERR_XXX, SQLITE_NOMEM, or SQLITE_READONLY is returned + * in sqlite3_backup_step(). These errors are considered fatal, so there is no point + * in retrying the call to executeStep(). + * + * @param[in] aNumPage The number of source pages to be copied, with a negative value meaning all remaining source pages + * + * @return SQLITE_OK/SQLITE_DONE/SQLITE_BUSY/SQLITE_LOCKED + * + * @throw SQLite::Exception in case of error + */ + int executeStep(const int aNumPage = -1); + + /// Return the number of source pages still to be backed up as of the most recent call to executeStep(). + int getRemainingPageCount(); + + /// Return the total number of pages in the source database as of the most recent call to executeStep(). + int getTotalPageCount(); + +private: + // TODO: use std::unique_ptr with a custom deleter to call sqlite3_backup_finish() + sqlite3_backup* mpSQLiteBackup = nullptr; ///< Pointer to SQLite Database Backup Handle +}; + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Column.cpp b/3rdparty/sqlitecpp/source/SQLiteCpp/Column.cpp new file mode 100644 index 0000000..f5dc0d9 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Column.cpp @@ -0,0 +1,122 @@ +/** + * @file Column.cpp + * @ingroup SQLiteCpp + * @brief Encapsulation of a Column in a row of the result pointed by the prepared SQLite::Statement. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#include <SQLiteCpp/Column.h> + +#include <sqlite3.h> + +#include <iostream> + + +namespace SQLite +{ + +const int INTEGER = SQLITE_INTEGER; +const int FLOAT = SQLITE_FLOAT; +const int TEXT = SQLITE_TEXT; +const int BLOB = SQLITE_BLOB; +const int Null = SQLITE_NULL; + + +// Encapsulation of a Column in a row of the result pointed by the prepared Statement. +Column::Column(const Statement::TStatementPtr& aStmtPtr, int aIndex) : + mStmtPtr(aStmtPtr), + mIndex(aIndex) +{ + if (!aStmtPtr) + { + throw SQLite::Exception("Statement was destroyed"); + } +} + +// Return the named assigned to this result column (potentially aliased) +const char* Column::getName() const noexcept +{ + return sqlite3_column_name(mStmtPtr.get(), mIndex); +} + +#ifdef SQLITE_ENABLE_COLUMN_METADATA +// Return the name of the table column that is the origin of this result column +const char* Column::getOriginName() const noexcept +{ + return sqlite3_column_origin_name(mStmtPtr.get(), mIndex); +} +#endif + +// Return the integer value of the column specified by its index starting at 0 +int Column::getInt() const noexcept +{ + return sqlite3_column_int(mStmtPtr.get(), mIndex); +} + +// Return the unsigned integer value of the column specified by its index starting at 0 +unsigned Column::getUInt() const noexcept +{ + return static_cast<unsigned>(getInt64()); +} + +// Return the 64bits integer value of the column specified by its index starting at 0 +long long Column::getInt64() const noexcept +{ + return sqlite3_column_int64(mStmtPtr.get(), mIndex); +} + +// Return the double value of the column specified by its index starting at 0 +double Column::getDouble() const noexcept +{ + return sqlite3_column_double(mStmtPtr.get(), mIndex); +} + +// Return a pointer to the text value (NULL terminated string) of the column specified by its index starting at 0 +const char* Column::getText(const char* apDefaultValue /* = "" */) const noexcept +{ + auto pText = reinterpret_cast<const char*>(sqlite3_column_text(mStmtPtr.get(), mIndex)); + return (pText?pText:apDefaultValue); +} + +// Return a pointer to the blob value (*not* NULL terminated) of the column specified by its index starting at 0 +const void* Column::getBlob() const noexcept +{ + return sqlite3_column_blob(mStmtPtr.get(), mIndex); +} + +// Return a std::string to a TEXT or BLOB column +std::string Column::getString() const +{ + // Note: using sqlite3_column_blob and not sqlite3_column_text + // - no need for sqlite3_column_text to add a \0 on the end, as we're getting the bytes length directly + auto data = static_cast<const char *>(sqlite3_column_blob(mStmtPtr.get(), mIndex)); + + // SQLite docs: "The safest policy is to invoke… sqlite3_column_blob() followed by sqlite3_column_bytes()" + // Note: std::string is ok to pass nullptr as first arg, if length is 0 + return std::string(data, sqlite3_column_bytes(mStmtPtr.get(), mIndex)); +} + +// Return the type of the value of the column +int Column::getType() const noexcept +{ + return sqlite3_column_type(mStmtPtr.get(), mIndex); +} + +// Return the number of bytes used by the text value of the column +int Column::getBytes() const noexcept +{ + return sqlite3_column_bytes(mStmtPtr.get(), mIndex); +} + +// Standard std::ostream inserter +std::ostream& operator<<(std::ostream& aStream, const Column& aColumn) +{ + aStream.write(aColumn.getText(), aColumn.getBytes()); + return aStream; +} + + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Column.h b/3rdparty/sqlitecpp/source/SQLiteCpp/Column.h new file mode 100644 index 0000000..bc349f9 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Column.h @@ -0,0 +1,291 @@ +/** + * @file Column.h + * @ingroup SQLiteCpp + * @brief Encapsulation of a Column in a row of the result pointed by the prepared SQLite::Statement. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#include <SQLiteCpp/Statement.h> +#include <SQLiteCpp/Exception.h> + +#include <string> +#include <memory> +#include <climits> // For INT_MAX + +// Forward declarations to avoid inclusion of <sqlite3.h> in a header +struct sqlite3_stmt; + +namespace SQLite +{ + +extern const int INTEGER; ///< SQLITE_INTEGER +extern const int FLOAT; ///< SQLITE_FLOAT +extern const int TEXT; ///< SQLITE_TEXT +extern const int BLOB; ///< SQLITE_BLOB +extern const int Null; ///< SQLITE_NULL + +/** + * @brief Encapsulation of a Column in a row of the result pointed by the prepared Statement. + * + * A Column is a particular field of SQLite data in the current row of result + * of the Statement : it points to a single cell. + * + * Its value can be expressed as a text, and, when applicable, as a numeric + * (integer or floating point) or a binary blob. + * + * Thread-safety: a Column object shall not be shared by multiple threads, because : + * 1) in the SQLite "Thread Safe" mode, "SQLite can be safely used by multiple threads + * provided that no single database connection is used simultaneously in two or more threads." + * 2) the SQLite "Serialized" mode is not supported by SQLiteC++, + * because of the way it shares the underling SQLite precompiled statement + * in a custom shared pointer (See the inner class "Statement::Ptr"). + */ +class Column +{ +public: + /** + * @brief Encapsulation of a Column in a Row of the result. + * + * @param[in] aStmtPtr Shared pointer to the prepared SQLite Statement Object. + * @param[in] aIndex Index of the column in the row of result, starting at 0 + */ + explicit Column(const Statement::TStatementPtr& aStmtPtr, int aIndex); + + // default destructor: the finalization will be done by the destructor of the last shared pointer + // default copy constructor and assignment operator are perfectly suited : + // they copy the Statement::Ptr which in turn increments the reference counter. + + /** + * @brief Return a pointer to the named assigned to this result column (potentially aliased) + * + * @see getOriginName() to get original column name (not aliased) + */ + const char* getName() const noexcept; + +#ifdef SQLITE_ENABLE_COLUMN_METADATA + /** + * @brief Return a pointer to the table column name that is the origin of this result column + * + * Require definition of the SQLITE_ENABLE_COLUMN_METADATA preprocessor macro : + * - when building the SQLite library itself (which is the case for the Debian libsqlite3 binary for instance), + * - and also when compiling this wrapper. + */ + const char* getOriginName() const noexcept; +#endif + + /// Return the integer value of the column. + int getInt() const noexcept; + /// Return the 32bits unsigned integer value of the column (note that SQLite3 does not support unsigned 64bits). + unsigned getUInt() const noexcept; + /// Return the 64bits integer value of the column (note that SQLite3 does not support unsigned 64bits). + long long getInt64() const noexcept; + /// Return the double (64bits float) value of the column + double getDouble() const noexcept; + /** + * @brief Return a pointer to the text value (NULL terminated string) of the column. + * + * @warning The value pointed at is only valid while the statement is valid (ie. not finalized), + * thus you must copy it before using it beyond its scope (to a std::string for instance). + */ + const char* getText(const char* apDefaultValue = "") const noexcept; + /** + * @brief Return a pointer to the binary blob value of the column. + * + * @warning The value pointed at is only valid while the statement is valid (ie. not finalized), + * thus you must copy it before using it beyond its scope (to a std::string for instance). + */ + const void* getBlob() const noexcept; + /** + * @brief Return a std::string for a TEXT or BLOB column. + * + * Note this correctly handles strings that contain null bytes. + */ + std::string getString() const; + + /** + * @brief Return the type of the value of the column + * + * Return either SQLite::INTEGER, SQLite::FLOAT, SQLite::TEXT, SQLite::BLOB, or SQLite::Null. + * + * @warning After a type conversion (by a call to a getXxx on a Column of a Yyy type), + * the value returned by sqlite3_column_type() is undefined. + */ + int getType() const noexcept; + + /// Test if the column is an integer type value (meaningful only before any conversion) + bool isInteger() const noexcept + { + return (SQLite::INTEGER == getType()); + } + /// Test if the column is a floating point type value (meaningful only before any conversion) + bool isFloat() const noexcept + { + return (SQLite::FLOAT == getType()); + } + /// Test if the column is a text type value (meaningful only before any conversion) + bool isText() const noexcept + { + return (SQLite::TEXT == getType()); + } + /// Test if the column is a binary blob type value (meaningful only before any conversion) + bool isBlob() const noexcept + { + return (SQLite::BLOB == getType()); + } + /// Test if the column is NULL (meaningful only before any conversion) + bool isNull() const noexcept + { + return (SQLite::Null == getType()); + } + + /** + * @brief Return the number of bytes used by the text (or blob) value of the column + * + * Return either : + * - size in bytes (not in characters) of the string returned by getText() without the '\0' terminator + * - size in bytes of the string representation of the numerical value (integer or double) + * - size in bytes of the binary blob returned by getBlob() + * - 0 for a NULL value + */ + int getBytes() const noexcept; + + /// Alias returning the number of bytes used by the text (or blob) value of the column + int size() const noexcept + { + return getBytes (); + } + + /// Inline cast operator to char + operator char() const + { + return static_cast<char>(getInt()); + } + /// Inline cast operator to unsigned char + operator unsigned char() const + { + return static_cast<unsigned char>(getInt()); + } + /// Inline cast operator to short + operator short() const + { + return static_cast<short>(getInt()); + } + /// Inline cast operator to unsigned short + operator unsigned short() const + { + return static_cast<unsigned short>(getInt()); + } + + /// Inline cast operator to int + operator int() const + { + return getInt(); + } + /// Inline cast operator to 32bits unsigned integer + operator unsigned int() const + { + return getUInt(); + } +#if (LONG_MAX == INT_MAX) // 4 bytes "long" type means the data model is ILP32 or LLP64 (Win64 Visual C++ and MinGW) + /// Inline cast operator to 32bits long + operator long() const + { + return getInt(); + } + /// Inline cast operator to 32bits unsigned long + operator unsigned long() const + { + return getUInt(); + } +#else // 8 bytes "long" type means the data model is LP64 (Most Unix-like, Windows when using Cygwin; z/OS) + /// Inline cast operator to 64bits long when the data model of the system is LP64 (Linux 64 bits...) + operator long() const + { + return getInt64(); + } +#endif + + /// Inline cast operator to 64bits integer + operator long long() const + { + return getInt64(); + } + /// Inline cast operator to double + operator double() const + { + return getDouble(); + } + /** + * @brief Inline cast operator to char* + * + * @see getText + */ + operator const char*() const + { + return getText(); + } + /** + * @brief Inline cast operator to void* + * + * @see getBlob + */ + operator const void*() const + { + return getBlob(); + } + + /** + * @brief Inline cast operator to std::string + * + * Handles BLOB or TEXT, which may contain null bytes within + * + * @see getString + */ + operator std::string() const + { + return getString(); + } + +private: + Statement::TStatementPtr mStmtPtr; ///< Shared Pointer to the prepared SQLite Statement Object + int mIndex; ///< Index of the column in the row of result, starting at 0 +}; + +/** + * @brief Standard std::ostream text inserter + * + * Insert the text value of the Column object, using getText(), into the provided stream. + * + * @param[in] aStream Stream to use + * @param[in] aColumn Column object to insert into the provided stream + * + * @return Reference to the stream used + */ +std::ostream& operator<<(std::ostream& aStream, const Column& aColumn); + +#if __cplusplus >= 201402L || (defined(_MSC_VER) && _MSC_VER >= 1900) // c++14: Visual Studio 2015 + +// Create an instance of T from the first N columns, see declaration in Statement.h for full details +template<typename T, int N> +T Statement::getColumns() +{ + checkRow(); + checkIndex(N - 1); + return getColumns<T>(std::make_integer_sequence<int, N>{}); +} + +// Helper function called by getColums<typename T, int N> +template<typename T, const int... Is> +T Statement::getColumns(const std::integer_sequence<int, Is...>) +{ + return T{Column(mpPreparedStatement, Is)...}; +} + +#endif + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Database.cpp b/3rdparty/sqlitecpp/source/SQLiteCpp/Database.cpp new file mode 100644 index 0000000..eb76c88 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Database.cpp @@ -0,0 +1,452 @@ +/** + * @file Database.cpp + * @ingroup SQLiteCpp + * @brief Management of a SQLite Database Connection. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#include <SQLiteCpp/Database.h> + +#include <SQLiteCpp/Assertion.h> +#include <SQLiteCpp/Backup.h> +#include <SQLiteCpp/Exception.h> +#include <SQLiteCpp/Statement.h> + +#include <sqlite3.h> +#include <fstream> +#include <string.h> + +#ifndef SQLITE_DETERMINISTIC +#define SQLITE_DETERMINISTIC 0x800 +#endif // SQLITE_DETERMINISTIC + + +namespace SQLite +{ + +const int OPEN_READONLY = SQLITE_OPEN_READONLY; +const int OPEN_READWRITE = SQLITE_OPEN_READWRITE; +const int OPEN_CREATE = SQLITE_OPEN_CREATE; +const int OPEN_URI = SQLITE_OPEN_URI; +const int OPEN_MEMORY = SQLITE_OPEN_MEMORY; +const int OPEN_NOMUTEX = SQLITE_OPEN_NOMUTEX; +const int OPEN_FULLMUTEX = SQLITE_OPEN_FULLMUTEX; +const int OPEN_SHAREDCACHE = SQLITE_OPEN_SHAREDCACHE; +const int OPEN_PRIVATECACHE = SQLITE_OPEN_PRIVATECACHE; +#if SQLITE_VERSION_NUMBER >= 3031000 +const int OPEN_NOFOLLOW = SQLITE_OPEN_NOFOLLOW; +#else +const int OPEN_NOFOLLOW = 0; +#endif + +const int OK = SQLITE_OK; + +const char* VERSION = SQLITE_VERSION; +const int VERSION_NUMBER = SQLITE_VERSION_NUMBER; + +// Return SQLite version string using runtime call to the compiled library +const char* getLibVersion() noexcept +{ + return sqlite3_libversion(); +} + +// Return SQLite version number using runtime call to the compiled library +int getLibVersionNumber() noexcept +{ + return sqlite3_libversion_number(); +} + + +// Open the provided database UTF-8 filename with SQLite::OPEN_xxx provided flags. +Database::Database(const char* apFilename, + const int aFlags /* = SQLite::OPEN_READONLY*/, + const int aBusyTimeoutMs /* = 0 */, + const char* apVfs /* = nullptr*/) : + mFilename(apFilename) +{ + sqlite3* handle; + const int ret = sqlite3_open_v2(apFilename, &handle, aFlags, apVfs); + mSQLitePtr.reset(handle); + if (SQLITE_OK != ret) + { + throw SQLite::Exception(handle, ret); + } + if (aBusyTimeoutMs > 0) + { + setBusyTimeout(aBusyTimeoutMs); + } +} + +// Deleter functor to use with smart pointers to close the SQLite database connection in an RAII fashion. +void Database::Deleter::operator()(sqlite3* apSQLite) +{ + const int ret = sqlite3_close(apSQLite); // Calling sqlite3_close() with a nullptr argument is a harmless no-op. + + // Avoid unreferenced variable warning when build in release mode + (void) ret; + + // Only case of error is SQLITE_BUSY: "database is locked" (some statements are not finalized) + // Never throw an exception in a destructor : + SQLITECPP_ASSERT(SQLITE_OK == ret, "database is locked"); // See SQLITECPP_ENABLE_ASSERT_HANDLER +} + +/** + * @brief Set a busy handler that sleeps for a specified amount of time when a table is locked. + * + * This is useful in multithreaded program to handle case where a table is locked for writting by a thread. + * Any other thread cannot access the table and will receive a SQLITE_BUSY error: + * setting a timeout will wait and retry up to the time specified before returning this SQLITE_BUSY error. + * Reading the value of timeout for current connection can be done with SQL query "PRAGMA busy_timeout;". + * Default busy timeout is 0ms. + * + * @param[in] aBusyTimeoutMs Amount of milliseconds to wait before returning SQLITE_BUSY + * + * @throw SQLite::Exception in case of error + */ +void Database::setBusyTimeout(const int aBusyTimeoutMs) +{ + const int ret = sqlite3_busy_timeout(getHandle(), aBusyTimeoutMs); + check(ret); +} + +// Shortcut to execute one or multiple SQL statements without results (UPDATE, INSERT, ALTER, COMMIT, CREATE...). +// Return the number of changes. +int Database::exec(const char* apQueries) +{ + const int ret = tryExec(apQueries); + check(ret); + + // Return the number of rows modified by those SQL statements (INSERT, UPDATE or DELETE only) + return sqlite3_changes(getHandle()); +} + +int Database::tryExec(const char* apQueries) noexcept +{ + return sqlite3_exec(getHandle(), apQueries, nullptr, nullptr, nullptr); +} + +// Shortcut to execute a one step query and fetch the first column of the result. +// WARNING: Be very careful with this dangerous method: you have to +// make a COPY OF THE result, else it will be destroy before the next line +// (when the underlying temporary Statement and Column objects are destroyed) +// this is an issue only for pointer type result (ie. char* and blob) +// (use the Column copy-constructor) +Column Database::execAndGet(const char* apQuery) +{ + Statement query(*this, apQuery); + (void)query.executeStep(); // Can return false if no result, which will throw next line in getColumn() + return query.getColumn(0); +} + +// Shortcut to test if a table exists. +bool Database::tableExists(const char* apTableName) +{ + Statement query(*this, "SELECT count(*) FROM sqlite_master WHERE type='table' AND name=?"); + query.bind(1, apTableName); + (void)query.executeStep(); // Cannot return false, as the above query always return a result + return (1 == query.getColumn(0).getInt()); +} + +// Get the rowid of the most recent successful INSERT into the database from the current connection. +long long Database::getLastInsertRowid() const noexcept +{ + return sqlite3_last_insert_rowid(getHandle()); +} + +// Get number of rows modified by last INSERT, UPDATE or DELETE statement (not DROP table). +int Database::getChanges() const noexcept +{ + return sqlite3_changes(getHandle()); +} + +// Get total number of rows modified by all INSERT, UPDATE or DELETE statement since connection. +int Database::getTotalChanges() const noexcept +{ + return sqlite3_total_changes(getHandle()); +} + +// Return the numeric result code for the most recent failed API call (if any). +int Database::getErrorCode() const noexcept +{ + return sqlite3_errcode(getHandle()); +} + +// Return the extended numeric result code for the most recent failed API call (if any). +int Database::getExtendedErrorCode() const noexcept +{ + return sqlite3_extended_errcode(getHandle()); +} + +// Return UTF-8 encoded English language explanation of the most recent failed API call (if any). +const char* Database::getErrorMsg() const noexcept +{ + return sqlite3_errmsg(getHandle()); +} + +// Attach a custom function to your sqlite database. Assumes UTF8 text representation. +// Parameter details can be found here: http://www.sqlite.org/c3ref/create_function.html +void Database::createFunction(const char* apFuncName, + int aNbArg, + bool abDeterministic, + void* apApp, + void (*apFunc)(sqlite3_context *, int, sqlite3_value **), + void (*apStep)(sqlite3_context *, int, sqlite3_value **) /* = nullptr */, + void (*apFinal)(sqlite3_context *) /* = nullptr */, // NOLINT(readability/casting) + void (*apDestroy)(void *) /* = nullptr */) +{ + int textRep = SQLITE_UTF8; + // optimization if deterministic function (e.g. of nondeterministic function random()) + if (abDeterministic) + { + textRep = textRep | SQLITE_DETERMINISTIC; + } + const int ret = sqlite3_create_function_v2(getHandle(), apFuncName, aNbArg, textRep, + apApp, apFunc, apStep, apFinal, apDestroy); + check(ret); +} + +// Load an extension into the sqlite database. Only affects the current connection. +// Parameter details can be found here: http://www.sqlite.org/c3ref/load_extension.html +void Database::loadExtension(const char* apExtensionName, const char *apEntryPointName) +{ +#ifdef SQLITE_OMIT_LOAD_EXTENSION + // Unused + (void)apExtensionName; + (void)apEntryPointName; + + throw SQLite::Exception("sqlite extensions are disabled"); +#else +#ifdef SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION // Since SQLite 3.13 (2016-05-18): + // Security warning: + // It is recommended that the SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION method be used to enable only this interface. + // The use of the sqlite3_enable_load_extension() interface should be avoided to keep the SQL load_extension() + // disabled and prevent SQL injections from giving attackers access to extension loading capabilities. + // (NOTE: not using nullptr: cannot pass object of non-POD type 'std::__1::nullptr_t' through variadic function) + int ret = sqlite3_db_config(getHandle(), SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, NULL); // NOTE: not using nullptr +#else + int ret = sqlite3_enable_load_extension(getHandle(), 1); +#endif + check(ret); + + ret = sqlite3_load_extension(getHandle(), apExtensionName, apEntryPointName, 0); + check(ret); +#endif +} + +// Set the key for the current sqlite database instance. +void Database::key(const std::string& aKey) const +{ + int passLen = static_cast<int>(aKey.length()); +#ifdef SQLITE_HAS_CODEC + if (passLen > 0) + { + const int ret = sqlite3_key(getHandle(), aKey.c_str(), passLen); + check(ret); + } +#else // SQLITE_HAS_CODEC + if (passLen > 0) + { + throw SQLite::Exception("No encryption support, recompile with SQLITE_HAS_CODEC to enable."); + } +#endif // SQLITE_HAS_CODEC +} + +// Reset the key for the current sqlite database instance. +void Database::rekey(const std::string& aNewKey) const +{ +#ifdef SQLITE_HAS_CODEC + int passLen = aNewKey.length(); + if (passLen > 0) + { + const int ret = sqlite3_rekey(getHandle(), aNewKey.c_str(), passLen); + check(ret); + } + else + { + const int ret = sqlite3_rekey(getHandle(), nullptr, 0); + check(ret); + } +#else // SQLITE_HAS_CODEC + static_cast<void>(aNewKey); // silence unused parameter warning + throw SQLite::Exception("No encryption support, recompile with SQLITE_HAS_CODEC to enable."); +#endif // SQLITE_HAS_CODEC +} + +// Test if a file contains an unencrypted database. +bool Database::isUnencrypted(const std::string& aFilename) +{ + if (aFilename.empty()) + { + throw SQLite::Exception("Could not open database, the aFilename parameter was empty."); + } + + std::ifstream fileBuffer(aFilename.c_str(), std::ios::in | std::ios::binary); + char header[16]; + if (fileBuffer.is_open()) + { + fileBuffer.seekg(0, std::ios::beg); + fileBuffer.getline(header, 16); + fileBuffer.close(); + } + else + { + throw SQLite::Exception("Error opening file: " + aFilename); + } + + return strncmp(header, "SQLite format 3\000", 16) == 0; +} + +// Parse header data from a database. +Header Database::getHeaderInfo(const std::string& aFilename) +{ + Header h; + unsigned char buf[100]; + char* pBuf = reinterpret_cast<char*>(&buf[0]); + char* pHeaderStr = reinterpret_cast<char*>(&h.headerStr[0]); + + if (aFilename.empty()) + { + throw SQLite::Exception("Filename parameter is empty"); + } + + { + std::ifstream fileBuffer(aFilename.c_str(), std::ios::in | std::ios::binary); + if (fileBuffer.is_open()) + { + fileBuffer.seekg(0, std::ios::beg); + fileBuffer.read(pBuf, 100); + fileBuffer.close(); + if (fileBuffer.gcount() < 100) + { + throw SQLite::Exception("File " + aFilename + " is too short"); + } + } + else + { + throw SQLite::Exception("Error opening file " + aFilename); + } + } + + // If the "magic string" can't be found then header is invalid, corrupt or unreadable + memcpy(pHeaderStr, pBuf, 16); + pHeaderStr[15] = '\0'; + if (strncmp(pHeaderStr, "SQLite format 3", 15) != 0) + { + throw SQLite::Exception("Invalid or encrypted SQLite header in file " + aFilename); + } + + h.pageSizeBytes = (buf[16] << 8) | buf[17]; + h.fileFormatWriteVersion = buf[18]; + h.fileFormatReadVersion = buf[19]; + h.reservedSpaceBytes = buf[20]; + h.maxEmbeddedPayloadFrac = buf[21]; + h.minEmbeddedPayloadFrac = buf[22]; + h.leafPayloadFrac = buf[23]; + + h.fileChangeCounter = + (buf[24] << 24) | + (buf[25] << 16) | + (buf[26] << 8) | + (buf[27] << 0); + + h.databaseSizePages = + (buf[28] << 24) | + (buf[29] << 16) | + (buf[30] << 8) | + (buf[31] << 0); + + h.firstFreelistTrunkPage = + (buf[32] << 24) | + (buf[33] << 16) | + (buf[34] << 8) | + (buf[35] << 0); + + h.totalFreelistPages = + (buf[36] << 24) | + (buf[37] << 16) | + (buf[38] << 8) | + (buf[39] << 0); + + h.schemaCookie = + (buf[40] << 24) | + (buf[41] << 16) | + (buf[42] << 8) | + (buf[43] << 0); + + h.schemaFormatNumber = + (buf[44] << 24) | + (buf[45] << 16) | + (buf[46] << 8) | + (buf[47] << 0); + + h.defaultPageCacheSizeBytes = + (buf[48] << 24) | + (buf[49] << 16) | + (buf[50] << 8) | + (buf[51] << 0); + + h.largestBTreePageNumber = + (buf[52] << 24) | + (buf[53] << 16) | + (buf[54] << 8) | + (buf[55] << 0); + + h.databaseTextEncoding = + (buf[56] << 24) | + (buf[57] << 16) | + (buf[58] << 8) | + (buf[59] << 0); + + h.userVersion = + (buf[60] << 24) | + (buf[61] << 16) | + (buf[62] << 8) | + (buf[63] << 0); + + h.incrementalVaccumMode = + (buf[64] << 24) | + (buf[65] << 16) | + (buf[66] << 8) | + (buf[67] << 0); + + h.applicationId = + (buf[68] << 24) | + (buf[69] << 16) | + (buf[70] << 8) | + (buf[71] << 0); + + h.versionValidFor = + (buf[92] << 24) | + (buf[93] << 16) | + (buf[94] << 8) | + (buf[95] << 0); + + h.sqliteVersion = + (buf[96] << 24) | + (buf[97] << 16) | + (buf[98] << 8) | + (buf[99] << 0); + + return h; +} + +void Database::backup(const char* apFilename, BackupType aType) +{ + // Open the database file identified by apFilename + Database otherDatabase(apFilename, SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE); + + // For a 'Save' operation, data is copied from the current Database to the other. A 'Load' is the reverse. + Database& src = (aType == Save ? *this : otherDatabase); + Database& dest = (aType == Save ? otherDatabase : *this); + + // Set up the backup procedure to copy between the "main" databases of each connection + Backup bkp(dest, src); + bkp.executeStep(); // Execute all steps at once + + // RAII Finish Backup an Close the other Database +} + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Database.h b/3rdparty/sqlitecpp/source/SQLiteCpp/Database.h new file mode 100644 index 0000000..7ee45d8 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Database.h @@ -0,0 +1,594 @@ +/** + * @file Database.h + * @ingroup SQLiteCpp + * @brief Management of a SQLite Database Connection. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#include <SQLiteCpp/Column.h> + +// c++17: MinGW GCC version > 8 +// c++17: Visual Studio 2017 version 15.7 +// c++17: macOS unless targetting compatibility with macOS < 10.15 +#if __cplusplus >= 201703L + #if defined(__MINGW32__) || defined(__MINGW64__) + #if __GNUC__ > 8 // MinGW requires GCC version > 8 for std::filesystem + #define SQLITECPP_HAVE_STD_FILESYSTEM + #endif + #elif defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + // macOS clang won't less us touch std::filesystem if we're targetting earlier than 10.15 + #else + #define SQLITECPP_HAVE_STD_FILESYSTEM + #endif +#elif defined(_MSVC_LANG) && _MSVC_LANG >= 201703L + #define SQLITECPP_HAVE_STD_FILESYSTEM +#endif + +#ifdef SQLITECPP_HAVE_STD_FILESYSTEM +#include <filesystem> +#endif // c++17 and a suitable compiler + +#include <memory> +#include <string.h> + +// Forward declarations to avoid inclusion of <sqlite3.h> in a header +struct sqlite3; +struct sqlite3_context; + +#ifndef SQLITE_USE_LEGACY_STRUCT // Since SQLITE 3.19 (used by default since SQLiteCpp 2.1.0) +typedef struct sqlite3_value sqlite3_value; +#else // Before SQLite 3.19 (legacy struct forward declaration can be activated with CMake SQLITECPP_LEGACY_STRUCT var) +struct Mem; +typedef struct Mem sqlite3_value; +#endif + + +namespace SQLite +{ + +// Those public constants enable most usages of SQLiteCpp without including <sqlite3.h> in the client application. + +/// The database is opened in read-only mode. If the database does not already exist, an error is returned. +extern const int OPEN_READONLY; // SQLITE_OPEN_READONLY +/// The database is opened for reading and writing if possible, or reading only if the file is write protected +/// by the operating system. In either case the database must already exist, otherwise an error is returned. +extern const int OPEN_READWRITE; // SQLITE_OPEN_READWRITE +/// With OPEN_READWRITE: The database is opened for reading and writing, and is created if it does not already exist. +extern const int OPEN_CREATE; // SQLITE_OPEN_CREATE +/// Enable URI filename interpretation, parsed according to RFC 3986 (ex. "file:data.db?mode=ro&cache=private") +extern const int OPEN_URI; // SQLITE_OPEN_URI +/// Open in memory database +extern const int OPEN_MEMORY; // SQLITE_OPEN_MEMORY +/// Open database in multi-thread threading mode +extern const int OPEN_NOMUTEX; // SQLITE_OPEN_NOMUTEX +/// Open database with thread-safety in serialized threading mode +extern const int OPEN_FULLMUTEX; // SQLITE_OPEN_FULLMUTEX +/// Open database with shared cache enabled +extern const int OPEN_SHAREDCACHE; // SQLITE_OPEN_SHAREDCACHE +/// Open database with shared cache disabled +extern const int OPEN_PRIVATECACHE; // SQLITE_OPEN_PRIVATECACHE +/// Database filename is not allowed to be a symbolic link (Note: only since SQlite 3.31.0 from 2020-01-22) +extern const int OPEN_NOFOLLOW; // SQLITE_OPEN_NOFOLLOW + + +extern const int OK; ///< SQLITE_OK (used by check() bellow) + +extern const char* VERSION; ///< SQLITE_VERSION string from the sqlite3.h used at compile time +extern const int VERSION_NUMBER; ///< SQLITE_VERSION_NUMBER from the sqlite3.h used at compile time + +/// Return SQLite version string using runtime call to the compiled library +const char* getLibVersion() noexcept; +/// Return SQLite version number using runtime call to the compiled library +int getLibVersionNumber() noexcept; + +// Public structure for representing all fields contained within the SQLite header. +// Official documentation for fields: https://www.sqlite.org/fileformat.html#the_database_header +struct Header { + unsigned char headerStr[16]; + unsigned int pageSizeBytes; + unsigned char fileFormatWriteVersion; + unsigned char fileFormatReadVersion; + unsigned char reservedSpaceBytes; + unsigned char maxEmbeddedPayloadFrac; + unsigned char minEmbeddedPayloadFrac; + unsigned char leafPayloadFrac; + unsigned long fileChangeCounter; + unsigned long databaseSizePages; + unsigned long firstFreelistTrunkPage; + unsigned long totalFreelistPages; + unsigned long schemaCookie; + unsigned long schemaFormatNumber; + unsigned long defaultPageCacheSizeBytes; + unsigned long largestBTreePageNumber; + unsigned long databaseTextEncoding; + unsigned long userVersion; + unsigned long incrementalVaccumMode; + unsigned long applicationId; + unsigned long versionValidFor; + unsigned long sqliteVersion; +}; + +/** + * @brief RAII management of a SQLite Database Connection. + * + * A Database object manage a list of all SQLite Statements associated with the + * underlying SQLite 3 database connection. + * + * Resource Acquisition Is Initialization (RAII) means that the Database Connection + * is opened in the constructor and closed in the destructor, so that there is + * no need to worry about memory management or the validity of the underlying SQLite Connection. + * + * Thread-safety: a Database object shall not be shared by multiple threads, because : + * 1) in the SQLite "Thread Safe" mode, "SQLite can be safely used by multiple threads + * provided that no single database connection is used simultaneously in two or more threads." + * 2) the SQLite "Serialized" mode is not supported by SQLiteC++, + * because of the way it shares the underling SQLite precompiled statement + * in a custom shared pointer (See the inner class "Statement::Ptr"). + */ +class Database +{ + friend class Statement; // Give Statement constructor access to the mSQLitePtr Connection Handle + +public: + /** + * @brief Open the provided database UTF-8 filename. + * + * Uses sqlite3_open_v2() with readonly default flag, which is the opposite behavior + * of the old sqlite3_open() function (READWRITE+CREATE). + * This makes sense if you want to use it on a readonly filesystem + * or to prevent creation of a void file when a required file is missing. + * + * Exception is thrown in case of error, then the Database object is NOT constructed. + * + * @param[in] apFilename UTF-8 path/uri to the database file ("filename" sqlite3 parameter) + * @param[in] aFlags SQLite::OPEN_READONLY/SQLite::OPEN_READWRITE/SQLite::OPEN_CREATE... + * @param[in] aBusyTimeoutMs Amount of milliseconds to wait before returning SQLITE_BUSY (see setBusyTimeout()) + * @param[in] apVfs UTF-8 name of custom VFS to use, or nullptr for sqlite3 default + * + * @throw SQLite::Exception in case of error + */ + Database(const char* apFilename, + const int aFlags = SQLite::OPEN_READONLY, + const int aBusyTimeoutMs = 0, + const char* apVfs = nullptr); + + /** + * @brief Open the provided database UTF-8 filename. + * + * Uses sqlite3_open_v2() with readonly default flag, which is the opposite behavior + * of the old sqlite3_open() function (READWRITE+CREATE). + * This makes sense if you want to use it on a readonly filesystem + * or to prevent creation of a void file when a required file is missing. + * + * Exception is thrown in case of error, then the Database object is NOT constructed. + * + * @param[in] aFilename UTF-8 path/uri to the database file ("filename" sqlite3 parameter) + * @param[in] aFlags SQLite::OPEN_READONLY/SQLite::OPEN_READWRITE/SQLite::OPEN_CREATE... + * @param[in] aBusyTimeoutMs Amount of milliseconds to wait before returning SQLITE_BUSY (see setBusyTimeout()) + * @param[in] aVfs UTF-8 name of custom VFS to use, or empty string for sqlite3 default + * + * @throw SQLite::Exception in case of error + */ + Database(const std::string& aFilename, + const int aFlags = SQLite::OPEN_READONLY, + const int aBusyTimeoutMs = 0, + const std::string& aVfs = "") : + Database(aFilename.c_str(), aFlags, aBusyTimeoutMs, aVfs.empty() ? nullptr : aVfs.c_str()) + { + } + + #ifdef SQLITECPP_HAVE_STD_FILESYSTEM + + /** + * @brief Open the provided database std::filesystem::path. + * + * @note This feature requires std=C++17 + * + * Uses sqlite3_open_v2() with readonly default flag, which is the opposite behavior + * of the old sqlite3_open() function (READWRITE+CREATE). + * This makes sense if you want to use it on a readonly filesystem + * or to prevent creation of a void file when a required file is missing. + * + * Exception is thrown in case of error, then the Database object is NOT constructed. + * + * @param[in] apFilename Path/uri to the database file ("filename" sqlite3 parameter) + * @param[in] aFlags SQLite::OPEN_READONLY/SQLite::OPEN_READWRITE/SQLite::OPEN_CREATE... + * @param[in] aBusyTimeoutMs Amount of milliseconds to wait before returning SQLITE_BUSY (see setBusyTimeout()) + * @param[in] apVfs UTF-8 name of custom VFS to use, or nullptr for sqlite3 default + * + * @throw SQLite::Exception in case of error + */ + Database(const std::filesystem::path& apFilename, + const int aFlags = SQLite::OPEN_READONLY, + const int aBusyTimeoutMs = 0, + const std::string& aVfs = "") : + Database(reinterpret_cast<const char*>(apFilename.u8string().c_str()), + aFlags, aBusyTimeoutMs, aVfs.empty() ? nullptr : aVfs.c_str()) + { + } + + #endif // have std::filesystem + + // Database is non-copyable + Database(const Database&) = delete; + Database& operator=(const Database&) = delete; + + // Database is movable + Database(Database&& aDatabase) = default; + Database& operator=(Database&& aDatabase) = default; + + /** + * @brief Close the SQLite database connection. + * + * All SQLite statements must have been finalized before, + * so all Statement objects must have been unregistered. + * + * @warning assert in case of error + */ + ~Database() = default; + + // Deleter functor to use with smart pointers to close the SQLite database connection in an RAII fashion. + struct Deleter + { + void operator()(sqlite3* apSQLite); + }; + + /** + * @brief Set a busy handler that sleeps for a specified amount of time when a table is locked. + * + * This is useful in multithreaded program to handle case where a table is locked for writing by a thread. + * Any other thread cannot access the table and will receive a SQLITE_BUSY error: + * setting a timeout will wait and retry up to the time specified before returning this SQLITE_BUSY error. + * Reading the value of timeout for current connection can be done with SQL query "PRAGMA busy_timeout;". + * Default busy timeout is 0ms. + * + * @param[in] aBusyTimeoutMs Amount of milliseconds to wait before returning SQLITE_BUSY + * + * @throw SQLite::Exception in case of error + */ + void setBusyTimeout(const int aBusyTimeoutMs); + + /** + * @brief Shortcut to execute one or multiple statements without results. Return the number of changes. + * + * This is useful for any kind of statements other than the Data Query Language (DQL) "SELECT" : + * - Data Manipulation Language (DML) statements "INSERT", "UPDATE" and "DELETE" + * - Data Definition Language (DDL) statements "CREATE", "ALTER" and "DROP" + * - Data Control Language (DCL) statements "GRANT", "REVOKE", "COMMIT" and "ROLLBACK" + * + * @see Database::tryExec() to execute, returning the sqlite result code + * @see Statement::exec() to handle precompiled statements (for better performances) without results + * @see Statement::executeStep() to handle "SELECT" queries with results + * + * @param[in] apQueries one or multiple UTF-8 encoded, semicolon-separate SQL statements + * + * @return number of rows modified by the *last* INSERT, UPDATE or DELETE statement (beware of multiple statements) + * @warning undefined for CREATE or DROP table: returns the value of a previous INSERT, UPDATE or DELETE statement. + * + * @throw SQLite::Exception in case of error + */ + int exec(const char* apQueries); + + /** + * @brief Shortcut to execute one or multiple statements without results. + * + * This is useful for any kind of statements other than the Data Query Language (DQL) "SELECT" : + * - Data Manipulation Language (DML) statements "INSERT", "UPDATE" and "DELETE" + * - Data Definition Language (DDL) statements "CREATE", "ALTER" and "DROP" + * - Data Control Language (DCL) statements "GRANT", "REVOKE", "COMMIT" and "ROLLBACK" + * + * @see Database::tryExec() to execute, returning the sqlite result code + * @see Statement::exec() to handle precompiled statements (for better performances) without results + * @see Statement::executeStep() to handle "SELECT" queries with results + * + * @param[in] aQueries one or multiple UTF-8 encoded, semicolon-separate SQL statements + * + * @return number of rows modified by the *last* INSERT, UPDATE or DELETE statement (beware of multiple statements) + * @warning undefined for CREATE or DROP table: returns the value of a previous INSERT, UPDATE or DELETE statement. + * + * @throw SQLite::Exception in case of error + */ + int exec(const std::string& aQueries) + { + return exec(aQueries.c_str()); + } + + /** + * @brief Try to execute one or multiple statements, returning the sqlite result code. + * + * This is useful for any kind of statements other than the Data Query Language (DQL) "SELECT" : + * - Data Manipulation Language (DML) statements "INSERT", "UPDATE" and "DELETE" + * - Data Definition Language (DDL) statements "CREATE", "ALTER" and "DROP" + * - Data Control Language (DCL) statements "GRANT", "REVOKE", "COMMIT" and "ROLLBACK" + * + * @see exec() to execute, returning number of rows modified + * + * @param[in] aQueries one or multiple UTF-8 encoded, semicolon-separate SQL statements + * + * @return the sqlite result code. + */ + int tryExec(const char* apQueries) noexcept; + + /** + * @brief Try to execute one or multiple statements, returning the sqlite result code. + * + * This is useful for any kind of statements other than the Data Query Language (DQL) "SELECT" : + * - Data Manipulation Language (DML) statements "INSERT", "UPDATE" and "DELETE" + * - Data Definition Language (DDL) statements "CREATE", "ALTER" and "DROP" + * - Data Control Language (DCL) statements "GRANT", "REVOKE", "COMMIT" and "ROLLBACK" + * + * @see exec() to execute, returning number of rows modified + * + * @param[in] aQueries one or multiple UTF-8 encoded, semicolon-separate SQL statements + * + * @return the sqlite result code. + */ + int tryExec(const std::string aQueries) noexcept + { + return tryExec(aQueries.c_str()); + } + + /** + * @brief Shortcut to execute a one step query and fetch the first column of the result. + * + * This is a shortcut to execute a simple statement with a single result. + * This should be used only for non reusable queries (else you should use a Statement with bind()). + * This should be used only for queries with expected results (else an exception is fired). + * + * @warning WARNING: Be very careful with this dangerous method: you have to + * make a COPY OF THE result, else it will be destroy before the next line + * (when the underlying temporary Statement and Column objects are destroyed) + * + * @see also Statement class for handling queries with multiple results + * + * @param[in] apQuery an UTF-8 encoded SQL query + * + * @return a temporary Column object with the first column of result. + * + * @throw SQLite::Exception in case of error + */ + Column execAndGet(const char* apQuery); + + /** + * @brief Shortcut to execute a one step query and fetch the first column of the result. + * + * This is a shortcut to execute a simple statement with a single result. + * This should be used only for non reusable queries (else you should use a Statement with bind()). + * This should be used only for queries with expected results (else an exception is fired). + * + * @warning WARNING: Be very careful with this dangerous method: you have to + * make a COPY OF THE result, else it will be destroy before the next line + * (when the underlying temporary Statement and Column objects are destroyed) + * + * @see also Statement class for handling queries with multiple results + * + * @param[in] aQuery an UTF-8 encoded SQL query + * + * @return a temporary Column object with the first column of result. + * + * @throw SQLite::Exception in case of error + */ + Column execAndGet(const std::string& aQuery) + { + return execAndGet(aQuery.c_str()); + } + + /** + * @brief Shortcut to test if a table exists. + * + * Table names are case sensitive. + * + * @param[in] apTableName an UTF-8 encoded case sensitive Table name + * + * @return true if the table exists. + * + * @throw SQLite::Exception in case of error + */ + bool tableExists(const char* apTableName); + + /** + * @brief Shortcut to test if a table exists. + * + * Table names are case sensitive. + * + * @param[in] aTableName an UTF-8 encoded case sensitive Table name + * + * @return true if the table exists. + * + * @throw SQLite::Exception in case of error + */ + bool tableExists(const std::string& aTableName) + { + return tableExists(aTableName.c_str()); + } + + /** + * @brief Get the rowid of the most recent successful INSERT into the database from the current connection. + * + * Each entry in an SQLite table always has a unique 64-bit signed integer key called the rowid. + * If the table has a column of type INTEGER PRIMARY KEY, then it is an alias for the rowid. + * + * @return Rowid of the most recent successful INSERT into the database, or 0 if there was none. + */ + long long getLastInsertRowid() const noexcept; + + /// Get number of rows modified by last INSERT, UPDATE or DELETE statement (not DROP table). + int getChanges() const noexcept; + + /// Get total number of rows modified by all INSERT, UPDATE or DELETE statement since connection (not DROP table). + int getTotalChanges() const noexcept; + + /// Return the numeric result code for the most recent failed API call (if any). + int getErrorCode() const noexcept; + /// Return the extended numeric result code for the most recent failed API call (if any). + int getExtendedErrorCode() const noexcept; + /// Return UTF-8 encoded English language explanation of the most recent failed API call (if any). + const char* getErrorMsg() const noexcept; + + /// Return the filename used to open the database. + const std::string& getFilename() const noexcept + { + return mFilename; + } + + /** + * @brief Return raw pointer to SQLite Database Connection Handle. + * + * This is often needed to mix this wrapper with other libraries or for advance usage not supported by SQLiteCpp. + */ + sqlite3* getHandle() const noexcept + { + return mSQLitePtr.get(); + } + + /** + * @brief Create or redefine a SQL function or aggregate in the sqlite database. + * + * This is the equivalent of the sqlite3_create_function_v2 command. + * @see http://www.sqlite.org/c3ref/create_function.html + * + * @note UTF-8 text encoding assumed. + * + * @param[in] apFuncName Name of the SQL function to be created or redefined + * @param[in] aNbArg Number of arguments in the function + * @param[in] abDeterministic Optimize for deterministic functions (most are). A random number generator is not. + * @param[in] apApp Arbitrary pointer of user data, accessible with sqlite3_user_data(). + * @param[in] apFunc Pointer to a C-function to implement a scalar SQL function (apStep & apFinal nullptr) + * @param[in] apStep Pointer to a C-function to implement an aggregate SQL function (apFunc nullptr) + * @param[in] apFinal Pointer to a C-function to implement an aggregate SQL function (apFunc nullptr) + * @param[in] apDestroy If not nullptr, then it is the destructor for the application data pointer. + * + * @throw SQLite::Exception in case of error + */ + void createFunction(const char* apFuncName, + int aNbArg, + bool abDeterministic, + void* apApp, + void (*apFunc)(sqlite3_context *, int, sqlite3_value **), + void (*apStep)(sqlite3_context *, int, sqlite3_value **) = nullptr, + void (*apFinal)(sqlite3_context *) = nullptr, // NOLINT(readability/casting) + void (*apDestroy)(void *) = nullptr); + + /** + * @brief Load a module into the current sqlite database instance. + * + * This is the equivalent of the sqlite3_load_extension call, but additionally enables + * module loading support prior to loading the requested module. + * + * @see http://www.sqlite.org/c3ref/load_extension.html + * + * @note UTF-8 text encoding assumed. + * + * @param[in] apExtensionName Name of the shared library containing extension + * @param[in] apEntryPointName Name of the entry point (nullptr to let sqlite work it out) + * + * @throw SQLite::Exception in case of error + */ + void loadExtension(const char* apExtensionName, const char* apEntryPointName); + + /** + * @brief Set the key for the current sqlite database instance. + * + * This is the equivalent of the sqlite3_key call and should thus be called + * directly after opening the database. + * Open encrypted database -> call db.key("secret") -> database ready + * + * @param[in] aKey Key to decode/encode the database + * + * @throw SQLite::Exception in case of error + */ + void key(const std::string& aKey) const; + + /** + * @brief Reset the key for the current sqlite database instance. + * + * This is the equivalent of the sqlite3_rekey call and should thus be called + * after the database has been opened with a valid key. To decrypt a + * database, call this method with an empty string. + * Open normal database -> call db.rekey("secret") -> encrypted database, database ready + * Open encrypted database -> call db.key("secret") -> call db.rekey("newsecret") -> change key, database ready + * Open encrypted database -> call db.key("secret") -> call db.rekey("") -> decrypted database, database ready + * + * @param[in] aNewKey New key to encode the database + * + * @throw SQLite::Exception in case of error + */ + void rekey(const std::string& aNewKey) const; + + /** + * @brief Test if a file contains an unencrypted database. + * + * This is a simple test that reads the first bytes of a database file and + * compares them to the standard header for unencrypted databases. If the + * header does not match the standard string, we assume that we have an + * encrypted file. + * + * @param[in] aFilename path/uri to a file + * + * @return true if the database has the standard header. + * + * @throw SQLite::Exception in case of error + */ + static bool isUnencrypted(const std::string& aFilename); + + /** + * @brief Parse SQLite header data from a database file. + * + * This function reads the first 100 bytes of a SQLite database file + * and reconstructs groups of individual bytes into the associated fields + * in a Header object. + * + * @param[in] aFilename path/uri to a file + * + * @return Header object containing file data + * + * @throw SQLite::Exception in case of error + */ + static Header getHeaderInfo(const std::string& aFilename); + + // Parse SQLite header data from a database file. + Header getHeaderInfo() + { + return getHeaderInfo(mFilename); + } + + /** + * @brief BackupType for the backup() method + */ + enum BackupType { Save, Load }; + + /** + * @brief Load or save the database content. + * + * This function is used to load the contents of a database file on disk + * into the "main" database of open database connection, or to save the current + * contents of the database into a database file on disk. + * + * @throw SQLite::Exception in case of error + */ + void backup(const char* apFilename, BackupType aType); + + /** + * @brief Check if aRet equal SQLITE_OK, else throw a SQLite::Exception with the SQLite error message + */ + void check(const int aRet) const + { + if (SQLite::OK != aRet) + { + throw SQLite::Exception(getHandle(), aRet); + } + } + +private: + // TODO: perhaps switch to having Statement sharing a pointer to the Connexion + std::unique_ptr<sqlite3, Deleter> mSQLitePtr; ///< Pointer to SQLite Database Connection Handle + std::string mFilename; ///< UTF-8 filename used to open the database +}; + + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Exception.cpp b/3rdparty/sqlitecpp/source/SQLiteCpp/Exception.cpp new file mode 100644 index 0000000..0dc644f --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Exception.cpp @@ -0,0 +1,47 @@ +/** + * @file Exception.cpp + * @ingroup SQLiteCpp + * @brief Encapsulation of the error message from SQLite3 on a std::runtime_error. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#include <SQLiteCpp/Exception.h> + +#include <sqlite3.h> + + +namespace SQLite +{ + +Exception::Exception(const char* aErrorMessage, int ret) : + std::runtime_error(aErrorMessage), + mErrcode(ret), + mExtendedErrcode(-1) +{ +} + +Exception::Exception(sqlite3* apSQLite) : + std::runtime_error(sqlite3_errmsg(apSQLite)), + mErrcode(sqlite3_errcode(apSQLite)), + mExtendedErrcode(sqlite3_extended_errcode(apSQLite)) +{ +} + +Exception::Exception(sqlite3* apSQLite, int ret) : + std::runtime_error(sqlite3_errmsg(apSQLite)), + mErrcode(ret), + mExtendedErrcode(sqlite3_extended_errcode(apSQLite)) +{ +} + +// Return a string, solely based on the error code +const char* Exception::getErrorStr() const noexcept +{ + return sqlite3_errstr(mErrcode); +} + + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Exception.h b/3rdparty/sqlitecpp/source/SQLiteCpp/Exception.h new file mode 100644 index 0000000..efd6356 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Exception.h @@ -0,0 +1,92 @@ +/** + * @file Exception.h + * @ingroup SQLiteCpp + * @brief Encapsulation of the error message from SQLite3 on a std::runtime_error. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#include <stdexcept> +#include <string> + +// Forward declaration to avoid inclusion of <sqlite3.h> in a header +struct sqlite3; + +namespace SQLite +{ + + +/** + * @brief Encapsulation of the error message from SQLite3, based on std::runtime_error. + */ +class Exception : public std::runtime_error +{ +public: + /** + * @brief Encapsulation of the error message from SQLite3, based on std::runtime_error. + * + * @param[in] aErrorMessage The string message describing the SQLite error + * @param[in] ret Return value from function call that failed. + */ + Exception(const char* aErrorMessage, int ret); + + Exception(const std::string& aErrorMessage, int ret) : + Exception(aErrorMessage.c_str(), ret) + { + } + + /** + * @brief Encapsulation of the error message from SQLite3, based on std::runtime_error. + * + * @param[in] aErrorMessage The string message describing the SQLite error + */ + explicit Exception(const char* aErrorMessage) : + Exception(aErrorMessage, -1) // 0 would be SQLITE_OK, which doesn't make sense + { + } + explicit Exception(const std::string& aErrorMessage) : + Exception(aErrorMessage.c_str(), -1) // 0 would be SQLITE_OK, which doesn't make sense + { + } + + /** + * @brief Encapsulation of the error message from SQLite3, based on std::runtime_error. + * + * @param[in] apSQLite The SQLite object, to obtain detailed error messages from. + */ + explicit Exception(sqlite3* apSQLite); + + /** + * @brief Encapsulation of the error message from SQLite3, based on std::runtime_error. + * + * @param[in] apSQLite The SQLite object, to obtain detailed error messages from. + * @param[in] ret Return value from function call that failed. + */ + Exception(sqlite3* apSQLite, int ret); + + /// Return the result code (if any, otherwise -1). + int getErrorCode() const noexcept + { + return mErrcode; + } + + /// Return the extended numeric result code (if any, otherwise -1). + int getExtendedErrorCode() const noexcept + { + return mExtendedErrcode; + } + + /// Return a string, solely based on the error code + const char* getErrorStr() const noexcept; + +private: + int mErrcode; ///< Error code value + int mExtendedErrcode; ///< Detailed error code if any +}; + + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/ExecuteMany.h b/3rdparty/sqlitecpp/source/SQLiteCpp/ExecuteMany.h new file mode 100644 index 0000000..4e7dac9 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/ExecuteMany.h @@ -0,0 +1,90 @@ +/** + * @file ExecuteMany.h + * @ingroup SQLiteCpp + * @brief Convenience function to execute a Statement with multiple Parameter sets + * + * Copyright (c) 2019 Maximilian Bachmann ([email protected]) + * Copyright (c) 2019-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#if (__cplusplus >= 201402L) || ( defined(_MSC_VER) && (_MSC_VER >= 1900) ) // c++14: Visual Studio 2015 + +#include <SQLiteCpp/Statement.h> +#include <SQLiteCpp/VariadicBind.h> + +/// @cond +#include <tuple> +#include <utility> +#include <initializer_list> + +namespace SQLite +{ +/// @endcond + +/** + * \brief Convenience function to execute a Statement with multiple Parameter sets once for each parameter set given. + * + * + * This feature requires a c++14 capable compiler. + * + * \code{.cpp} + * execute_many(db, "INSERT INTO test VALUES (?, ?)", + * 1, + * std::make_tuple(2), + * std::make_tuple(3, "three") + * ); + * \endcode + * @param aDatabase Database to use + * @param apQuery Query to use with all parameter sets + * @param aArg first tuple with parameters + * @param aParams the following tuples with parameters + */ +template <typename Arg, typename... Types> +void execute_many(Database& aDatabase, const char* apQuery, Arg&& aArg, Types&&... aParams) +{ + SQLite::Statement query(aDatabase, apQuery); + bind_exec(query, std::forward<Arg>(aArg)); + (void)std::initializer_list<int> + { + ((void)reset_bind_exec(query, std::forward<Types>(aParams)), 0)... + }; +} + +/** + * \brief Convenience function to reset a statement and call bind_exec to + * bind new values to the statement and execute it + * + * This feature requires a c++14 capable compiler. + * + * @param apQuery Query to use + * @param aTuple Tuple to bind + */ +template <typename TupleT> +void reset_bind_exec(Statement& apQuery, TupleT&& aTuple) +{ + apQuery.reset(); + bind_exec(apQuery, std::forward<TupleT>(aTuple)); +} + +/** + * \brief Convenience function to bind values a the statement and execute it + * + * This feature requires a c++14 capable compiler. + * + * @param apQuery Query to use + * @param aTuple Tuple to bind + */ +template <typename TupleT> +void bind_exec(Statement& apQuery, TupleT&& aTuple) +{ + SQLite::bind(apQuery, std::forward<TupleT>(aTuple)); + while (apQuery.executeStep()) {} +} + +} // namespace SQLite + +#endif // c++14 diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/SQLiteCpp.h b/3rdparty/sqlitecpp/source/SQLiteCpp/SQLiteCpp.h new file mode 100644 index 0000000..161478c --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/SQLiteCpp.h @@ -0,0 +1,44 @@ +/** + * @file SQLiteCpp.h + * @ingroup SQLiteCpp + * @brief SQLiteC++ is a smart and simple C++ SQLite3 wrapper. This file is only "easy include" for other files. + * + * Include this main header file in your project to gain access to all functionality provided by the wrapper. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +/** + * @defgroup SQLiteCpp SQLiteC++ + * @brief SQLiteC++ is a smart and simple C++ SQLite3 wrapper. This file is only "easy include" for other files. + */ +#pragma once + + +// Include useful headers of SQLiteC++ +#include <SQLiteCpp/Assertion.h> +#include <SQLiteCpp/Exception.h> +#include <SQLiteCpp/Database.h> +#include <SQLiteCpp/Statement.h> +#include <SQLiteCpp/Column.h> +#include <SQLiteCpp/Transaction.h> + + +/** + * @brief Version numbers for SQLiteC++ are provided in the same way as sqlite3.h + * + * The [SQLITECPP_VERSION] C preprocessor macro in the SQLiteC++.h header + * evaluates to a string literal that is the SQLite version in the + * format "X.Y.Z" where X is the major version number + * and Y is the minor version number and Z is the release number. + * + * The [SQLITECPP_VERSION_NUMBER] C preprocessor macro resolves to an integer + * with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same + * numbers used in [SQLITECPP_VERSION]. + * + * WARNING: shall always be updated in sync with PROJECT_VERSION in CMakeLists.txt + */ +#define SQLITECPP_VERSION "3.01.01" // 3.1.1 +#define SQLITECPP_VERSION_NUMBER 3001001 // 3.1.1 diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Savepoint.cpp b/3rdparty/sqlitecpp/source/SQLiteCpp/Savepoint.cpp new file mode 100644 index 0000000..b3d13a2 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Savepoint.cpp @@ -0,0 +1,65 @@ +/** + * @file Savepoint.cpp + * @ingroup SQLiteCpp + * @brief A Savepoint is a way to group multiple SQL statements into an atomic + * secured operation. Similar to a transaction while allowing child savepoints. + * + * Copyright (c) 2020 Kelvin Hammond ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt or + * copy at http://opensource.org/licenses/MIT) + */ + +#include <SQLiteCpp/Assertion.h> +#include <SQLiteCpp/Database.h> +#include <SQLiteCpp/Savepoint.h> +#include <SQLiteCpp/Statement.h> + +namespace SQLite { + +// Begins the SQLite savepoint +Savepoint::Savepoint(Database& aDatabase, std::string aName) + : mDatabase(aDatabase), msName(aName), mbReleased(false) { + // workaround because you cannot bind to SAVEPOINT + // escape name for use in query + Statement stmt(mDatabase, "SELECT quote(?)"); + stmt.bind(1, msName); + stmt.executeStep(); + msName = stmt.getColumn(0).getText(); + + mDatabase.exec(std::string("SAVEPOINT ") + msName); +} + +// Safely rollback the savepoint if it has not been committed. +Savepoint::~Savepoint() { + if (!mbReleased) { + try { + rollback(); + } catch (SQLite::Exception&) { + // Never throw an exception in a destructor: error if already rolled + // back or released, but no harm is caused by this. + } + } +} + +// Release the savepoint and commit +void Savepoint::release() { + if (!mbReleased) { + mDatabase.exec(std::string("RELEASE SAVEPOINT ") + msName); + mbReleased = true; + } else { + throw SQLite::Exception("Savepoint already released or rolled back."); + } +} + +// Rollback the savepoint +void Savepoint::rollback() { + if (!mbReleased) { + mDatabase.exec(std::string("ROLLBACK TO SAVEPOINT ") + msName); + mbReleased = true; + } else { + throw SQLite::Exception("Savepoint already released or rolled back."); + } +} + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Savepoint.h b/3rdparty/sqlitecpp/source/SQLiteCpp/Savepoint.h new file mode 100644 index 0000000..d389720 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Savepoint.h @@ -0,0 +1,95 @@ +/** + * @file Savepoint.h + * @ingroup SQLiteCpp + * @brief A Savepoint is a way to group multiple SQL statements into an atomic + * secured operation. Similar to a transaction while allowing child savepoints. + * + * Copyright (c) 2020 Kelvin Hammond ([email protected]) + * Copyright (c) 2020-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt or + * copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#include <SQLiteCpp/Exception.h> + +namespace SQLite { + +// Foward declaration +class Database; + +/** + * @brief RAII encapsulation of a SQLite Savepoint. + * + * A Savepoint is a way to group multiple SQL statements into an atomic + * secureced operation; either it succeeds, with all the changes commited to the + * database file, or if it fails, all the changes are rolled back to the initial + * state at the start of the savepoint. + * + * This method also offers big performances improvements compared to + * individually executed statements. + * + * Caveats: + * + * 1) Calling COMMIT or commiting a parent transaction or RELEASE on a parent + * savepoint will cause this savepoint to be released. + * + * 2) Calling ROLLBACK or rolling back a parent savepoint will cause this + * savepoint to be rolled back. + * + * 3) This savepoint is not saved to the database until this and all savepoints + * or transaction in the savepoint stack have been released or commited. + * + * See also: https://sqlite.org/lang_savepoint.html + * + * Thread-safety: a Transaction object shall not be shared by multiple threads, + * because: + * + * 1) in the SQLite "Thread Safe" mode, "SQLite can be safely used by multiple + * threads provided that no single database connection is used simultaneously in + * two or more threads." + * + * 2) the SQLite "Serialized" mode is not supported by SQLiteC++, because of the + * way it shares the underling SQLite precompiled statement in a custom shared + * pointer (See the inner class "Statement::Ptr"). + */ + +class Savepoint { + public: + /** + * @brief Begins the SQLite savepoint + * + * @param[in] aDatabase the SQLite Database Connection + * @param[in] aName the name of the Savepoint + * + * Exception is thrown in case of error, then the Savepoint is NOT + * initiated. + */ + Savepoint(Database& aDatabase, std::string name); + + // Savepoint is non-copyable + Savepoint(const Savepoint&) = delete; + Savepoint& operator=(const Savepoint&) = delete; + + /** + * @brief Safely rollback the savepoint if it has not been commited. + */ + ~Savepoint(); + + /** + * @brief Commit and release the savepoint. + */ + void release(); + + /** + * @brief Rollback the savepoint + */ + void rollback(); + + private: + Database& mDatabase; ///< Reference to the SQLite Database Connection + std::string msName; ///< Name of the Savepoint + bool mbReleased; ///< True when release has been called +}; +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Statement.cpp b/3rdparty/sqlitecpp/source/SQLiteCpp/Statement.cpp new file mode 100644 index 0000000..64e16d2 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Statement.cpp @@ -0,0 +1,368 @@ +/** + * @file Statement.cpp + * @ingroup SQLiteCpp + * @brief A prepared SQLite Statement is a compiled SQL query ready to be executed, pointing to a row of result. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#include <SQLiteCpp/Statement.h> + +#include <SQLiteCpp/Database.h> +#include <SQLiteCpp/Column.h> +#include <SQLiteCpp/Assertion.h> +#include <SQLiteCpp/Exception.h> + +#include <sqlite3.h> + +namespace SQLite +{ + +Statement::Statement(const Database& aDatabase, const char* apQuery) : + mQuery(apQuery), + mpSQLite(aDatabase.getHandle()), + mpPreparedStatement(prepareStatement()) // prepare the SQL query (needs Database friendship) +{ + mColumnCount = sqlite3_column_count(mpPreparedStatement.get()); +} + +Statement::Statement(Statement&& aStatement) noexcept : + mQuery(std::move(aStatement.mQuery)), + mpSQLite(aStatement.mpSQLite), + mpPreparedStatement(std::move(aStatement.mpPreparedStatement)), + mColumnCount(aStatement.mColumnCount), + mbHasRow(aStatement.mbHasRow), + mbDone(aStatement.mbDone), + mColumnNames(std::move(aStatement.mColumnNames)) +{ + aStatement.mpSQLite = nullptr; + aStatement.mColumnCount = 0; + aStatement.mbHasRow = false; + aStatement.mbDone = false; +} + +// Reset the statement to make it ready for a new execution (see also #clearBindings() bellow) +void Statement::reset() +{ + const int ret = tryReset(); + check(ret); +} + +int Statement::tryReset() noexcept +{ + mbHasRow = false; + mbDone = false; + return sqlite3_reset(mpPreparedStatement.get()); +} + +// Clears away all the bindings of a prepared statement (can be associated with #reset() above). +void Statement::clearBindings() +{ + const int ret = sqlite3_clear_bindings(getPreparedStatement()); + check(ret); +} + +int Statement::getIndex(const char * const apName) const +{ + return sqlite3_bind_parameter_index(getPreparedStatement(), apName); +} + +// Bind an 32bits int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bind(const int aIndex, const int32_t aValue) +{ + const int ret = sqlite3_bind_int(getPreparedStatement(), aIndex, aValue); + check(ret); +} + +// Bind a 32bits unsigned int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bind(const int aIndex, const uint32_t aValue) +{ + const int ret = sqlite3_bind_int64(getPreparedStatement(), aIndex, aValue); + check(ret); +} + +// Bind a 64bits int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bind(const int aIndex, const int64_t aValue) +{ + const int ret = sqlite3_bind_int64(getPreparedStatement(), aIndex, aValue); + check(ret); +} + +// Bind a double (64bits float) value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bind(const int aIndex, const double aValue) +{ + const int ret = sqlite3_bind_double(getPreparedStatement(), aIndex, aValue); + check(ret); +} + +// Bind a string value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bind(const int aIndex, const std::string& aValue) +{ + const int ret = sqlite3_bind_text(getPreparedStatement(), aIndex, aValue.c_str(), + static_cast<int>(aValue.size()), SQLITE_TRANSIENT); + check(ret); +} + +// Bind a text value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bind(const int aIndex, const char* apValue) +{ + const int ret = sqlite3_bind_text(getPreparedStatement(), aIndex, apValue, -1, SQLITE_TRANSIENT); + check(ret); +} + +// Bind a binary blob value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bind(const int aIndex, const void* apValue, const int aSize) +{ + const int ret = sqlite3_bind_blob(getPreparedStatement(), aIndex, apValue, aSize, SQLITE_TRANSIENT); + check(ret); +} + +// Bind a string value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bindNoCopy(const int aIndex, const std::string& aValue) +{ + const int ret = sqlite3_bind_text(getPreparedStatement(), aIndex, aValue.c_str(), + static_cast<int>(aValue.size()), SQLITE_STATIC); + check(ret); +} + +// Bind a text value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bindNoCopy(const int aIndex, const char* apValue) +{ + const int ret = sqlite3_bind_text(getPreparedStatement(), aIndex, apValue, -1, SQLITE_STATIC); + check(ret); +} + +// Bind a binary blob value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bindNoCopy(const int aIndex, const void* apValue, const int aSize) +{ + const int ret = sqlite3_bind_blob(getPreparedStatement(), aIndex, apValue, aSize, SQLITE_STATIC); + check(ret); +} + +// Bind a NULL value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement +void Statement::bind(const int aIndex) +{ + const int ret = sqlite3_bind_null(getPreparedStatement(), aIndex); + check(ret); +} + + +// Execute a step of the query to fetch one row of results +bool Statement::executeStep() +{ + const int ret = tryExecuteStep(); + if ((SQLITE_ROW != ret) && (SQLITE_DONE != ret)) // on row or no (more) row ready, else it's a problem + { + if (ret == sqlite3_errcode(mpSQLite)) + { + throw SQLite::Exception(mpSQLite, ret); + } + else + { + throw SQLite::Exception("Statement needs to be reseted", ret); + } + } + + return mbHasRow; // true only if one row is accessible by getColumn(N) +} + +// Execute a one-step query with no expected result, and return the number of changes. +int Statement::exec() +{ + const int ret = tryExecuteStep(); + if (SQLITE_DONE != ret) // the statement has finished executing successfully + { + if (SQLITE_ROW == ret) + { + throw SQLite::Exception("exec() does not expect results. Use executeStep."); + } + else if (ret == sqlite3_errcode(mpSQLite)) + { + throw SQLite::Exception(mpSQLite, ret); + } + else + { + throw SQLite::Exception("Statement needs to be reseted", ret); + } + } + + // Return the number of rows modified by those SQL statements (INSERT, UPDATE or DELETE) + return sqlite3_changes(mpSQLite); +} + +int Statement::tryExecuteStep() noexcept +{ + if (mbDone) + { + return SQLITE_MISUSE; // Statement needs to be reseted ! + } + + const int ret = sqlite3_step(mpPreparedStatement.get()); + if (SQLITE_ROW == ret) // one row is ready : call getColumn(N) to access it + { + mbHasRow = true; + } + else + { + mbHasRow = false; + mbDone = SQLITE_DONE == ret; // check if the query has finished executing + } + return ret; +} + + +// Return a copy of the column data specified by its index starting at 0 +// (use the Column copy-constructor) +Column Statement::getColumn(const int aIndex) const +{ + checkRow(); + checkIndex(aIndex); + + // Share the Statement Object handle with the new Column created + return Column(mpPreparedStatement, aIndex); +} + +// Return a copy of the column data specified by its column name starting at 0 +// (use the Column copy-constructor) +Column Statement::getColumn(const char* apName) const +{ + checkRow(); + const int index = getColumnIndex(apName); + + // Share the Statement Object handle with the new Column created + return Column(mpPreparedStatement, index); +} + +// Test if the column is NULL +bool Statement::isColumnNull(const int aIndex) const +{ + checkRow(); + checkIndex(aIndex); + return (SQLITE_NULL == sqlite3_column_type(getPreparedStatement(), aIndex)); +} + +bool Statement::isColumnNull(const char* apName) const +{ + checkRow(); + const int index = getColumnIndex(apName); + return (SQLITE_NULL == sqlite3_column_type(getPreparedStatement(), index)); +} + +// Return the named assigned to the specified result column (potentially aliased) +const char* Statement::getColumnName(const int aIndex) const +{ + checkIndex(aIndex); + return sqlite3_column_name(getPreparedStatement(), aIndex); +} + +#ifdef SQLITE_ENABLE_COLUMN_METADATA +// Return the named assigned to the specified result column (potentially aliased) +const char* Statement::getColumnOriginName(const int aIndex) const +{ + checkIndex(aIndex); + return sqlite3_column_origin_name(getPreparedStatement(), aIndex); +} +#endif + +// Return the index of the specified (potentially aliased) column name +int Statement::getColumnIndex(const char* apName) const +{ + // Build the map of column index by name on first call + if (mColumnNames.empty()) + { + for (int i = 0; i < mColumnCount; ++i) + { + const char* pName = sqlite3_column_name(getPreparedStatement(), i); + mColumnNames[pName] = i; + } + } + + const auto iIndex = mColumnNames.find(apName); + if (iIndex == mColumnNames.end()) + { + throw SQLite::Exception("Unknown column name."); + } + + return iIndex->second; +} + +const char * Statement::getColumnDeclaredType(const int aIndex) const +{ + checkIndex(aIndex); + const char * result = sqlite3_column_decltype(getPreparedStatement(), aIndex); + if (!result) + { + throw SQLite::Exception("Could not determine declared column type."); + } + else + { + return result; + } +} + +// Get number of rows modified by last INSERT, UPDATE or DELETE statement (not DROP table). +int Statement::getChanges() const noexcept +{ + return sqlite3_changes(mpSQLite); +} + +int Statement::getBindParameterCount() const noexcept +{ + return sqlite3_bind_parameter_count(mpPreparedStatement.get()); +} + +// Return the numeric result code for the most recent failed API call (if any). +int Statement::getErrorCode() const noexcept +{ + return sqlite3_errcode(mpSQLite); +} + +// Return the extended numeric result code for the most recent failed API call (if any). +int Statement::getExtendedErrorCode() const noexcept +{ + return sqlite3_extended_errcode(mpSQLite); +} + +// Return UTF-8 encoded English language explanation of the most recent failed API call (if any). +const char* Statement::getErrorMsg() const noexcept +{ + return sqlite3_errmsg(mpSQLite); +} + +// Return a UTF-8 string containing the SQL text of prepared statement with bound parameters expanded. +std::string Statement::getExpandedSQL() const { + char* expanded = sqlite3_expanded_sql(getPreparedStatement()); + std::string expandedString(expanded); + sqlite3_free(expanded); + return expandedString; +} + +// Prepare SQLite statement object and return shared pointer to this object +Statement::TStatementPtr Statement::prepareStatement() +{ + sqlite3_stmt* statement; + const int ret = sqlite3_prepare_v2(mpSQLite, mQuery.c_str(), static_cast<int>(mQuery.size()), &statement, nullptr); + if (SQLITE_OK != ret) + { + throw SQLite::Exception(mpSQLite, ret); + } + return Statement::TStatementPtr(statement, [](sqlite3_stmt* stmt) + { + sqlite3_finalize(stmt); + }); +} + +// Return prepered statement object or throw +sqlite3_stmt* Statement::getPreparedStatement() const +{ + sqlite3_stmt* ret = mpPreparedStatement.get(); + if (ret) + { + return ret; + } + throw SQLite::Exception("Statement was not prepared."); +} + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Statement.h b/3rdparty/sqlitecpp/source/SQLiteCpp/Statement.h new file mode 100644 index 0000000..c81e215 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Statement.h @@ -0,0 +1,714 @@ +/** + * @file Statement.h + * @ingroup SQLiteCpp + * @brief A prepared SQLite Statement is a compiled SQL query ready to be executed, pointing to a row of result. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#include <SQLiteCpp/Exception.h> +#include <SQLiteCpp/Utils.h> // SQLITECPP_PURE_FUNC + +#include <string> +#include <map> +#include <memory> + +// Forward declarations to avoid inclusion of <sqlite3.h> in a header +struct sqlite3; +struct sqlite3_stmt; + + +namespace SQLite +{ + + +// Forward declaration +class Database; +class Column; + +extern const int OK; ///< SQLITE_OK + +/** + * @brief RAII encapsulation of a prepared SQLite Statement. + * + * A Statement is a compiled SQL query ready to be executed step by step + * to provide results one row at a time. + * + * Resource Acquisition Is Initialization (RAII) means that the Statement + * is compiled in the constructor and finalized in the destructor, so that there is + * no need to worry about memory management or the validity of the underlying SQLite Statement. + * + * Thread-safety: a Statement object shall not be shared by multiple threads, because : + * 1) in the SQLite "Thread Safe" mode, "SQLite can be safely used by multiple threads + * provided that no single database connection is used simultaneously in two or more threads." + * 2) the SQLite "Serialized" mode is not supported by SQLiteC++, + * because of the way it shares the underling SQLite precompiled statement + * in a custom shared pointer (See the inner class "Statement::Ptr"). + */ +class Statement +{ +public: + /** + * @brief Compile and register the SQL query for the provided SQLite Database Connection + * + * @param[in] aDatabase the SQLite Database Connection + * @param[in] apQuery an UTF-8 encoded query string + * + * Exception is thrown in case of error, then the Statement object is NOT constructed. + */ + Statement(const Database& aDatabase, const char* apQuery); + + /** + * @brief Compile and register the SQL query for the provided SQLite Database Connection + * + * @param[in] aDatabase the SQLite Database Connection + * @param[in] aQuery an UTF-8 encoded query string + * + * Exception is thrown in case of error, then the Statement object is NOT constructed. + */ + Statement(const Database& aDatabase, const std::string& aQuery) : + Statement(aDatabase, aQuery.c_str()) + {} + + /** + * @brief Move an SQLite statement. + * + * @param[in] aStatement Statement to move + */ + Statement(Statement&& aStatement) noexcept; + Statement& operator=(Statement&& aStatement) noexcept = default; + + // Statement is non-copyable + Statement(const Statement&) = delete; + Statement& operator=(const Statement&) = delete; + + /// Finalize and unregister the SQL query from the SQLite Database Connection. + /// The finalization will be done by the destructor of the last shared pointer + ~Statement() = default; + + /// Reset the statement to make it ready for a new execution. Throws an exception on error. + void reset(); + + /// Reset the statement. Returns the sqlite result code instead of throwing an exception on error. + int tryReset() noexcept; + + /** + * @brief Clears away all the bindings of a prepared statement. + * + * Contrary to the intuition of many, reset() does not reset the bindings on a prepared statement. + * Use this routine to reset all parameters to NULL. + */ + void clearBindings(); // throw(SQLite::Exception) + + //////////////////////////////////////////////////////////////////////////// + // Bind a value to a parameter of the SQL statement, + // in the form "?" (unnamed), "?NNN", ":VVV", "@VVV" or "$VVV". + // + // Can use the parameter index, starting from "1", to the higher NNN value, + // or the complete parameter name "?NNN", ":VVV", "@VVV" or "$VVV" + // (prefixed with the corresponding sign "?", ":", "@" or "$") + // + // Note that for text and blob values, the SQLITE_TRANSIENT flag is used, + // which tell the sqlite library to make its own copy of the data before the bind() call returns. + // This choice is done to prevent any common misuses, like passing a pointer to a + // dynamic allocated and temporary variable (a std::string for instance). + // This is under-optimized for static data (a static text define in code) + // as well as for dynamic allocated buffer which could be transfer to sqlite + // instead of being copied. + // => if you know what you are doing, use bindNoCopy() instead of bind() + + SQLITECPP_PURE_FUNC + int getIndex(const char * const apName) const; + + /** + * @brief Bind an int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const int aIndex, const int32_t aValue); + /** + * @brief Bind a 32bits unsigned int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const int aIndex, const uint32_t aValue); + /** + * @brief Bind a 64bits int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const int aIndex, const int64_t aValue); + /** + * @brief Bind a double (64bits float) value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const int aIndex, const double aValue); + /** + * @brief Bind a string value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use + */ + void bind(const int aIndex, const std::string& aValue); + /** + * @brief Bind a text value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use + */ + void bind(const int aIndex, const char* apValue); + /** + * @brief Bind a binary blob value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use + */ + void bind(const int aIndex, const void* apValue, const int aSize); + /** + * @brief Bind a string value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1). + * + * The string can contain null characters as it is binded using its size. + * + * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement. + */ + void bindNoCopy(const int aIndex, const std::string& aValue); + /** + * @brief Bind a text value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * Main usage is with null-terminated literal text (aka in code static strings) + * + * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement. + */ + void bindNoCopy(const int aIndex, const char* apValue); + /** + * @brief Bind a binary blob value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement. + */ + void bindNoCopy(const int aIndex, const void* apValue, const int aSize); + /** + * @brief Bind a NULL value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @see clearBindings() to set all bound parameters to NULL. + */ + void bind(const int aIndex); + + /** + * @brief Bind an int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const char* apName, const int32_t aValue) + { + bind(getIndex(apName), aValue); + } + /** + * @brief Bind a 32bits unsigned int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const char* apName, const uint32_t aValue) + { + bind(getIndex(apName), aValue); + } + /** + * @brief Bind a 64bits int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const char* apName, const int64_t aValue) + { + bind(getIndex(apName), aValue); + } + /** + * @brief Bind a double (64bits float) value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const char* apName, const double aValue) + { + bind(getIndex(apName), aValue); + } + /** + * @brief Bind a string value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use + */ + void bind(const char* apName, const std::string& aValue) + { + bind(getIndex(apName), aValue); + } + /** + * @brief Bind a text value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use + */ + void bind(const char* apName, const char* apValue) + { + bind(getIndex(apName), apValue); + } + /** + * @brief Bind a binary blob value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use + */ + void bind(const char* apName, const void* apValue, const int aSize) + { + bind(getIndex(apName), apValue, aSize); + } + /** + * @brief Bind a string value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * The string can contain null characters as it is binded using its size. + * + * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement. + */ + void bindNoCopy(const char* apName, const std::string& aValue) + { + bindNoCopy(getIndex(apName), aValue); + } + /** + * @brief Bind a text value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * Main usage is with null-terminated literal text (aka in code static strings) + * + * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement. + */ + void bindNoCopy(const char* apName, const char* apValue) + { + bindNoCopy(getIndex(apName), apValue); + } + /** + * @brief Bind a binary blob value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement. + */ + void bindNoCopy(const char* apName, const void* apValue, const int aSize) + { + bindNoCopy(getIndex(apName), apValue, aSize); + } + /** + * @brief Bind a NULL value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @see clearBindings() to set all bound parameters to NULL. + */ + void bind(const char* apName) // bind NULL value + { + bind(getIndex(apName)); + } + + + /** + * @brief Bind an int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const std::string& aName, const int32_t aValue) + { + bind(aName.c_str(), aValue); + } + /** + * @brief Bind a 32bits unsigned int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const std::string& aName, const uint32_t aValue) + { + bind(aName.c_str(), aValue); + } + /** + * @brief Bind a 64bits int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const std::string& aName, const int64_t aValue) + { + bind(aName.c_str(), aValue); + } + /** + * @brief Bind a double (64bits float) value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + */ + void bind(const std::string& aName, const double aValue) + { + bind(aName.c_str(), aValue); + } + /** + * @brief Bind a string value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use + */ + void bind(const std::string& aName, const std::string& aValue) + { + bind(aName.c_str(), aValue); + } + /** + * @brief Bind a text value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use + */ + void bind(const std::string& aName, const char* apValue) + { + bind(aName.c_str(), apValue); + } + /** + * @brief Bind a binary blob value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use + */ + void bind(const std::string& aName, const void* apValue, const int aSize) + { + bind(aName.c_str(), apValue, aSize); + } + /** + * @brief Bind a string value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * The string can contain null characters as it is binded using its size. + * + * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement. + */ + void bindNoCopy(const std::string& aName, const std::string& aValue) + { + bindNoCopy(aName.c_str(), aValue); + } + /** + * @brief Bind a text value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * Main usage is with null-terminated literal text (aka in code static strings) + * + * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement. + */ + void bindNoCopy(const std::string& aName, const char* apValue) + { + bindNoCopy(aName.c_str(), apValue); + } + /** + * @brief Bind a binary blob value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement. + */ + void bindNoCopy(const std::string& aName, const void* apValue, const int aSize) + { + bindNoCopy(aName.c_str(), apValue, aSize); + } + /** + * @brief Bind a NULL value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1) + * + * @see clearBindings() to set all bound parameters to NULL. + */ + void bind(const std::string& aName) // bind NULL value + { + bind(aName.c_str()); + } + + //////////////////////////////////////////////////////////////////////////// + + /** + * @brief Execute a step of the prepared query to fetch one row of results. + * + * While true is returned, a row of results is available, and can be accessed + * through the getColumn() method + * + * @see exec() execute a one-step prepared statement with no expected result + * @see tryExecuteStep() try to execute a step of the prepared query to fetch one row of results, returning the sqlite result code. + * @see Database::exec() is a shortcut to execute one or multiple statements without results + * + * @return - true (SQLITE_ROW) if there is another row ready : you can call getColumn(N) to get it + * then you have to call executeStep() again to fetch more rows until the query is finished + * - false (SQLITE_DONE) if the query has finished executing : there is no (more) row of result + * (case of a query with no result, or after N rows fetched successfully) + * + * @throw SQLite::Exception in case of error + */ + bool executeStep(); + + /** + * @brief Try to execute a step of the prepared query to fetch one row of results, returning the sqlite result code. + * + * + * + * @see exec() execute a one-step prepared statement with no expected result + * @see executeStep() execute a step of the prepared query to fetch one row of results + * @see Database::exec() is a shortcut to execute one or multiple statements without results + * + * @return the sqlite result code. + */ + int tryExecuteStep() noexcept; + + /** + * @brief Execute a one-step query with no expected result, and return the number of changes. + * + * This method is useful for any kind of statements other than the Data Query Language (DQL) "SELECT" : + * - Data Definition Language (DDL) statements "CREATE", "ALTER" and "DROP" + * - Data Manipulation Language (DML) statements "INSERT", "UPDATE" and "DELETE" + * - Data Control Language (DCL) statements "GRANT", "REVOKE", "COMMIT" and "ROLLBACK" + * + * It is similar to Database::exec(), but using a precompiled statement, it adds : + * - the ability to bind() arguments to it (best way to insert data), + * - reusing it allows for better performances (efficient for multiple insertion). + * + * @see executeStep() execute a step of the prepared query to fetch one row of results + * @see tryExecuteStep() try to execute a step of the prepared query to fetch one row of results, returning the sqlite result code. + * @see Database::exec() is a shortcut to execute one or multiple statements without results + * + * @return number of row modified by this SQL statement (INSERT, UPDATE or DELETE) + * + * @throw SQLite::Exception in case of error, or if row of results are returned while they are not expected! + */ + int exec(); + + //////////////////////////////////////////////////////////////////////////// + + /** + * @brief Return a copy of the column data specified by its index + * + * Can be used to access the data of the current row of result when applicable, + * while the executeStep() method returns true. + * + * Throw an exception if there is no row to return a Column from: + * - if provided index is out of bound + * - before any executeStep() call + * - after the last executeStep() returned false + * - after a reset() call + * + * Throw an exception if the specified index is out of the [0, getColumnCount()) range. + * + * @param[in] aIndex Index of the column, starting at 0 + * + * @note This method is not const, reflecting the fact that the returned Column object will + * share the ownership of the underlying sqlite3_stmt. + * + * @warning The resulting Column object must not be memorized "as-is". + * Is is only a wrapper around the current result row, so it is only valid + * while the row from the Statement remains valid, that is only until next executeStep() call. + * Thus, you should instead extract immediately its data (getInt(), getText()...) + * and use or copy this data for any later usage. + */ + Column getColumn(const int aIndex) const; + + /** + * @brief Return a copy of the column data specified by its column name (less efficient than using an index) + * + * Can be used to access the data of the current row of result when applicable, + * while the executeStep() method returns true. + * + * Throw an exception if there is no row to return a Column from : + * - if provided name is not one of the aliased column names + * - before any executeStep() call + * - after the last executeStep() returned false + * - after a reset() call + * + * Throw an exception if the specified name is not an on of the aliased name of the columns in the result. + * + * @param[in] apName Aliased name of the column, that is, the named specified in the query (not the original name) + * + * @note Uses a map of column names to indexes, build on first call. + * + * @note This method is not const, reflecting the fact that the returned Column object will + * share the ownership of the underlying sqlite3_stmt. + * + * @warning The resulting Column object must not be memorized "as-is". + * Is is only a wrapper around the current result row, so it is only valid + * while the row from the Statement remains valid, that is only until next executeStep() call. + * Thus, you should instead extract immediately its data (getInt(), getText()...) + * and use or copy this data for any later usage. + * + * Throw an exception if the specified name is not one of the aliased name of the columns in the result. + */ + Column getColumn(const char* apName) const; + +#if __cplusplus >= 201402L || (defined(_MSC_VER) && _MSC_VER >= 1900) // c++14: Visual Studio 2015 + /** + * @brief Return an instance of T constructed from copies of the first N columns + * + * Can be used to access the data of the current row of result when applicable, + * while the executeStep() method returns true. + * + * Throw an exception if there is no row to return a Column from: + * - if provided column count is out of bound + * - before any executeStep() call + * - after the last executeStep() returned false + * - after a reset() call + * + * Throw an exception if the specified column count is out of the [0, getColumnCount()) range. + * + * @tparam T Object type to construct + * @tparam N Number of columns + * + * @note Requires std=C++14 + */ + template<typename T, int N> + T getColumns(); + +private: + /** + * @brief Helper function used by getColumns<typename T, int N> to expand an integer_sequence used to generate + * the required Column objects + */ + template<typename T, const int... Is> + T getColumns(const std::integer_sequence<int, Is...>); + +public: +#endif + + /** + * @brief Test if the column value is NULL + * + * @param[in] aIndex Index of the column, starting at 0 + * + * @return true if the column value is NULL + * + * Throw an exception if the specified index is out of the [0, getColumnCount()) range. + */ + bool isColumnNull(const int aIndex) const; + + /** + * @brief Test if the column value is NULL + * + * @param[in] apName Aliased name of the column, that is, the named specified in the query (not the original name) + * + * @return true if the column value is NULL + * + * Throw an exception if the specified name is not one of the aliased name of the columns in the result. + */ + bool isColumnNull(const char* apName) const; + + /** + * @brief Return a pointer to the named assigned to the specified result column (potentially aliased) + * + * @param[in] aIndex Index of the column in the range [0, getColumnCount()). + * + * @see getColumnOriginName() to get original column name (not aliased) + * + * Throw an exception if the specified index is out of the [0, getColumnCount()) range. + */ + const char* getColumnName(const int aIndex) const; + +#ifdef SQLITE_ENABLE_COLUMN_METADATA + /** + * @brief Return a pointer to the table column name that is the origin of the specified result column + * + * Require definition of the SQLITE_ENABLE_COLUMN_METADATA preprocessor macro : + * - when building the SQLite library itself (which is the case for the Debian libsqlite3 binary for instance), + * - and also when compiling this wrapper. + * + * Throw an exception if the specified index is out of the [0, getColumnCount()) range. + */ + const char* getColumnOriginName(const int aIndex) const; +#endif + + /** + * @brief Return the index of the specified (potentially aliased) column name + * + * @param[in] apName Aliased name of the column, that is, the named specified in the query (not the original name) + * + * @note Uses a map of column names to indexes, build on first call. + * + * Throw an exception if the specified name is not known. + */ + int getColumnIndex(const char* apName) const; + + + /** + * @brief Return the declared type of the specified result column for a SELECT statement. + * + * This is the type given at creation of the column and not the actual data type. + * SQLite stores data types dynamically for each value and not per column. + * + * @param[in] aIndex Index of the column in the range [0, getColumnCount()). + * + * Throw an exception if the type can't be determined because: + * - the specified index is out of the [0, getColumnCount()) range + * - the statement is not a SELECT query + * - the column at aIndex is not a table column but an expression or subquery + */ + const char * getColumnDeclaredType(const int aIndex) const; + + + /// Get number of rows modified by last INSERT, UPDATE or DELETE statement (not DROP table). + int getChanges() const noexcept; + + + //////////////////////////////////////////////////////////////////////////// + + /// Return the UTF-8 SQL Query. + const std::string& getQuery() const + { + return mQuery; + } + + // Return a UTF-8 string containing the SQL text of prepared statement with bound parameters expanded. + std::string getExpandedSQL() const; + + /// Return the number of columns in the result set returned by the prepared statement + int getColumnCount() const + { + return mColumnCount; + } + /// true when a row has been fetched with executeStep() + bool hasRow() const + { + return mbHasRow; + } + /// true when the last executeStep() had no more row to fetch + bool isDone() const + { + return mbDone; + } + + /// Return the number of bind parameters in the statement + int getBindParameterCount() const noexcept; + + /// Return the numeric result code for the most recent failed API call (if any). + int getErrorCode() const noexcept; + /// Return the extended numeric result code for the most recent failed API call (if any). + int getExtendedErrorCode() const noexcept; + /// Return UTF-8 encoded English language explanation of the most recent failed API call (if any). + const char* getErrorMsg() const noexcept; + + /// Shared pointer to SQLite Prepared Statement Object + using TStatementPtr = std::shared_ptr<sqlite3_stmt>; + +private: + /** + * @brief Check if a return code equals SQLITE_OK, else throw a SQLite::Exception with the SQLite error message + * + * @param[in] aRet SQLite return code to test against the SQLITE_OK expected value + */ + void check(const int aRet) const + { + if (SQLite::OK != aRet) + { + throw SQLite::Exception(mpSQLite, aRet); + } + } + + /** + * @brief Check if there is a row of result returned by executeStep(), else throw a SQLite::Exception. + */ + void checkRow() const + { + if (false == mbHasRow) + { + throw SQLite::Exception("No row to get a column from. executeStep() was not called, or returned false."); + } + } + + /** + * @brief Check if there is a Column index is in the range of columns in the result. + */ + void checkIndex(const int aIndex) const + { + if ((aIndex < 0) || (aIndex >= mColumnCount)) + { + throw SQLite::Exception("Column index out of range."); + } + } + + /** + * @brief Prepare statement object. + * + * @return Shared pointer to prepared statement object + */ + TStatementPtr prepareStatement(); + + /** + * @brief Return a prepared statement object. + * + * Throw an exception if the statement object was not prepared. + * @return raw pointer to Prepared Statement Object + */ + sqlite3_stmt* getPreparedStatement() const; + + std::string mQuery; //!< UTF-8 SQL Query + sqlite3* mpSQLite; //!< Pointer to SQLite Database Connection Handle + TStatementPtr mpPreparedStatement; //!< Shared Pointer to the prepared SQLite Statement Object + int mColumnCount{0}; //!< Number of columns in the result of the prepared statement + bool mbHasRow{false}; //!< true when a row has been fetched with executeStep() + bool mbDone{false}; //!< true when the last executeStep() had no more row to fetch + + /// Map of columns index by name (mutable so getColumnIndex can be const) + mutable std::map<std::string, int> mColumnNames{}; +}; + + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Transaction.cpp b/3rdparty/sqlitecpp/source/SQLiteCpp/Transaction.cpp new file mode 100644 index 0000000..2a8857a --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Transaction.cpp @@ -0,0 +1,83 @@ +/** + * @file Transaction.cpp + * @ingroup SQLiteCpp + * @brief A Transaction is way to group multiple SQL statements into an atomic secured operation. + * + * Copyright (c) 2012-2019 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#include <SQLiteCpp/Transaction.h> + +#include <SQLiteCpp/Database.h> +#include <SQLiteCpp/Assertion.h> + +#include <sqlite3.h> + +namespace SQLite +{ + + +// Begins the SQLite transaction +Transaction::Transaction(Database& aDatabase, TransactionBehavior behavior) : + mDatabase(aDatabase), + mbCommited(false) +{ + const char *stmt; + switch (behavior) { + case TransactionBehavior::DEFERRED: + stmt = "BEGIN DEFERRED"; + break; + case TransactionBehavior::IMMEDIATE: + stmt = "BEGIN IMMEDIATE"; + break; + case TransactionBehavior::EXCLUSIVE: + stmt = "BEGIN EXCLUSIVE"; + break; + default: + throw SQLite::Exception("invalid/unknown transaction behavior", SQLITE_ERROR); + } + mDatabase.exec(stmt); +} + +// Begins the SQLite transaction +Transaction::Transaction(Database &aDatabase) : + mDatabase(aDatabase), + mbCommited(false) +{ + mDatabase.exec("BEGIN"); +} + +// Safely rollback the transaction if it has not been committed. +Transaction::~Transaction() +{ + if (false == mbCommited) + { + try + { + mDatabase.exec("ROLLBACK"); + } + catch (SQLite::Exception&) + { + // Never throw an exception in a destructor: error if already rollbacked, but no harm is caused by this. + } + } +} + +// Commit the transaction. +void Transaction::commit() +{ + if (false == mbCommited) + { + mDatabase.exec("COMMIT"); + mbCommited = true; + } + else + { + throw SQLite::Exception("Transaction already committed."); + } +} + + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Transaction.h b/3rdparty/sqlitecpp/source/SQLiteCpp/Transaction.h new file mode 100644 index 0000000..d7f26ca --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Transaction.h @@ -0,0 +1,95 @@ +/** + * @file Transaction.h + * @ingroup SQLiteCpp + * @brief A Transaction is way to group multiple SQL statements into an atomic secured operation. + * + * Copyright (c) 2012-2021 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#include <SQLiteCpp/Exception.h> + + +namespace SQLite +{ + + +// Forward declaration +class Database; + +/** + * @brief Transaction behaviors when opening an SQLite transaction. + * Names correspond directly to the behavior. + */ +enum class TransactionBehavior { + DEFERRED, + IMMEDIATE, + EXCLUSIVE, +}; + +/** + * @brief RAII encapsulation of a SQLite Transaction. + * + * A Transaction is a way to group multiple SQL statements into an atomic secured operation; + * either it succeeds, with all the changes committed to the database file, + * or if it fails, all the changes are rolled back to the initial state. + * + * Resource Acquisition Is Initialization (RAII) means that the Transaction + * begins in the constructor and is rollbacked in the destructor, so that there is + * no need to worry about memory management or the validity of the underlying SQLite Connection. + * + * This method also offers big performances improvements compared to individually executed statements. + * + * Thread-safety: a Transaction object shall not be shared by multiple threads, because : + * 1) in the SQLite "Thread Safe" mode, "SQLite can be safely used by multiple threads + * provided that no single database connection is used simultaneously in two or more threads." + * 2) the SQLite "Serialized" mode is not supported by SQLiteC++, + * because of the way it shares the underling SQLite precompiled statement + * in a custom shared pointer (See the inner class "Statement::Ptr"). + */ +class Transaction +{ +public: + /** + * @brief Begins the SQLite transaction using the default transaction behavior. + * + * @param[in] aDatabase the SQLite Database Connection + * + * Exception is thrown in case of error, then the Transaction is NOT initiated. + */ + explicit Transaction(Database& aDatabase); + + /** + * @brief Begins the SQLite transaction with the specified behavior. + * + * @param[in] aDatabase the SQLite Database Connection + * @param[in] behavior the requested transaction behavior + * + * Exception is thrown in case of error, then the Transaction is NOT initiated. + */ + explicit Transaction(Database& aDatabase, TransactionBehavior behavior); + + // Transaction is non-copyable + Transaction(const Transaction&) = delete; + Transaction& operator=(const Transaction&) = delete; + + /** + * @brief Safely rollback the transaction if it has not been committed. + */ + ~Transaction(); + + /** + * @brief Commit the transaction. + */ + void commit(); + +private: + Database& mDatabase; ///< Reference to the SQLite Database Connection + bool mbCommited; ///< True when commit has been called +}; + + +} // namespace SQLite diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/Utils.h b/3rdparty/sqlitecpp/source/SQLiteCpp/Utils.h new file mode 100644 index 0000000..f053b3f --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/Utils.h @@ -0,0 +1,31 @@ +/** + * @file Utils.h + * @ingroup SQLiteCpp + * @brief Definition of the SQLITECPP_PURE_FUNC macro. + * + * Copyright (c) 2012-2020 Sebastien Rombauts ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +// macro taken from https://github.com/nemequ/hedley/blob/master/hedley.h that was in public domain at this time +#if defined(__GNUC__) || defined(__GNUG__) || defined(__clang__) ||\ +(defined(__INTEL_COMPILER) && __INTEL_COMPILER > 1600) ||\ +(defined(__ARMCC_VERSION) && __ARMCC_VERSION > 4010000) ||\ +(\ + defined(__TI_COMPILER_VERSION__) && (\ + __TI_COMPILER_VERSION__ > 8003000 ||\ + (__TI_COMPILER_VERSION__ > 7003000 && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))\ + )\ +) +#if defined(__has_attribute) +#if !defined(SQLITECPP_PURE_FUNC) && __has_attribute(pure) +#define SQLITECPP_PURE_FUNC __attribute__((pure)) +#endif +#endif +#endif +#if !defined(SQLITECPP_PURE_FUNC) +#define SQLITECPP_PURE_FUNC +#endif diff --git a/3rdparty/sqlitecpp/source/SQLiteCpp/VariadicBind.h b/3rdparty/sqlitecpp/source/SQLiteCpp/VariadicBind.h new file mode 100644 index 0000000..e82b436 --- /dev/null +++ b/3rdparty/sqlitecpp/source/SQLiteCpp/VariadicBind.h @@ -0,0 +1,98 @@ +/** + * @file VariadicBind.h + * @ingroup SQLiteCpp + * @brief Convenience function for Statement::bind(...) + * + * Copyright (c) 2016 Paul Dreik ([email protected]) + * Copyright (c) 2016-2021 Sebastien Rombauts ([email protected]) + * Copyright (c) 2019 Maximilian Bachmann ([email protected]) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#pragma once + +#include <SQLiteCpp/Statement.h> + +#if (__cplusplus >= 201402L) || ( defined(_MSC_VER) && (_MSC_VER >= 1900) ) // c++14: Visual Studio 2015 +#include <tuple> +#endif // c++14 + +/// @cond +#include <utility> +#include <initializer_list> + +namespace SQLite +{ +/// @endcond + +/** + * \brief Convenience function for calling Statement::bind(...) once for each argument given. + * + * This takes care of incrementing the index between each calls to bind. + * + * This feature requires a c++11 capable compiler. + * + * \code{.cpp} + * SQLite::Statement stm("SELECT * FROM MyTable WHERE colA>? && colB=? && colC<?"); + * SQLite::bind(stm,a,b,c); + * //...is equivalent to + * stm.bind(1,a); + * stm.bind(2,b); + * stm.bind(3,c); + * \endcode + * @param query statement + * @param args zero or more args to bind. + */ +template<class ...Args> +void bind(SQLite::Statement& query, const Args& ... args) +{ + int pos = 0; + (void)std::initializer_list<int>{ + ((void)query.bind(++pos, std::forward<decltype(args)>(args)), 0)... + }; +} + +#if (__cplusplus >= 201402L) || ( defined(_MSC_VER) && (_MSC_VER >= 1900) ) // c++14: Visual Studio 2015 + +/** + * \brief Convenience function for calling Statement::bind(...) once for each parameter of a tuple, + * by forwarding them to the variadic template + * + * This feature requires a c++14 capable compiler. + * + * \code{.cpp} + * SQLite::Statement stm("SELECT * FROM MyTable WHERE colA>? && colB=? && colC<?"); + * SQLite::bind(stm, std::make_tuple(a, b, c)); + * //...is equivalent to + * stm.bind(1,a); + * stm.bind(2,b); + * stm.bind(3,c); + * \endcode + * @param query statement + * @param tuple tuple with values to bind + */ +template <typename ... Types> +void bind(SQLite::Statement& query, const std::tuple<Types...> &tuple) +{ + bind(query, tuple, std::index_sequence_for<Types...>()); +} + +/** + * \brief Convenience function for calling Statement::bind(...) once for each parameter of a tuple, + * by forwarding them to the variadic template. This function is just needed to convert the tuples + * to parameter packs + * + * This feature requires a c++14 capable compiler. + * + * @param query statement + * @param tuple tuple with values to bind + */ +template <typename ... Types, std::size_t ... Indices> +void bind(SQLite::Statement& query, const std::tuple<Types...> &tuple, std::index_sequence<Indices...>) +{ + bind(query, std::get<Indices>(tuple)...); +} +#endif // c++14 + +} // namespace SQLite |