diff --git a/CMakeLists.txt b/CMakeLists.txt index 65bd5db..18cb1c5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -92,11 +92,12 @@ endif (SQLITE_ENABLE_ASSERT_HANDLER) # list of sources files of the library set(SQLITECPP_SRC + ${PROJECT_SOURCE_DIR}/src/Backup.cpp ${PROJECT_SOURCE_DIR}/src/Column.cpp ${PROJECT_SOURCE_DIR}/src/Database.cpp + ${PROJECT_SOURCE_DIR}/src/Exception.cpp ${PROJECT_SOURCE_DIR}/src/Statement.cpp ${PROJECT_SOURCE_DIR}/src/Transaction.cpp - ${PROJECT_SOURCE_DIR}/src/Backup.cpp ) source_group(src FILES ${SQLITECPP_SRC}) diff --git a/README.md b/README.md index 9dd1b93..ce9b7dd 100644 --- a/README.md +++ b/README.md @@ -227,7 +227,7 @@ catch (std::exception& e) ```C++ try { - SQLite::Database db("transaction.db3", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); + SQLite::Database db("transaction.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); db.exec("DROP TABLE IF EXISTS test"); diff --git a/TODO.txt b/TODO.txt index 6bc8067..7a74609 100644 --- a/TODO.txt +++ b/TODO.txt @@ -1,23 +1,20 @@ +Switch to C++11 for v2.0.0 with removal of include in headers + Add a Tutorial for SQLite newbies -Add a real example (rework current example?) +Add a real example in the form of a small interactive console application Improve Github Wiki pages with the FAQ: Installation, Examples, Tutorial, How to contribute Publish the Doxygen Documentation in the Github Pages (gh-pages branch) -Missing features in v1.1.0: -- bind a SQLITE_STATIC value (string/blob) -- bind a dynamic value with zerocopy (unlike SQLITE_TRANSIENT) with custom deleter +Missing features in v2.0.0: - #24: executemany() like in Python https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.executemany - #34: Better type for getColumn -Missing documentation in v1.1.0: +Missing documentation in v2.0.0: - explain the noncopyable property for RAII design - comment on returning error code instead of exception that shall not be thrown when expected (!?) -Missing unit tests in v1.0.0: -- Binding variants -- Create Function -- Assert Handler +Missing unit tests in v2.0.0: - Load Extension (not practicable, and easy to verify by code review) Advanced missing features: diff --git a/appveyor.yml b/appveyor.yml index b409f35..08ae6b1 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -9,9 +9,11 @@ install: # - git submodule update --init googletest # configurations to add to build matrix +# TODO: VS2010->VS2015 and Win32/Win64 (see https://github.com/google/googletest/blob/master/appveyor.yml) +# TODO: MinGW Makefiles and MSYS Makefiles configuration: - Debug - - Release +# - Release # CMake can only build the default configuration on Visual Studio # scripts to run before build # NOTE : no unit tests as cloning googletest does not work on AppVeyor diff --git a/examples/example1/main.cpp b/examples/example1/main.cpp index 227d06c..59a079d 100644 --- a/examples/example1/main.cpp +++ b/examples/example1/main.cpp @@ -84,7 +84,9 @@ private: int main () { - std::cout << "SQlite3 version " << SQLITE_VERSION << std::endl; + // Using SQLITE_VERSION would require #include which we want to avoid + // TODO: replace by a SQLite::VERSION + // std::cout << "SQlite3 version " << SQLITE_VERSION << std::endl; std::cout << "SQliteC++ version " << SQLITECPP_VERSION << std::endl; //////////////////////////////////////////////////////////////////////////// @@ -92,7 +94,7 @@ int main () try { // Open a database file in readonly mode - SQLite::Database db(filename_example_db3); // SQLITE_OPEN_READONLY + SQLite::Database db(filename_example_db3); // SQLite::OPEN_READONLY std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; // Test if the 'test' table exists @@ -114,7 +116,7 @@ int main () try { // Open a database file in readonly mode - SQLite::Database db(filename_example_db3); // SQLITE_OPEN_READONLY + SQLite::Database db(filename_example_db3); // SQLite::OPEN_READONLY std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; ///// a) Loop to get values of column by index, using auto cast to variable type @@ -230,7 +232,7 @@ int main () try { // Open a database file in readonly mode - SQLite::Database db(filename_example_db3); // SQLITE_OPEN_READONLY + SQLite::Database db(filename_example_db3); // SQLite::OPEN_READONLY std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; // WARNING: Be very careful with this dangerous method: you have to @@ -250,7 +252,7 @@ int main () try { // Open a database file in create/write mode - SQLite::Database db("test.db3", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); + SQLite::Database db("test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; // Create a new table with an explicit "id" column aliasing the underlying rowid @@ -291,7 +293,7 @@ int main () try { // Open a database file in create/write mode - SQLite::Database db("transaction.db3", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); + SQLite::Database db("transaction.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; db.exec("DROP TABLE IF EXISTS test"); @@ -359,7 +361,7 @@ int main () try { // Open a database file in create/write mode - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; db.exec("DROP TABLE IF EXISTS test"); @@ -428,7 +430,7 @@ int main () try { // Open a database file in create/write mode - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); db.exec("DROP TABLE IF EXISTS test"); db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)"); diff --git a/include/SQLiteCpp/Assertion.h b/include/SQLiteCpp/Assertion.h index 2486e9e..4a85c3d 100644 --- a/include/SQLiteCpp/Assertion.h +++ b/include/SQLiteCpp/Assertion.h @@ -3,7 +3,7 @@ * @ingroup SQLiteCpp * @brief Definition of the SQLITECPP_ASSERT() macro. * - * Copyright (c) 2012-2013 Sebastien Rombauts (sebastien.rombauts@gmail.com) + * Copyright (c) 2012-2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) * * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt * or copy at http://opensource.org/licenses/MIT) diff --git a/include/SQLiteCpp/Backup.h b/include/SQLiteCpp/Backup.h index 1ac14bd..0978cda 100644 --- a/include/SQLiteCpp/Backup.h +++ b/include/SQLiteCpp/Backup.h @@ -3,7 +3,8 @@ * @ingroup SQLiteCpp * @brief Backup is used to backup a database file in a safe and online way. * - * Copyright (c) 2015-2015 Shibao HONG (shibaohong@outlook.com) + * Copyright (c) 2015 Shibao HONG (shibaohong@outlook.com) + * Copyright (c) 2015-2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) * * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt * or copy at http://opensource.org/licenses/MIT) diff --git a/include/SQLiteCpp/Column.h b/include/SQLiteCpp/Column.h index 1301205..7f09b09 100644 --- a/include/SQLiteCpp/Column.h +++ b/include/SQLiteCpp/Column.h @@ -20,6 +20,12 @@ 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. @@ -110,7 +116,7 @@ public: /** * @brief Return the type of the value of the column * - * Return either SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT, SQLITE_BLOB, or SQLITE_NULL. + * 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. @@ -120,27 +126,27 @@ public: /// Test if the column is an integer type value (meaningful only before any conversion) inline bool isInteger() const noexcept // nothrow { - return (SQLITE_INTEGER == getType()); + return (SQLite::INTEGER == getType()); } /// Test if the column is a floating point type value (meaningful only before any conversion) inline bool isFloat() const noexcept // nothrow { - return (SQLITE_FLOAT == getType()); + return (SQLite::FLOAT == getType()); } /// Test if the column is a text type value (meaningful only before any conversion) inline bool isText() const noexcept // nothrow { - return (SQLITE_TEXT == getType()); + return (SQLite::TEXT == getType()); } /// Test if the column is a binary blob type value (meaningful only before any conversion) inline bool isBlob() const noexcept // nothrow { - return (SQLITE_BLOB == getType()); + return (SQLite::BLOB == getType()); } /// Test if the column is NULL (meaningful only before any conversion) inline bool isNull() const noexcept // nothrow { - return (SQLITE_NULL == getType()); + return (SQLite::Null == getType()); } /** diff --git a/include/SQLiteCpp/Database.h b/include/SQLiteCpp/Database.h index 775a8e5..1ab2e24 100644 --- a/include/SQLiteCpp/Database.h +++ b/include/SQLiteCpp/Database.h @@ -23,6 +23,22 @@ typedef struct Mem sqlite3_value; namespace SQLite { +// Those public constants enable most usages of SQLiteCpp without including 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 + + +extern const int OK; ///< SQLITE_OK (used by inline check() bellow) + /** * @brief RAII management of a SQLite Database Connection. @@ -57,14 +73,14 @@ public: * 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] 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 aFlags = SQLite::OPEN_READONLY, const int aBusyTimeoutMs = 0, const char* apVfs = NULL); @@ -79,14 +95,14 @@ public: * 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] 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 aFlags = SQLite::OPEN_READONLY, const int aBusyTimeoutMs = 0, const std::string& aVfs = ""); @@ -250,6 +266,7 @@ public: /// Return the extended numeric result code for the most recent failed API call (if any). int getExtendedErrorCode() const noexcept; // nothrow /// Return UTF-8 encoded English language explanation of the most recent failed API call (if any). + // TODO: rename getErrorMessage const char* errmsg() const noexcept; // nothrow /// Return the filename used to open the database. @@ -358,7 +375,7 @@ private: */ inline void check(const int aRet) const { - if (SQLITE_OK != aRet) + if (SQLite::OK != aRet) { throw SQLite::Exception(mpSQLite, aRet); } diff --git a/include/SQLiteCpp/Exception.h b/include/SQLiteCpp/Exception.h index 4dac7b8..0afbb86 100644 --- a/include/SQLiteCpp/Exception.h +++ b/include/SQLiteCpp/Exception.h @@ -3,7 +3,7 @@ * @ingroup SQLiteCpp * @brief Encapsulation of the error message from SQLite3 on a std::runtime_error. * - * Copyright (c) 2012-2013 Sebastien Rombauts (sebastien.rombauts@gmail.com) + * Copyright (c) 2012-2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) * * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt * or copy at http://opensource.org/licenses/MIT) @@ -12,9 +12,9 @@ #include #include -#include -#include +// Forward declaration to avoid inclusion of in a header +struct sqlite3; /// Compatibility with non-clang compilers. #ifndef __has_feature @@ -50,12 +50,7 @@ public: * * @param[in] aErrorMessage The string message describing the SQLite error */ - explicit Exception(const std::string& aErrorMessage) : - std::runtime_error(aErrorMessage), - mErrcode(-1), // 0 would be SQLITE_OK, which doesn't make sense - mExtendedErrcode(-1) - { - } + explicit Exception(const std::string& aErrorMessage); /** * @brief Encapsulation of the error message from SQLite3, based on std::runtime_error. @@ -63,24 +58,14 @@ public: * @param[in] aErrorMessage The string message describing the SQLite error * @param[in] ret Return value from function call that failed. */ - explicit Exception(const std::string& aErrorMessage, int ret) : - std::runtime_error(aErrorMessage), - mErrcode(ret), - mExtendedErrcode(-1) - { - } + Exception(const std::string& aErrorMessage, int ret); /** * @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) : - std::runtime_error(sqlite3_errmsg(apSQLite)), - mErrcode(sqlite3_errcode(apSQLite)), - mExtendedErrcode(sqlite3_extended_errcode(apSQLite)) - { - } + explicit Exception(sqlite3* apSQLite); /** * @brief Encapsulation of the error message from SQLite3, based on std::runtime_error. @@ -88,12 +73,7 @@ public: * @param[in] apSQLite The SQLite object, to obtain detailed error messages from. * @param[in] ret Return value from function call that failed. */ - explicit Exception(sqlite3* apSQLite, int ret) : - std::runtime_error(sqlite3_errmsg(apSQLite)), - mErrcode(ret), - mExtendedErrcode(sqlite3_extended_errcode(apSQLite)) - { - } + Exception(sqlite3* apSQLite, int ret); /** * @brief Encapsulation of the error message from SQLite3, based on std::runtime_error. @@ -102,30 +82,16 @@ public: * @param[in] ret Return value from function call that failed. * @param[in] aErrorMessage String providing more context, added to the SQLite errmsg */ - explicit Exception(sqlite3* apSQLite, int ret, const std::string &aErrorMessage) : - std::runtime_error(aErrorMessage + ": " + sqlite3_errmsg(apSQLite)), - mErrcode(ret), - mExtendedErrcode(sqlite3_extended_errcode(apSQLite)) - { - } + Exception(sqlite3* apSQLite, int ret, const std::string &aErrorMessage); /// Return the result code (if any, otherwise -1). - inline int getErrorCode() const noexcept // nothrow - { - return mErrcode; - } + int getErrorCode() const noexcept; // nothrow /// Return the extended numeric result code (if any, otherwise -1). - inline int getExtendedErrorCode() const noexcept // nothrow - { - return mExtendedErrcode; - } + inline int getExtendedErrorCode() const noexcept; // nothrow /// Return a string, solely based on the error code - inline const char *getErrStr() const noexcept // nothrow - { - return sqlite3_errstr(mErrcode); - } + inline const char *getErrStr() const noexcept; // nothrow private: const int mErrcode; ///< Error code value diff --git a/include/SQLiteCpp/SQLiteCpp.h b/include/SQLiteCpp/SQLiteCpp.h index b51061a..88a96be 100644 --- a/include/SQLiteCpp/SQLiteCpp.h +++ b/include/SQLiteCpp/SQLiteCpp.h @@ -38,5 +38,5 @@ * with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same * numbers used in [SQLITECPP_VERSION]. */ -#define SQLITECPP_VERSION "1.3.1" -#define SQLITECPP_VERSION_NUMBER 1003001 +#define SQLITECPP_VERSION "1.99.99" // Pre-2.0.0 +#define SQLITECPP_VERSION_NUMBER 1099099 // Pre-2.0.0 diff --git a/include/SQLiteCpp/Statement.h b/include/SQLiteCpp/Statement.h index 511d989..db7f695 100644 --- a/include/SQLiteCpp/Statement.h +++ b/include/SQLiteCpp/Statement.h @@ -29,6 +29,8 @@ namespace SQLite class Database; class Column; +extern const int OK; ///< SQLITE_OK + /** * @brief RAII encapsulation of a prepared SQLite Statement. * @@ -542,7 +544,7 @@ private: */ inline void check(const int aRet) const { - if (SQLITE_OK != aRet) + if (SQLite::OK != aRet) { throw SQLite::Exception(mStmtPtr, aRet); } diff --git a/include/SQLiteCpp/Transaction.h b/include/SQLiteCpp/Transaction.h index 70e7e99..33935a6 100644 --- a/include/SQLiteCpp/Transaction.h +++ b/include/SQLiteCpp/Transaction.h @@ -3,7 +3,7 @@ * @ingroup SQLiteCpp * @brief A Transaction is way to group multiple SQL statements into an atomic secured operation. * - * Copyright (c) 2012-2013 Sebastien Rombauts (sebastien.rombauts@gmail.com) + * Copyright (c) 2012-2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) * * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt * or copy at http://opensource.org/licenses/MIT) diff --git a/include/SQLiteCpp/VariadicBind.h b/include/SQLiteCpp/VariadicBind.h index a040f15..524cdf6 100644 --- a/include/SQLiteCpp/VariadicBind.h +++ b/include/SQLiteCpp/VariadicBind.h @@ -4,6 +4,7 @@ * @brief Convenience function for Statement::bind(...) * * Copyright (c) 2016 Paul Dreik (github@pauldreik.se) + * Copyright (c) 2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) * * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt * or copy at http://opensource.org/licenses/MIT) diff --git a/src/Backup.cpp b/src/Backup.cpp index c638239..f8fd58a 100644 --- a/src/Backup.cpp +++ b/src/Backup.cpp @@ -3,12 +3,12 @@ * @ingroup SQLiteCpp * @brief Backup is used to backup a database file in a safe and online way. * - * Copyright (c) 2015-2015 Shibao HONG (shibaohong@outlook.com) + * Copyright (c) 2015 Shibao HONG (shibaohong@outlook.com) + * Copyright (c) 2015-2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) * * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt * or copy at http://opensource.org/licenses/MIT) */ - #include #include diff --git a/src/Column.cpp b/src/Column.cpp index 3fd219b..3529f87 100644 --- a/src/Column.cpp +++ b/src/Column.cpp @@ -18,6 +18,13 @@ 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; + + // Encapsulation of a Column in a row of the result pointed by the prepared Statement. Column::Column(Statement::Ptr& aStmtPtr, int aIndex) noexcept : // nothrow mStmtPtr(aStmtPtr), diff --git a/src/Database.cpp b/src/Database.cpp index f44f2b4..185a872 100644 --- a/src/Database.cpp +++ b/src/Database.cpp @@ -3,7 +3,7 @@ * @ingroup SQLiteCpp * @brief Management of a SQLite Database Connection. * - * Copyright (c) 2012-2013 Sebastien Rombauts (sebastien.rombauts@gmail.com) + * Copyright (c) 2012-2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) * * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt * or copy at http://opensource.org/licenses/MIT) @@ -24,10 +24,18 @@ namespace SQLite { +extern const int OPEN_READONLY = SQLITE_OPEN_READONLY; +extern const int OPEN_READWRITE = SQLITE_OPEN_READWRITE; +extern const int OPEN_CREATE = SQLITE_OPEN_CREATE; +extern const int OPEN_URI = SQLITE_OPEN_URI; +extern const int OPEN_MEMORY = SQLITE_OPEN_MEMORY; -// Open the provided database UTF-8 filename with SQLITE_OPEN_xxx provided flags. +extern const int OK = SQLITE_OK; + + +// 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 aFlags /* = SQLite::OPEN_READONLY*/, const int aBusyTimeoutMs /* = 0 */, const char* apVfs /* = NULL*/) : mpSQLite(NULL), @@ -47,9 +55,9 @@ Database::Database(const char* apFilename, } } -// Open the provided database UTF-8 filename with SQLITE_OPEN_xxx provided flags. +// Open the provided database UTF-8 filename with SQLite::OPEN_xxx provided flags. Database::Database(const std::string& aFilename, - const int aFlags /* = SQLITE_OPEN_READONLY*/, + const int aFlags /* = SQLite::OPEN_READONLY*/, const int aBusyTimeoutMs /* = 0 */, const std::string& aVfs /* = "" */) : mpSQLite(NULL), diff --git a/src/Exception.cpp b/src/Exception.cpp new file mode 100644 index 0000000..7b1a931 --- /dev/null +++ b/src/Exception.cpp @@ -0,0 +1,73 @@ +/** + * @file Exception.cpp + * @ingroup SQLiteCpp + * @brief Encapsulation of the error message from SQLite3 on a std::runtime_error. + * + * Copyright (c) 2012-2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ +#include + +#include + + +namespace SQLite +{ + +Exception::Exception(const std::string& aErrorMessage) : + std::runtime_error(aErrorMessage), + mErrcode(-1), // 0 would be SQLITE_OK, which doesn't make sense + mExtendedErrcode(-1) +{ +} + +Exception::Exception(const std::string& 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)) +{ +} + +Exception::Exception(sqlite3* apSQLite, int ret, const std::string &aErrorMessage) : + std::runtime_error(aErrorMessage + ": " + sqlite3_errmsg(apSQLite)), + mErrcode(ret), + mExtendedErrcode(sqlite3_extended_errcode(apSQLite)) +{ +} + +// Return the result code (if any, otherwise -1). +inline int Exception::getErrorCode() const noexcept // nothrow +{ + return mErrcode; +} + +// Return the extended numeric result code (if any, otherwise -1). +inline int Exception::getExtendedErrorCode() const noexcept // nothrow +{ + return mExtendedErrcode; +} + +// Return a string, solely based on the error code +inline const char *Exception::getErrStr() const noexcept // nothrow +{ + return sqlite3_errstr(mErrcode); +} + + +} // namespace SQLite diff --git a/tests/Backup_test.cpp b/tests/Backup_test.cpp index 0567882..4ec37a1 100644 --- a/tests/Backup_test.cpp +++ b/tests/Backup_test.cpp @@ -4,7 +4,7 @@ * @brief Test of a SQLite Backup. * * Copyright (c) 2015 Shibao HONG (shibaohong@outlook.com) - * Copyright (c) 2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) + * Copyright (c) 2015-2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) * * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt * or copy at http://opensource.org/licenses/MIT) @@ -15,13 +15,15 @@ #include #include +#include // for SQLITE_ERROR, SQLITE_RANGE and SQLITE_DONE + #include #include TEST(Backup, initException) { remove("backup_test.db3"); - SQLite::Database srcDB("backup_test.db3", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); @@ -35,15 +37,15 @@ TEST(Backup, initException) { TEST(Backup, executeStepOne) { remove("backup_test.db3"); remove("backup_test.db3.backup"); - SQLite::Database srcDB("backup_test.db3", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); - SQLite::Database destDB("backup_test.db3.backup", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); SQLite::Backup backup(destDB, "main", srcDB, "main"); int res = backup.executeStep(1); // backup only one page at a time - ASSERT_EQ(SQLITE_OK, res); + ASSERT_EQ(SQLite::OK, res); const int total = backup.getTotalPageCount(); ASSERT_EQ(2, total); int remaining = backup.getRemainingPageCount(); @@ -67,12 +69,12 @@ TEST(Backup, executeStepOne) { TEST(Backup, executeStepAll) { remove("backup_test.db3"); remove("backup_test.db3.backup"); - SQLite::Database srcDB("backup_test.db3", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); - SQLite::Database destDB("backup_test.db3.backup", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); SQLite::Backup backup(destDB, srcDB); const int res = backup.executeStep(); // uses default argument "-1" => execute all steps at once ASSERT_EQ(res, SQLITE_DONE); @@ -95,16 +97,16 @@ TEST(Backup, executeStepAll) { TEST(Backup, executeStepException) { remove("backup_test.db3"); remove("backup_test.db3.backup"); - SQLite::Database srcDB("backup_test.db3", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); { - SQLite::Database destDB("backup_test.db3.backup", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); (void)destDB; } { - SQLite::Database destDB("backup_test.db3.backup", SQLITE_OPEN_READONLY); + SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READONLY); SQLite::Backup backup(destDB, srcDB); EXPECT_THROW(backup.executeStep(), SQLite::Exception); } diff --git a/tests/Column_test.cpp b/tests/Column_test.cpp index 7b71e02..e86c321 100644 --- a/tests/Column_test.cpp +++ b/tests/Column_test.cpp @@ -13,6 +13,8 @@ #include #include +#include // for sqlite3_int64 + #include #include @@ -20,9 +22,9 @@ TEST(Column, basis) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); - EXPECT_EQ(SQLITE_OK, db.getExtendedErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getExtendedErrorCode()); // Create a new table EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT, int INTEGER, double REAL, binary BLOB, empty TEXT)")); @@ -108,7 +110,7 @@ TEST(Column, basis) { } // Validate getBytes(), getType(), isInteger(), isNull()... - EXPECT_EQ(SQLITE_INTEGER, query.getColumn(0).getType()); + EXPECT_EQ(SQLite::INTEGER, query.getColumn(0).getType()); EXPECT_EQ(true, query.getColumn(0).isInteger()); EXPECT_EQ(false, query.getColumn(0).isFloat()); EXPECT_EQ(false, query.getColumn(0).isText()); @@ -116,7 +118,7 @@ TEST(Column, basis) { EXPECT_EQ(false, query.getColumn(0).isNull()); EXPECT_STREQ("1", query.getColumn(0).getText()); // convert to string EXPECT_EQ(1, query.getColumn(0).getBytes()); // size of the string "1" without the null terminator - EXPECT_EQ(SQLITE_TEXT, query.getColumn(1).getType()); + EXPECT_EQ(SQLite::TEXT, query.getColumn(1).getType()); EXPECT_EQ(false, query.getColumn(1).isInteger()); EXPECT_EQ(false, query.getColumn(1).isFloat()); EXPECT_EQ(true, query.getColumn(1).isText()); @@ -124,7 +126,7 @@ TEST(Column, basis) { EXPECT_EQ(false, query.getColumn(1).isNull()); EXPECT_STREQ("first", query.getColumn(1).getText()); // convert to string EXPECT_EQ(5, query.getColumn(1).getBytes()); // size of the string "first" - EXPECT_EQ(SQLITE_INTEGER, query.getColumn(2).getType()); + EXPECT_EQ(SQLite::INTEGER, query.getColumn(2).getType()); EXPECT_EQ(true, query.getColumn(2).isInteger()); EXPECT_EQ(false, query.getColumn(2).isFloat()); EXPECT_EQ(false, query.getColumn(2).isText()); @@ -132,7 +134,7 @@ TEST(Column, basis) { EXPECT_EQ(false, query.getColumn(2).isNull()); EXPECT_STREQ("-123", query.getColumn(2).getText()); // convert to string EXPECT_EQ(4, query.getColumn(2).getBytes()); // size of the string "-123" - EXPECT_EQ(SQLITE_FLOAT, query.getColumn(3).getType()); + EXPECT_EQ(SQLite::FLOAT, query.getColumn(3).getType()); EXPECT_EQ(false, query.getColumn(3).isInteger()); EXPECT_EQ(true, query.getColumn(3).isFloat()); EXPECT_EQ(false, query.getColumn(3).isText()); @@ -140,7 +142,7 @@ TEST(Column, basis) { EXPECT_EQ(false, query.getColumn(3).isNull()); EXPECT_STREQ("0.123", query.getColumn(3).getText()); // convert to string EXPECT_EQ(5, query.getColumn(3).getBytes()); // size of the string "0.123" - EXPECT_EQ(SQLITE_BLOB, query.getColumn(4).getType()); + EXPECT_EQ(SQLite::BLOB, query.getColumn(4).getType()); EXPECT_EQ(false, query.getColumn(4).isInteger()); EXPECT_EQ(false, query.getColumn(4).isFloat()); EXPECT_EQ(false, query.getColumn(4).isText()); @@ -148,7 +150,7 @@ TEST(Column, basis) { EXPECT_EQ(false, query.getColumn(4).isNull()); EXPECT_STREQ("bl\0b", query.getColumn(4).getText()); // convert to string EXPECT_EQ(4, query.getColumn(4).getBytes()); // size of the blob "bl\0b" with the null char - EXPECT_EQ(SQLITE_NULL, query.getColumn(5).getType()); + EXPECT_EQ(SQLite::Null, query.getColumn(5).getType()); EXPECT_EQ(false, query.getColumn(5).isInteger()); EXPECT_EQ(false, query.getColumn(5).isFloat()); EXPECT_EQ(false, query.getColumn(5).isText()); @@ -172,7 +174,7 @@ TEST(Column, basis) { TEST(Column, getName) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT)")); EXPECT_EQ(1, db.exec("INSERT INTO test VALUES (NULL, \"first\")")); diff --git a/tests/Database_test.cpp b/tests/Database_test.cpp index 4124486..bcb91ed 100644 --- a/tests/Database_test.cpp +++ b/tests/Database_test.cpp @@ -11,6 +11,8 @@ #include +#include // for SQLITE_ERROR and SQLITE_VERSION_NUMBER + #include #include @@ -36,7 +38,7 @@ TEST(Database, ctorExecCreateDropExist) { EXPECT_THROW(SQLite::Database not_found(filename), SQLite::Exception); // Create a new database - SQLite::Database db("test.db3", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); + SQLite::Database db("test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); EXPECT_STREQ("test.db3", db.getFilename().c_str()); EXPECT_FALSE(db.tableExists("test")); EXPECT_FALSE(db.tableExists(std::string("test"))); @@ -62,14 +64,14 @@ TEST(Database, createCloseReopen) { EXPECT_THROW(SQLite::Database not_found("test.db3"), SQLite::Exception); // Create a new database - SQLite::Database db("test.db3", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database db("test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); EXPECT_FALSE(db.tableExists("test")); db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)"); EXPECT_TRUE(db.tableExists("test")); } // Close DB test.db3 { // Reopen the database file - SQLite::Database db("test.db3", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database db("test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); EXPECT_TRUE(db.tableExists("test")); } // Close DB test.db3 remove("test.db3"); @@ -78,7 +80,7 @@ TEST(Database, createCloseReopen) { TEST(Database, inMemory) { { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE); EXPECT_FALSE(db.tableExists("test")); db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)"); EXPECT_TRUE(db.tableExists("test")); @@ -111,7 +113,7 @@ TEST(Database, busyTimeout) { } { // Create a new database with a non null busy timeout - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE, 5000); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE, 5000); EXPECT_EQ(5000, db.execAndGet("PRAGMA busy_timeout").getInt()); // Reset timeout to null @@ -121,7 +123,7 @@ TEST(Database, busyTimeout) { { // Create a new database with a non null busy timeout const std::string memory = ":memory:"; - SQLite::Database db(memory, SQLITE_OPEN_READWRITE, 5000); + SQLite::Database db(memory, SQLite::OPEN_READWRITE, 5000); EXPECT_EQ(5000, db.execAndGet("PRAGMA busy_timeout").getInt()); // Reset timeout to null @@ -133,7 +135,7 @@ TEST(Database, busyTimeout) { TEST(Database, exec) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE); // Create a new table with an explicit "id" column aliasing the underlying rowid // NOTE: here exec() returns 0 only because it is the first statements since database connexion, @@ -194,7 +196,7 @@ TEST(Database, exec) { TEST(Database, execAndGet) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE); // Create a new table with an explicit "id" column aliasing the underlying rowid db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT, weight INTEGER)"); @@ -212,9 +214,9 @@ TEST(Database, execAndGet) { TEST(Database, execException) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); - EXPECT_EQ(SQLITE_OK, db.getExtendedErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getExtendedErrorCode()); // exception with SQL error: "no such table" EXPECT_THROW(db.exec("INSERT INTO test VALUES (NULL, \"first\", 3)"), SQLite::Exception); @@ -224,8 +226,8 @@ TEST(Database, execException) { // Create a new table db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT, weight INTEGER)"); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); - EXPECT_EQ(SQLITE_OK, db.getExtendedErrorCode()); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getExtendedErrorCode()); EXPECT_STREQ("not an error", db.errmsg()); // exception with SQL error: "table test has 3 columns but 2 values were supplied" diff --git a/tests/Statement_test.cpp b/tests/Statement_test.cpp index f5c48fc..0237027 100644 --- a/tests/Statement_test.cpp +++ b/tests/Statement_test.cpp @@ -12,6 +12,8 @@ #include #include +#include // for SQLITE_DONE + #include #include @@ -19,9 +21,9 @@ TEST(Statement, invalid) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); - EXPECT_EQ(SQLITE_OK, db.getExtendedErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getExtendedErrorCode()); // Compile a SQL query, but without any table in the database EXPECT_THROW(SQLite::Statement query(db, "SELECT * FROM test"), SQLite::Exception); @@ -29,8 +31,8 @@ TEST(Statement, invalid) { EXPECT_EQ(SQLITE_ERROR, db.getExtendedErrorCode()); EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)")); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); - EXPECT_EQ(SQLITE_OK, db.getExtendedErrorCode()); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getExtendedErrorCode()); // Compile a SQL query with no parameter SQLite::Statement query(db, "SELECT * FROM test"); @@ -38,8 +40,8 @@ TEST(Statement, invalid) { EXPECT_EQ(2, query.getColumnCount ()); EXPECT_FALSE(query.isOk()); EXPECT_FALSE(query.isDone()); - EXPECT_EQ(SQLITE_OK, query.getErrorCode()); - EXPECT_EQ(SQLITE_OK, query.getExtendedErrorCode()); + EXPECT_EQ(SQLite::OK, query.getErrorCode()); + EXPECT_EQ(SQLite::OK, query.getExtendedErrorCode()); EXPECT_THROW(query.isColumnNull(-1), SQLite::Exception); EXPECT_THROW(query.isColumnNull(0), SQLite::Exception); EXPECT_THROW(query.isColumnNull(1), SQLite::Exception); @@ -94,12 +96,12 @@ TEST(Statement, invalid) { TEST(Statement, executeStep) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Create a new table EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT, int INTEGER, double REAL)")); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Create a first row EXPECT_EQ(1, db.exec("INSERT INTO test VALUES (NULL, \"first\", 123, 0.123)")); @@ -146,12 +148,12 @@ TEST(Statement, executeStep) { TEST(Statement, bindings) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Create a new table EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT, int INTEGER, double REAL)")); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Insertion with bindable parameters SQLite::Statement insert(db, "INSERT INTO test VALUES (NULL, ?, ?, ?)"); @@ -290,12 +292,12 @@ TEST(Statement, bindings) { TEST(Statement, bindNoCopy) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Create a new table EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, txt1 TEXT, txt2 TEXT, binary BLOB)")); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Insertion with bindable parameters SQLite::Statement insert(db, "INSERT INTO test VALUES (NULL, ?, ?, ?)"); @@ -329,12 +331,12 @@ TEST(Statement, bindNoCopy) { TEST(Statement, bindByName) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Create a new table EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT, int INTEGER, double REAL)")); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Insertion with bindable parameters SQLite::Statement insert(db, "INSERT INTO test VALUES (NULL, @msg, @int, @double)"); @@ -427,12 +429,12 @@ TEST(Statement, bindByName) { TEST(Statement, bindNoCopyByName) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Create a new table EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, txt1 TEXT, txt2 TEXT, binary BLOB)")); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Insertion with bindable parameters SQLite::Statement insert(db, "INSERT INTO test VALUES (NULL, @txt1, @txt2, @blob)"); @@ -466,12 +468,12 @@ TEST(Statement, bindNoCopyByName) { TEST(Statement, isColumnNull) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); - ASSERT_EQ(SQLITE_OK, db.getErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + ASSERT_EQ(SQLite::OK, db.getErrorCode()); // Create a new table EXPECT_EQ(0, db.exec("CREATE TABLE test (msg TEXT, int INTEGER, double REAL)")); - ASSERT_EQ(SQLITE_OK, db.getErrorCode()); + ASSERT_EQ(SQLite::OK, db.getErrorCode()); // Create a first row with no null values, then other rows with each time a NULL value ASSERT_EQ(1, db.exec("INSERT INTO test VALUES (\"first\", 123, 0.123)")); @@ -528,14 +530,14 @@ TEST(Statement, isColumnNull) { TEST(Statement, getColumnByName) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); - EXPECT_EQ(SQLITE_OK, db.getExtendedErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getExtendedErrorCode()); // Create a new table EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT, int INTEGER, double REAL)")); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); - EXPECT_EQ(SQLITE_OK, db.getExtendedErrorCode()); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getExtendedErrorCode()); // Create a first row EXPECT_EQ(1, db.exec("INSERT INTO test VALUES (NULL, \"first\", 123, 0.123)")); @@ -564,7 +566,7 @@ TEST(Statement, getColumnByName) { TEST(Statement, getName) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT)")); // Compile a SQL query, using the "id" column name as-is, but aliasing the "msg" column with new name "value" diff --git a/tests/Transaction_test.cpp b/tests/Transaction_test.cpp index a117a43..c10db32 100644 --- a/tests/Transaction_test.cpp +++ b/tests/Transaction_test.cpp @@ -20,15 +20,15 @@ TEST(Transaction, commitRollback) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); { // Begin transaction SQLite::Transaction transaction(db); EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)")); - EXPECT_EQ(SQLITE_OK, db.getErrorCode()); + EXPECT_EQ(SQLite::OK, db.getErrorCode()); // Insert a first value EXPECT_EQ(1, db.exec("INSERT INTO test VALUES (NULL, \"first\")")); diff --git a/tests/VariadicBind_test.cpp b/tests/VariadicBind_test.cpp index 693b8ee..50973fd 100644 --- a/tests/VariadicBind_test.cpp +++ b/tests/VariadicBind_test.cpp @@ -4,6 +4,7 @@ * @brief Test of variadic bind * * Copyright (c) 2016 Paul Dreik (github@pauldreik.se) + * Copyright (c) 2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) * * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt * or copy at http://opensource.org/licenses/MIT) @@ -20,7 +21,7 @@ #if (__cplusplus >= 201402L) || ( defined(_MSC_VER) && (_MSC_VER >= 1900) ) // c++14: Visual Studio 2015 TEST(VariadicBind, invalid) { // Create a new database - SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); EXPECT_EQ(0, db.exec("DROP TABLE IF EXISTS test")); EXPECT_EQ(0,