cuberite/SQLiteCpp
1
0
Fork 0
mirror of https://github.com/cuberite/SQLiteCpp.git synced 2025-08-05 10:16:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

Fixed many cpplint warnings

Browse Source
This commit is contained in:
Sébastien Rombauts 2014-03-07 13:12:31 +01:00
parent 64b35bbd4e
commit 6d8b808320
12 changed files with 268 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cpplint.py vendored
View File

@ -2032,7 +2032,7 @@ class _NestingState(object):
slots = ''
if access_match.group(3):
slots = access_match.group(3)
error(filename, linenum, 'whitespace/indent', 3,
error(filename, linenum, 'whitespace/indent', 0,
'%s%s: should be indented +1 space inside %s' % (
access_match.group(2), slots, parent))
@ -3660,7 +3660,7 @@ def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):
if Match(r'(f|ind|io|i|o|parse|pf|stdio|str|)?stream$', include):
# Many unit tests use cout, so we exempt them.
if not _IsTestFilename(filename):
error(filename, linenum, 'readability/streams', 3,
error(filename, linenum, 'readability/streams', 0,
'Streams are highly discouraged.')

15
include/SQLiteCpp/Assertion.h
View File

@ -25,21 +25,22 @@
// 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);
// 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__
#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)
}
#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 debug mode, assert() does nothing)
#define SQLITECPP_ASSERT(expression,message) assert(expression && message)
#define SQLITECPP_ASSERT(expression, message) assert(expression && message)
#endif

22
include/SQLiteCpp/Column.h
View File

@ -15,6 +15,8 @@
#include <SQLiteCpp/Statement.h>
#include <SQLiteCpp/Exception.h>
#include <string>
namespace SQLite
{
@ -50,14 +52,14 @@ public:
Column(Statement::Ptr& aStmtPtr, int aIndex) noexcept; // nothrow
/// @brief Simple destructor
virtual ~Column(void) noexcept; // nothrow
// 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 a result column (potentially aliased)
*/
const char* getName (void) const noexcept; // nothrow
const char* getName(void) const noexcept; // nothrow
#ifdef SQLITE_ENABLE_COLUMN_METADATA
/**
@ -67,13 +69,13 @@ public:
* - 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 (void) const noexcept; // nothrow
const char* getOriginName(void) const noexcept; // nothrow
#endif
/// @brief Return the integer value of the column.
int getInt (void) const noexcept; // nothrow
int getInt(void) const noexcept; // nothrow
/// @brief Return the 64bits integer value of the column.
sqlite3_int64 getInt64 (void) const noexcept; // nothrow
sqlite3_int64 getInt64(void) const noexcept; // nothrow
/// @brief Return the double (64bits float) value of the column.
double getDouble(void) const noexcept; // nothrow
/**
@ -82,15 +84,15 @@ public:
* @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; // nothrow
const char* getText(const char* apDefaultValue = "") const noexcept; // nothrow
/**
* @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 (void) const noexcept; // nothrow
const void* getBlob(void) const noexcept; // nothrow
/**
* @brief Return the type of the value of the column
*
@ -100,7 +102,7 @@ public:
* the value returned by sqlite3_column_type() is undefined.
*/
int getType(void) const noexcept; // nothrow
/// @brief Test if the column is an integer type value (meaningful only before any conversion)
inline bool isInteger(void) const noexcept // nothrow
{
@ -179,7 +181,7 @@ public:
}
#ifdef __GNUC__
// NOTE : the following is required by GCC to cast a Column result in a std::string
// (error: conversion from ‘SQLite::Column’ to non-scalar type ‘std::string {aka std::basic_string<char>}’ requested)
// (error: conversion from ‘SQLite::Column’ to non-scalar type ‘std::string {aka std::basic_string<char>}’)
// but is not working under Microsoft Visual Studio 2010 and 2012
// (error C2440: 'initializing' : cannot convert from 'SQLite::Column' to 'std::basic_string<_Elem,_Traits,_Ax>'
// [...] constructor overload resolution was ambiguous)

44
include/SQLiteCpp/Database.h
View File

@ -14,6 +14,8 @@
#include <SQLiteCpp/Column.h>
#include <string>
namespace SQLite
{
@ -54,8 +56,10 @@ public:
* @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] 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 char * apVfs = NULL); // throw(SQLite::Exception);
Database(const char* apFilename, const int aFlags = SQLITE_OPEN_READONLY, const char * apVfs = NULL);
/**
* @brief Open the provided database UTF-8 filename.
@ -70,14 +74,18 @@ public:
* @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] 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 std::string& aVfs = ""); // throw(SQLite::Exception);
Database(const std::string& aFilename, const int aFlags = SQLITE_OPEN_READONLY, const std::string& aVfs = "");
/**
* @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
*/
virtual ~Database(void) noexcept; // nothrow
@ -98,7 +106,7 @@ public:
*
* @throw SQLite::Exception in case of error
*/
int exec(const char* apQueries); // throw(SQLite::Exception);
int exec(const char* apQueries);
/**
* @brief Shortcut to execute one or multiple statements without results.
@ -117,7 +125,7 @@ public:
*
* @throw SQLite::Exception in case of error
*/
inline int exec(const std::string& aQueries) // throw(SQLite::Exception);
inline int exec(const std::string& aQueries)
{
return exec(aQueries.c_str());
}
@ -141,7 +149,7 @@ public:
*
* @throw SQLite::Exception in case of error
*/
Column execAndGet(const char* apQuery); // throw(SQLite::Exception);
Column execAndGet(const char* apQuery);
/**
* @brief Shortcut to execute a one step query and fetch the first column of the result.
@ -162,7 +170,7 @@ public:
*
* @throw SQLite::Exception in case of error
*/
inline Column execAndGet(const std::string& aQuery) // throw(SQLite::Exception);
inline Column execAndGet(const std::string& aQuery)
{
return execAndGet(aQuery.c_str());
}
@ -178,7 +186,7 @@ public:
*
* @throw SQLite::Exception in case of error
*/
bool tableExists(const char* apTableName); // throw(SQLite::Exception);
bool tableExists(const char* apTableName);
/**
* @brief Shortcut to test if a table exists.
@ -191,7 +199,7 @@ public:
*
* @throw SQLite::Exception in case of error
*/
inline bool tableExists(const std::string& aTableName) // throw(SQLite::Exception);
inline bool tableExists(const std::string& aTableName)
{
return tableExists(aTableName.c_str());
}
@ -201,7 +209,7 @@ public:
*
* @param[in] aTimeoutMs Amount of milliseconds to wait before returning SQLITE_BUSY
*/
inline int setBusyTimeout(int aTimeoutMs) // noexcept; nothrow
inline int setBusyTimeout(int aTimeoutMs) noexcept // nothrow
{
return sqlite3_busy_timeout(mpSQLite, aTimeoutMs);
}
@ -211,7 +219,7 @@ public:
*
* @return Rowid of the most recent successful INSERT into the database, or 0 if there was none.
*/
inline sqlite3_int64 getLastInsertRowid(void) const // noexcept; nothrow
inline sqlite3_int64 getLastInsertRowid(void) const noexcept // nothrow
{
return sqlite3_last_insert_rowid(mpSQLite);
}
@ -219,7 +227,7 @@ public:
/**
* @brief Return the filename used to open the database
*/
inline const std::string& getFilename(void) const
inline const std::string& getFilename(void) const noexcept // nothrow
{
return mFilename;
}
@ -227,11 +235,11 @@ public:
/**
* @brief Return UTF-8 encoded English language explanation of the most recent error.
*/
inline const char* errmsg(void) const
inline const char* errmsg(void) const noexcept // nothrow
{
return sqlite3_errmsg(mpSQLite);
}
/**
* @brief Create or redefine a SQL function or aggregate in the sqlite database.
*
@ -243,7 +251,7 @@ public:
* @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 ot user data, accessible with sqlite3_user_data().
* @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 NULL)
* @param[in] apStep Pointer to a C-function to implement an aggregate SQL function (apFunc NULL)
* @param[in] apFinal Pointer to a C-function to implement an aggregate SQL function (apFunc NULL)
@ -257,7 +265,7 @@ public:
void* apApp,
void (*apFunc)(sqlite3_context *, int, sqlite3_value **),
void (*apStep)(sqlite3_context *, int, sqlite3_value **),
void (*apFinal)(sqlite3_context *),
void (*apFinal)(sqlite3_context *), // NOLINT(readability/casting)
void (*apDestroy)(void *));
/**
@ -271,7 +279,7 @@ public:
* @param[in] aFuncName 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 ot user data, accessible with sqlite3_user_data().
* @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 NULL)
* @param[in] apStep Pointer to a C-function to implement an aggregate SQL function (apFunc NULL)
* @param[in] apFinal Pointer to a C-function to implement an aggregate SQL function (apFunc NULL)
@ -285,7 +293,7 @@ public:
void* apApp,
void (*apFunc)(sqlite3_context *, int, sqlite3_value **),
void (*apStep)(sqlite3_context *, int, sqlite3_value **),
void (*apFinal)(sqlite3_context *),
void (*apFinal)(sqlite3_context *), // NOLINT(readability/casting)
void (*apDestroy)(void *))
{
return createFunction(aFuncName.c_str(), aNbArg, abDeterministic,
@ -301,7 +309,7 @@ private:
/**
* @brief Check if aRet equal SQLITE_OK, else throw a SQLite::Exception with the SQLite error message
*/
void check(const int aRet) const; // throw(SQLite::Exception);
void check(const int aRet) const;
private:
sqlite3* mpSQLite; //!< Pointer to SQLite Database Connection Handle

5
include/SQLiteCpp/Exception.h
View File

@ -11,6 +11,7 @@
#pragma once
#include <stdexcept>
#include <string>
namespace SQLite
@ -28,7 +29,7 @@ public:
*
* @param[in] aErrorMessage The string message describing the SQLite error
*/
Exception(const std::string& aErrorMessage) :
explicit Exception(const std::string& aErrorMessage) :
std::runtime_error(aErrorMessage)
{
}
@ -40,7 +41,7 @@ public:
/// Compatibility with non-clang compilers.
#ifndef __has_feature
#define __has_feature(x) 0
#define __has_feature(x) 0
#endif
// Detect whether the compiler supports C++11 noexcept exception specifications.

84
include/SQLiteCpp/SQLiteCpp.h
View File

@ -1,42 +1,42 @@
/**
* @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-2014 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)
*/
/**
* @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].
*/
#define SQLITECPP_VERSION "0.9.9"
#define SQLITECPP_VERSION_NUMBER 0009009
/**
* @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-2014 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)
*/
/**
* @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].
*/
#define SQLITECPP_VERSION "0.9.9"
#define SQLITECPP_VERSION_NUMBER 0009009

63
include/SQLiteCpp/Statement.h
View File

@ -54,7 +54,7 @@ public:
*
* Exception is thrown in case of error, then the Statement object is NOT constructed.
*/
Statement(Database& aDatabase, const char* apQuery); // throw(SQLite::Exception);
Statement(Database& aDatabase, const char* apQuery);
/**
* @brief Compile and register the SQL query for the provided SQLite Database Connection
@ -64,7 +64,7 @@ public:
*
* Exception is thrown in case of error, then the Statement object is NOT constructed.
*/
Statement(Database& aDatabase, const std::string& aQuery); // throw(SQLite::Exception);
Statement(Database& aDatabase, const std::string& aQuery);
/**
* @brief Finalize and unregister the SQL query from the SQLite Database Connection.
@ -74,7 +74,7 @@ public:
/**
* @brief Reset the statement to make it ready for a new execution.
*/
void reset(void); // throw(SQLite::Exception);
void reset(void);
////////////////////////////////////////////////////////////////////////////
// Bind a value to a parameter of the SQL statement,
@ -86,7 +86,7 @@ public:
//
// 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
// 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
@ -95,92 +95,92 @@ public:
/**
* @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 int& aValue) ; // throw(SQLite::Exception);
void bind(const int aIndex, const int& 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 sqlite3_int64& aValue) ; // throw(SQLite::Exception);
void bind(const int aIndex, const sqlite3_int64& 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) ; // throw(SQLite::Exception);
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 This uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
*/
void bind(const int aIndex, const std::string& aValue) ; // throw(SQLite::Exception);
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 This uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
*/
void bind(const int aIndex, const char* apValue) ; // throw(SQLite::Exception);
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 This 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) ; // throw(SQLite::Exception);
void bind(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)
*/
void bind(const int aIndex); // throw(SQLite::Exception);
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 int& aValue) ; // throw(SQLite::Exception);
void bind(const char* apName, const int& 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 sqlite3_int64& aValue) ; // throw(SQLite::Exception);
void bind(const char* apName, const sqlite3_int64& 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) ; // throw(SQLite::Exception);
void bind(const char* apName, const double& aValue);
/**
* @brief Bind a string value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
*
* @note This uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
*/
void bind(const char* apName, const std::string& aValue) ; // throw(SQLite::Exception);
void bind(const char* apName, const std::string& aValue);
/**
* @brief Bind a text value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
*
* @note This uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
*/
void bind(const char* apName, const char* apValue) ; // throw(SQLite::Exception);
void bind(const char* apName, const char* apValue);
/**
* @brief Bind a binary blob value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
*
* @note This 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) ; // throw(SQLite::Exception);
void bind(const char* apName, const void* apValue, const int aSize);
/**
* @brief Bind a NULL value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
*/
void bind(const char* apName); // throw(SQLite::Exception); // bind NULL value
void bind(const char* apName); // bind NULL value
/**
* @brief Bind an int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
*/
inline void bind(const std::string& aName, const int& aValue) // throw(SQLite::Exception);
inline void bind(const std::string& aName, const int& 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)
*/
inline void bind(const std::string& aName, const sqlite3_int64& aValue) // throw(SQLite::Exception);
inline void bind(const std::string& aName, const sqlite3_int64& 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)
*/
inline void bind(const std::string& aName, const double& aValue) // throw(SQLite::Exception);
inline void bind(const std::string& aName, const double& aValue)
{
bind(aName.c_str(), aValue);
}
@ -189,7 +189,7 @@ public:
*
* @note This uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
*/
inline void bind(const std::string& aName, const std::string& aValue) // throw(SQLite::Exception);
inline void bind(const std::string& aName, const std::string& aValue)
{
bind(aName.c_str(), aValue);
}
@ -198,7 +198,7 @@ public:
*
* @note This uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
*/
inline void bind(const std::string& aName, const char* apValue) // throw(SQLite::Exception);
inline void bind(const std::string& aName, const char* apValue)
{
bind(aName.c_str(), apValue);
}
@ -207,14 +207,14 @@ public:
*
* @note This uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
*/
inline void bind(const std::string& aName, const void* apValue, const int aSize) // throw(SQLite::Exception);
inline void bind(const std::string& aName, const void* apValue, const int aSize)
{
bind(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)
*/
inline void bind(const std::string& aName) // throw(SQLite::Exception); // bind NULL value
inline void bind(const std::string& aName) // bind NULL value
{
bind(aName.c_str());
}
@ -238,7 +238,7 @@ public:
*
* @throw SQLite::Exception in case of error
*/
bool executeStep(void); // throw(SQLite::Exception);
bool executeStep(void);
/**
* @brief Execute a one-step query with no expected result.
@ -259,7 +259,7 @@ public:
*
* @throw SQLite::Exception in case of error, or if row of results are returned !
*/
int exec(void); // throw(SQLite::Exception);
int exec(void);
////////////////////////////////////////////////////////////////////////////
@ -288,7 +288,7 @@ public:
* 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); // throw(SQLite::Exception);
Column getColumn(const int aIndex);
/**
* @brief Test if the column value is NULL
@ -297,7 +297,7 @@ public:
*
* @return true if the column value is NULL
*/
bool isColumnNull(const int aIndex) const; // throw(SQLite::Exception);
bool isColumnNull(const int aIndex) const;
////////////////////////////////////////////////////////////////////////////
@ -365,7 +365,8 @@ public:
private:
sqlite3* mpSQLite; //!< Pointer to SQLite Database Connection Handle
sqlite3_stmt* mpStmt; //!< Pointer to SQLite Statement Object
unsigned int* mpRefCount; //!< Pointer to the heap allocated reference counter of the sqlite3_stmt (to share it with Column objects)
unsigned int* mpRefCount; //!< Pointer to the heap allocated reference counter of the sqlite3_stmt
//!< (to share it with Column objects)
};
private:
@ -379,7 +380,7 @@ private:
*
* @param[in] SQLite return code to test against the SQLITE_OK expected value
*/
void check(const int aRet) const; // throw(SQLite::Exception);
void check(const int aRet) const;
private:
std::string mQuery; //!< UTF-8 SQL Query

4
include/SQLiteCpp/Transaction.h
View File

@ -50,7 +50,7 @@ public:
*
* Exception is thrown in case of error, then the Transaction is NOT initiated.
*/
explicit Transaction(Database& aDatabase); // throw(SQLite::Exception);
explicit Transaction(Database& aDatabase);
/**
* @brief Safely rollback the transaction if it has not been committed.
@ -60,7 +60,7 @@ public:
/**
* @brief Commit the transaction.
*/
void commit(void); // throw(SQLite::Exception);
void commit(void);
private:
// Transaction must be non-copyable

196
src/Column.cpp
View File

@ -1,98 +1,98 @@
/**
* @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-2014 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 <SQLiteCpp/Column.h>
#include <iostream>
namespace SQLite
{
// 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),
mIndex (aIndex)
{
}
// Finalize and unregister the SQL query from the SQLite Database Connection.
Column::~Column(void) noexcept // nothrow
{
// the finalization will be done by the destructor of the last shared pointer
}
// Return the named assigned to this result column (potentially aliased)
const char * Column::getName(void) const noexcept // nothrow
{
return sqlite3_column_name(mStmtPtr, 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(void) const noexcept // nothrow
{
return sqlite3_column_origin_name(mStmtPtr, mIndex);
}
#endif
// Return the integer value of the column specified by its index starting at 0
int Column::getInt(void) const noexcept // nothrow
{
return sqlite3_column_int(mStmtPtr, mIndex);
}
// Return the 64bits integer value of the column specified by its index starting at 0
sqlite3_int64 Column::getInt64(void) const noexcept // nothrow
{
return sqlite3_column_int64(mStmtPtr, mIndex);
}
// Return the double value of the column specified by its index starting at 0
double Column::getDouble(void) const noexcept // nothrow
{
return sqlite3_column_double(mStmtPtr, 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 // nothrow
{
const char* pText = (const char*)sqlite3_column_text(mStmtPtr, mIndex);
return (pText?pText:apDefaultValue);
}
// Return a pointer to the text value (NULL terminated string) of the column specified by its index starting at 0
const void* Column::getBlob(void) const noexcept // nothrow
{
return sqlite3_column_blob(mStmtPtr, mIndex);
}
// Return the type of the value of the column
int Column::getType(void) const noexcept // nothrow
{
return sqlite3_column_type(mStmtPtr, mIndex);
}
// Return the number of bytes used by the text value of the column
int Column::getBytes(void) const noexcept // nothrow
{
return sqlite3_column_bytes(mStmtPtr, mIndex);
}
// Standard std::ostream inserter
std::ostream& operator<<(std::ostream& aStream, const Column& aColumn)
{
aStream << aColumn.getText();
return aStream;
}
} // namespace SQLite
/**
* @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-2014 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 <SQLiteCpp/Column.h>
#include <iostream>
namespace SQLite
{
// 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),
mIndex(aIndex)
{
}
// Finalize and unregister the SQL query from the SQLite Database Connection.
Column::~Column(void) noexcept // nothrow
{
// the finalization will be done by the destructor of the last shared pointer
}
// Return the named assigned to this result column (potentially aliased)
const char * Column::getName(void) const noexcept // nothrow
{
return sqlite3_column_name(mStmtPtr, 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(void) const noexcept // nothrow
{
return sqlite3_column_origin_name(mStmtPtr, mIndex);
}
#endif
// Return the integer value of the column specified by its index starting at 0
int Column::getInt(void) const noexcept // nothrow
{
return sqlite3_column_int(mStmtPtr, mIndex);
}
// Return the 64bits integer value of the column specified by its index starting at 0
sqlite3_int64 Column::getInt64(void) const noexcept // nothrow
{
return sqlite3_column_int64(mStmtPtr, mIndex);
}
// Return the double value of the column specified by its index starting at 0
double Column::getDouble(void) const noexcept // nothrow
{
return sqlite3_column_double(mStmtPtr, 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 // nothrow
{
const char* pText = (const char*)sqlite3_column_text(mStmtPtr, mIndex);
return (pText?pText:apDefaultValue);
}
// Return a pointer to the text value (NULL terminated string) of the column specified by its index starting at 0
const void* Column::getBlob(void) const noexcept // nothrow
{
return sqlite3_column_blob(mStmtPtr, mIndex);
}
// Return the type of the value of the column
int Column::getType(void) const noexcept // nothrow
{
return sqlite3_column_type(mStmtPtr, mIndex);
}
// Return the number of bytes used by the text value of the column
int Column::getBytes(void) const noexcept // nothrow
{
return sqlite3_column_bytes(mStmtPtr, mIndex);
}
// Standard std::ostream inserter
std::ostream& operator<<(std::ostream& aStream, const Column& aColumn)
{
aStream << aColumn.getText();
return aStream;
}
} // namespace SQLite

25
src/Database.cpp
View File

@ -14,16 +14,19 @@
#include <SQLiteCpp/Assertion.h>
#include <SQLiteCpp/Exception.h>
#include <string>
#ifndef SQLITE_DETERMINISTIC
#define SQLITE_DETERMINISTIC 0x800
#endif //SQLITE_DETERMINISTIC
#endif // SQLITE_DETERMINISTIC
namespace SQLite
{
// 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 char* apVfs /*= NULL*/) : // throw(SQLite::Exception)
Database::Database(const char* apFilename, const int aFlags /*= SQLITE_OPEN_READONLY*/, const char* apVfs /*= NULL*/) :
mpSQLite(NULL),
mFilename(apFilename)
{
@ -37,7 +40,7 @@ Database::Database(const char* apFilename, const int aFlags /*= SQLITE_OPEN_READ
}
// 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 std::string& aVfs /*= ""*/) : // throw(SQLite::Exception)
Database::Database(const std::string& aFilename, const int aFlags /*= SQLITE_OPEN_READONLY*/, const std::string& aVfs) :
mpSQLite(NULL),
mFilename(aFilename)
{
@ -55,11 +58,11 @@ Database::~Database(void) noexcept // nothrow
{
int ret = sqlite3_close(mpSQLite);
// Never throw an exception in a destructor
SQLITECPP_ASSERT (SQLITE_OK == ret, sqlite3_errmsg(mpSQLite)); // See SQLITECPP_ENABLE_ASSERT_HANDLER
SQLITECPP_ASSERT(SQLITE_OK == ret, sqlite3_errmsg(mpSQLite)); // See SQLITECPP_ENABLE_ASSERT_HANDLER
}
// Shortcut to execute one or multiple SQL statements without results (UPDATE, INSERT, ALTER, COMMIT...).
int Database::exec(const char* apQueries) // throw(SQLite::Exception);
int Database::exec(const char* apQueries)
{
int ret = sqlite3_exec(mpSQLite, apQueries, NULL, NULL, NULL);
check(ret);
@ -74,7 +77,7 @@ int Database::exec(const char* apQueries) // throw(SQLite::Exception);
// (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) // throw(SQLite::Exception)
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()
@ -82,7 +85,7 @@ Column Database::execAndGet(const char* apQuery) // throw(SQLite::Exception)
}
// Shortcut to test if a table exists.
bool Database::tableExists(const char* apTableName) // throw(SQLite::Exception)
bool Database::tableExists(const char* apTableName)
{
Statement query(*this, "SELECT count(*) FROM sqlite_master WHERE type='table' AND name=?");
query.bind(1, apTableName);
@ -92,14 +95,14 @@ bool Database::tableExists(const char* apTableName) // throw(SQLite::Exception)
}
// Check if aRet equal SQLITE_OK, else throw a SQLite::Exception with the SQLite error message
void Database::check(const int aRet) const // throw(SQLite::Exception)
void Database::check(const int aRet) const
{
if (SQLITE_OK != aRet)
{
throw SQLite::Exception(sqlite3_errmsg(mpSQLite));
}
}
// 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,
@ -108,7 +111,7 @@ void Database::createFunction(const char* apFuncName,
void* apApp,
void (*apFunc)(sqlite3_context *, int, sqlite3_value **),
void (*apStep)(sqlite3_context *, int, sqlite3_value **),
void (*apFinal)(sqlite3_context *),
void (*apFinal)(sqlite3_context *), // NOLINT(readability/casting)
void (*apDestroy)(void *))
{
int TextRep = SQLITE_UTF8;
@ -118,7 +121,7 @@ void Database::createFunction(const char* apFuncName,
}
int ret = sqlite3_create_function_v2(mpSQLite, apFuncName, aNbArg, TextRep,
apApp, apFunc, apStep, apFinal, apDestroy);
check(ret);
}

51
src/Statement.cpp
View File

@ -15,12 +15,14 @@
#include <SQLiteCpp/Assertion.h>
#include <SQLiteCpp/Exception.h>
#include <string>
namespace SQLite
{
// Compile and register the SQL query for the provided SQLite Database Connection
Statement::Statement(Database &aDatabase, const char* apQuery) : // throw(SQLite::Exception)
Statement::Statement(Database &aDatabase, const char* apQuery) :
mQuery(apQuery),
mStmtPtr(aDatabase.mpSQLite, mQuery), // prepare the SQL query, and ref count (needs Database friendship)
mColumnCount(0),
@ -31,7 +33,7 @@ Statement::Statement(Database &aDatabase, const char* apQuery) : // throw(SQLite
}
// Compile and register the SQL query for the provided SQLite Database Connection
Statement::Statement(Database &aDatabase, const std::string& aQuery) : // throw(SQLite::Exception)
Statement::Statement(Database &aDatabase, const std::string& aQuery) :
mQuery(aQuery),
mStmtPtr(aDatabase.mpSQLite, mQuery), // prepare the SQL query, and ref count (needs Database friendship)
mColumnCount(0),
@ -48,7 +50,7 @@ Statement::~Statement(void) noexcept // nothrow
}
// Reset the statement to make it ready for a new execution
void Statement::reset(void) // throw(SQLite::Exception)
void Statement::reset(void)
{
mbOk = false;
mbDone = false;
@ -57,49 +59,49 @@ void Statement::reset(void) // throw(SQLite::Exception)
}
// Bind an int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const int aIndex, const int& aValue) // throw(SQLite::Exception)
void Statement::bind(const int aIndex, const int& aValue)
{
int ret = sqlite3_bind_int(mStmtPtr, 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 sqlite3_int64& aValue) // throw(SQLite::Exception)
void Statement::bind(const int aIndex, const sqlite3_int64& aValue)
{
int ret = sqlite3_bind_int64(mStmtPtr, 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) // throw(SQLite::Exception)
void Statement::bind(const int aIndex, const double& aValue)
{
int ret = sqlite3_bind_double(mStmtPtr, 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) // throw(SQLite::Exception)
void Statement::bind(const int aIndex, const std::string& aValue)
{
int ret = sqlite3_bind_text(mStmtPtr, 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) // throw(SQLite::Exception)
void Statement::bind(const int aIndex, const char* apValue)
{
int ret = sqlite3_bind_text(mStmtPtr, 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) // throw(SQLite::Exception)
void Statement::bind(const int aIndex, const void* apValue, const int aSize)
{
int ret = sqlite3_bind_blob(mStmtPtr, aIndex, apValue, aSize, SQLITE_TRANSIENT);
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) // throw(SQLite::Exception)
void Statement::bind(const int aIndex)
{
int ret = sqlite3_bind_null(mStmtPtr, aIndex);
check(ret);
@ -107,7 +109,7 @@ void Statement::bind(const int aIndex) // throw(SQLite::Exception)
// Bind an int value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const char* apName, const int& aValue) // throw(SQLite::Exception)
void Statement::bind(const char* apName, const int& aValue)
{
int index = sqlite3_bind_parameter_index(mStmtPtr, apName);
int ret = sqlite3_bind_int(mStmtPtr, index, aValue);
@ -115,7 +117,7 @@ void Statement::bind(const char* apName, const int& aValue) // throw(SQLite::Exc
}
// Bind a 64bits int value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const char* apName, const sqlite3_int64& aValue) // throw(SQLite::Exception)
void Statement::bind(const char* apName, const sqlite3_int64& aValue)
{
int index = sqlite3_bind_parameter_index(mStmtPtr, apName);
int ret = sqlite3_bind_int64(mStmtPtr, index, aValue);
@ -123,7 +125,7 @@ void Statement::bind(const char* apName, const sqlite3_int64& aValue) // throw(S
}
// Bind a double (64bits float) value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const char* apName, const double& aValue) // throw(SQLite::Exception)
void Statement::bind(const char* apName, const double& aValue)
{
int index = sqlite3_bind_parameter_index(mStmtPtr, apName);
int ret = sqlite3_bind_double(mStmtPtr, index, aValue);
@ -131,7 +133,7 @@ void Statement::bind(const char* apName, const double& aValue) // throw(SQLite::
}
// Bind a string value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const char* apName, const std::string& aValue) // throw(SQLite::Exception)
void Statement::bind(const char* apName, const std::string& aValue)
{
int index = sqlite3_bind_parameter_index(mStmtPtr, apName);
int ret = sqlite3_bind_text(mStmtPtr, index, aValue.c_str(), static_cast<int>(aValue.size()), SQLITE_TRANSIENT);
@ -139,7 +141,7 @@ void Statement::bind(const char* apName, const std::string& aValue) // throw(SQL
}
// Bind a text value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const char* apName, const char* apValue) // throw(SQLite::Exception)
void Statement::bind(const char* apName, const char* apValue)
{
int index = sqlite3_bind_parameter_index(mStmtPtr, apName);
int ret = sqlite3_bind_text(mStmtPtr, index, apValue, -1, SQLITE_TRANSIENT);
@ -147,7 +149,7 @@ void Statement::bind(const char* apName, const char* apValue) // throw(SQLite::E
}
// Bind a binary blob value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const char* apName, const void* apValue, const int aSize) // throw(SQLite::Exception)
void Statement::bind(const char* apName, const void* apValue, const int aSize)
{
int index = sqlite3_bind_parameter_index(mStmtPtr, apName);
int ret = sqlite3_bind_blob(mStmtPtr, index, apValue, aSize, SQLITE_TRANSIENT);
@ -155,7 +157,7 @@ void Statement::bind(const char* apName, const void* apValue, const int aSize) /
}
// Bind a NULL value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const char* apName) // throw(SQLite::Exception)
void Statement::bind(const char* apName)
{
int index = sqlite3_bind_parameter_index(mStmtPtr, apName);
int ret = sqlite3_bind_null(mStmtPtr, index);
@ -164,7 +166,7 @@ void Statement::bind(const char* apName) // throw(SQLite::Exception)
// Execute a step of the query to fetch one row of results
bool Statement::executeStep(void) // throw(SQLite::Exception)
bool Statement::executeStep(void)
{
if (false == mbDone)
{
@ -194,7 +196,7 @@ bool Statement::executeStep(void) // throw(SQLite::Exception)
}
// Execute a one-step query with no expected result
int Statement::exec(void) // throw(SQLite::Exception)
int Statement::exec(void)
{
if (false == mbDone)
{
@ -228,7 +230,7 @@ int Statement::exec(void) // throw(SQLite::Exception)
// 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) // throw(SQLite::Exception)
Column Statement::getColumn(const int aIndex)
{
if (false == mbOk)
{
@ -244,7 +246,7 @@ Column Statement::getColumn(const int aIndex) // throw(SQLite::Exception)
}
// Test if the column is NULL
bool Statement::isColumnNull(const int aIndex) const // throw(SQLite::Exception)
bool Statement::isColumnNull(const int aIndex) const
{
if (false == mbOk)
{
@ -259,7 +261,7 @@ bool Statement::isColumnNull(const int aIndex) const // throw(SQLite::Exception)
}
// Check if aRet equal SQLITE_OK, else throw a SQLite::Exception with the SQLite error message
void Statement::check(const int aRet) const // throw(SQLite::Exception)
void Statement::check(const int aRet) const
{
if (SQLITE_OK != aRet)
{
@ -291,7 +293,7 @@ Statement::Ptr::Ptr(sqlite3* apSQLite, std::string& aQuery) :
// Initialize the reference counter of the sqlite3_stmt :
// used to share the mStmtPtr between Statement and Column objects;
// This is needed to enable Column objects to live longer than the Statement objet it refers to.
mpRefCount = new unsigned int(1);
mpRefCount = new unsigned int(1); // NOLINT(readability/casting)
}
/**
@ -328,7 +330,7 @@ Statement::Ptr::~Ptr(void) noexcept // nothrow
// as no Statement not Column objet use it anymore
int ret = sqlite3_finalize(mpStmt);
// Never throw an exception in a destructor
SQLITECPP_ASSERT (SQLITE_OK == ret, sqlite3_errmsg(mpSQLite)); // See SQLITECPP_ENABLE_ASSERT_HANDLER
SQLITECPP_ASSERT(SQLITE_OK == ret, sqlite3_errmsg(mpSQLite)); // See SQLITECPP_ENABLE_ASSERT_HANDLER
// and delete the reference counter
delete mpRefCount;
@ -338,4 +340,5 @@ Statement::Ptr::~Ptr(void) noexcept // nothrow
// else, the finalization will be done later, by the last object
}
} // namespace SQLite

4
src/Transaction.cpp
View File

@ -19,7 +19,7 @@ namespace SQLite
// Begins the SQLite transaction
Transaction::Transaction(Database& aDatabase) : // throw(SQLite::Exception)
Transaction::Transaction(Database& aDatabase) :
mDatabase(aDatabase),
mbCommited(false)
{
@ -44,7 +44,7 @@ Transaction::~Transaction(void) noexcept // nothrow
}
// Commit the transaction.
void Transaction::commit(void) // throw(SQLite::Exception)
void Transaction::commit(void)
{
if (false == mbCommited)
{