diff --git a/cpplint.py b/cpplint.py
index e644136..da63df9 100755
--- a/cpplint.py
+++ b/cpplint.py
@@ -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.')
 
 
diff --git a/include/SQLiteCpp/Assertion.h b/include/SQLiteCpp/Assertion.h
index d578a50..ae611ab 100644
--- a/include/SQLiteCpp/Assertion.h
+++ b/include/SQLiteCpp/Assertion.h
@@ -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
diff --git a/include/SQLiteCpp/Column.h b/include/SQLiteCpp/Column.h
index e65e285..8f3c2c2 100644
--- a/include/SQLiteCpp/Column.h
+++ b/include/SQLiteCpp/Column.h
@@ -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)
diff --git a/include/SQLiteCpp/Database.h b/include/SQLiteCpp/Database.h
index 48d8fd1..9e1c46e 100644
--- a/include/SQLiteCpp/Database.h
+++ b/include/SQLiteCpp/Database.h
@@ -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
diff --git a/include/SQLiteCpp/Exception.h b/include/SQLiteCpp/Exception.h
index d8fdbc6..43b621e 100644
--- a/include/SQLiteCpp/Exception.h
+++ b/include/SQLiteCpp/Exception.h
@@ -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.
diff --git a/include/SQLiteCpp/SQLiteCpp.h b/include/SQLiteCpp/SQLiteCpp.h
index eafa323..6228001 100644
--- a/include/SQLiteCpp/SQLiteCpp.h
+++ b/include/SQLiteCpp/SQLiteCpp.h
@@ -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
diff --git a/include/SQLiteCpp/Statement.h b/include/SQLiteCpp/Statement.h
index 2eeb2e6..6563eeb 100644
--- a/include/SQLiteCpp/Statement.h
+++ b/include/SQLiteCpp/Statement.h
@@ -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
diff --git a/include/SQLiteCpp/Transaction.h b/include/SQLiteCpp/Transaction.h
index 69649bc..a5b493f 100644
--- a/include/SQLiteCpp/Transaction.h
+++ b/include/SQLiteCpp/Transaction.h
@@ -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
diff --git a/src/Column.cpp b/src/Column.cpp
index eb97a2e..cec87b2 100644
--- a/src/Column.cpp
+++ b/src/Column.cpp
@@ -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
diff --git a/src/Database.cpp b/src/Database.cpp
index b847f15..eb7bc5a 100644
--- a/src/Database.cpp
+++ b/src/Database.cpp
@@ -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);
 }
 
diff --git a/src/Statement.cpp b/src/Statement.cpp
index 0bcf409..8630280 100644
--- a/src/Statement.cpp
+++ b/src/Statement.cpp
@@ -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
diff --git a/src/Transaction.cpp b/src/Transaction.cpp
index 0f37cf3..eb38ceb 100644
--- a/src/Transaction.cpp
+++ b/src/Transaction.cpp
@@ -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)
     {