diff --git a/README.md b/README.md
index 48839d43..dc8c040c 100644
--- a/README.md
+++ b/README.md
@@ -4,26 +4,8 @@ A type safe embedded domain specific language for SQL queries and results in C++
 
 Documentation is found in the [wiki](https://github.com/rbock/sqlpp11/wiki)
 
-Contact:
---------
-  * Issues at https://github.com/rbock/sqlpp11/issues
-  * email at rbock at eudoxos dot de
-  * [![Join the chat at https://gitter.im/sqlpp11/Lobby](https://badges.gitter.im/sqlpp11/Lobby.svg)](https://gitter.im/sqlpp11/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-Breaking changes in 0.36:
--------------------------
-See [Changes](ChangeLog.md)
-
-Status:
--------
-
-Branch / Compiler | clang-3.4,  gcc-4.9, Xcode-7   |  MSVC 2015/2017  | Test Coverage
-------------------| -------------------------------|-------------|---------------
-master | [![Build Status](https://travis-ci.org/rbock/sqlpp11.svg?branch=master)](https://travis-ci.org/rbock/sqlpp11?branch=master) | [![Build status](https://ci.appveyor.com/api/projects/status/eid7mwqgavo0h61h/branch/master?svg=true)](https://ci.appveyor.com/project/rbock/sqlpp11/branch/master) | [![Coverage Status](https://coveralls.io/repos/rbock/sqlpp11/badge.svg?branch=master)](https://coveralls.io/r/rbock/sqlpp11?branch=master)
-develop | [![Build Status](https://travis-ci.org/rbock/sqlpp11.svg?branch=develop)](https://travis-ci.org/rbock/sqlpp11?branch=develop) | [![Build status](https://ci.appveyor.com/api/projects/status/eid7mwqgavo0h61h/branch/develop?svg=true)](https://ci.appveyor.com/project/rbock/sqlpp11/branch/develop) | [![Coverage Status](https://coveralls.io/repos/rbock/sqlpp11/badge.svg?branch=develop)](https://coveralls.io/r/rbock/sqlpp11?branch=develop)
-
-Motivation:
------------
+So what is this about?
+----------------------
 SQL and C++ are both strongly typed languages. Still, most C/C++ interfaces to SQL are based on constructing queries as strings and on interpreting arrays or maps of strings as results.
 
 sqlpp11 is a templated library representing an embedded domain specific language (EDSL) that allows you to
@@ -100,6 +82,21 @@ db(update(foo).set(foo.hasFun = not foo.hasFun).where(foo.name != "nobody"));
 db(remove_from(foo).where(not foo.hasFun));
 ```
 
+License:
+-------------
+sqlpp11 is distributed under the [BSD 2-Clause License](https://github.com/rbock/sqlpp11/blob/master/LICENSE).
+
+Status:
+-------
+Branch / Compiler | clang-3.4,  gcc-4.9, Xcode-7   |  MSVC 2015/2017  | Test Coverage
+------------------| -------------------------------|-------------|---------------
+master | [![Build Status](https://travis-ci.org/rbock/sqlpp11.svg?branch=master)](https://travis-ci.org/rbock/sqlpp11?branch=master) | [![Build status](https://ci.appveyor.com/api/projects/status/eid7mwqgavo0h61h/branch/master?svg=true)](https://ci.appveyor.com/project/rbock/sqlpp11/branch/master) | [![Coverage Status](https://coveralls.io/repos/rbock/sqlpp11/badge.svg?branch=master)](https://coveralls.io/r/rbock/sqlpp11?branch=master)
+develop | [![Build Status](https://travis-ci.org/rbock/sqlpp11.svg?branch=develop)](https://travis-ci.org/rbock/sqlpp11?branch=develop) | [![Build status](https://ci.appveyor.com/api/projects/status/eid7mwqgavo0h61h/branch/develop?svg=true)](https://ci.appveyor.com/project/rbock/sqlpp11/branch/develop) | [![Coverage Status](https://coveralls.io/repos/rbock/sqlpp11/badge.svg?branch=develop)](https://coveralls.io/r/rbock/sqlpp11?branch=develop)
+
+MSVC 2017 is currently broken, see
+   - https://github.com/rbock/sqlpp11/issues/181
+   - https://developercommunity.visualstudio.com/content/problem/95983/c-vs152-153-regression-in-variadic-template-argume.html
+
 Additional information available:
 ---------------------------------
 Past talks about sqlpp11 and some coding concepts used within the library:
@@ -192,7 +189,14 @@ Include generated header (MyTable.h), that's all.
 
 If you prefer Ruby over Python, you might want to take a look at https://github.com/douyw/sqlpp11gen
 
-License:
--------------
-sqlpp11 is distributed under the [BSD 2-Clause License](https://github.com/rbock/sqlpp11/blob/master/LICENSE).
+Contact:
+--------
+  * Issues at https://github.com/rbock/sqlpp11/issues
+  * email at rbock at eudoxos dot de
+  * [![Join the chat at https://gitter.im/sqlpp11/Lobby](https://badges.gitter.im/sqlpp11/Lobby.svg)](https://gitter.im/sqlpp11/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Breaking changes in 0.36:
+-------------------------
+See [Changes](ChangeLog.md)
+
 
diff --git a/include/sqlpp11/aggregate_functions.h b/include/sqlpp11/aggregate_functions.h
index 4d250a77..d2904b96 100644
--- a/include/sqlpp11/aggregate_functions.h
+++ b/include/sqlpp11/aggregate_functions.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_AGGREGATE_FUNCTIONS_H
-#define SQLPP_AGGREGATE_FUNCTIONS_H
+#ifndef SQLPP11_AGGREGATE_FUNCTIONS_H
+#define SQLPP11_AGGREGATE_FUNCTIONS_H
 
 #include <sqlpp11/aggregate_functions/count.h>
 #include <sqlpp11/aggregate_functions/min.h>
diff --git a/include/sqlpp11/aggregate_functions/avg.h b/include/sqlpp11/aggregate_functions/avg.h
index f3c273b8..a9df9e62 100644
--- a/include/sqlpp11/aggregate_functions/avg.h
+++ b/include/sqlpp11/aggregate_functions/avg.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_AVG_H
-#define SQLPP_AVG_H
+#ifndef SQLPP11_AGGREGATE_FUNCTIONS_AVG_H
+#define SQLPP11_AGGREGATE_FUNCTIONS_AVG_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/char_sequence.h>
@@ -116,13 +116,13 @@ namespace sqlpp
   }
 
   template <typename T>
-  auto avg(const distinct_t&, T t) -> avg_t<distinct_t, wrap_operand_t<T>>
+  auto avg(const distinct_t& /*unused*/, T t) -> avg_t<distinct_t, wrap_operand_t<T>>
   {
     static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
                   "avg() cannot be used on an aggregate function");
     static_assert(is_numeric_t<wrap_operand_t<T>>::value, "avg() requires a numeric value expression as argument");
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/aggregate_functions/count.h b/include/sqlpp11/aggregate_functions/count.h
index 225aa6a5..79d96e52 100644
--- a/include/sqlpp11/aggregate_functions/count.h
+++ b/include/sqlpp11/aggregate_functions/count.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_COUNT_H
-#define SQLPP_COUNT_H
+#ifndef SQLPP11_AGGREGATE_FUNCTIONS_COUNT_H
+#define SQLPP11_AGGREGATE_FUNCTIONS_COUNT_H
 
 #include <sqlpp11/char_sequence.h>
 #include <sqlpp11/select_flags.h>
@@ -117,13 +117,13 @@ namespace sqlpp
   }
 
   template <typename T>
-  auto count(const distinct_t&, T t) -> count_t<distinct_t, wrap_operand_t<T>>
+  auto count(const distinct_t& /*unused*/, T t) -> count_t<distinct_t, wrap_operand_t<T>>
   {
     static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
                   "count() cannot be used on an aggregate function");
     static_assert(is_expression_t<wrap_operand_t<T>>::value, "count() requires an expression as argument");
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/aggregate_functions/max.h b/include/sqlpp11/aggregate_functions/max.h
index abe29d6a..16faaa47 100644
--- a/include/sqlpp11/aggregate_functions/max.h
+++ b/include/sqlpp11/aggregate_functions/max.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_MAX_H
-#define SQLPP_MAX_H
+#ifndef SQLPP11_AGGREGATE_FUNCTIONS_MAX_H
+#define SQLPP11_AGGREGATE_FUNCTIONS_MAX_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/char_sequence.h>
@@ -100,6 +100,6 @@ namespace sqlpp
     static_assert(is_expression_t<wrap_operand_t<T>>::value, "max() requires an expression as argument");
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/aggregate_functions/min.h b/include/sqlpp11/aggregate_functions/min.h
index a82bf9c7..37604e03 100644
--- a/include/sqlpp11/aggregate_functions/min.h
+++ b/include/sqlpp11/aggregate_functions/min.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_MIN_H
-#define SQLPP_MIN_H
+#ifndef SQLPP11_AGGREGATE_FUNCTIONS_MIN_H
+#define SQLPP11_AGGREGATE_FUNCTIONS_MIN_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/char_sequence.h>
@@ -100,6 +100,6 @@ namespace sqlpp
     static_assert(is_expression_t<wrap_operand_t<T>>::value, "min() requires an expression as argument");
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/aggregate_functions/sum.h b/include/sqlpp11/aggregate_functions/sum.h
index cee32aed..67428472 100644
--- a/include/sqlpp11/aggregate_functions/sum.h
+++ b/include/sqlpp11/aggregate_functions/sum.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SUM_H
-#define SQLPP_SUM_H
+#ifndef SQLPP11_AGGREGATE_FUNCTIONS_SUM_H
+#define SQLPP11_AGGREGATE_FUNCTIONS_SUM_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/char_sequence.h>
@@ -98,7 +98,9 @@ namespace sqlpp
         serialize_operand(t._expr, context);
       }
       else
+      {
         serialize(t._expr, context);
+      }
 
       context << ")";
       return context;
@@ -115,13 +117,13 @@ namespace sqlpp
   }
 
   template <typename T>
-  auto sum(const distinct_t&, T t) -> sum_t<distinct_t, wrap_operand_t<T>>
+  auto sum(const distinct_t& /*unused*/, T t) -> sum_t<distinct_t, wrap_operand_t<T>>
   {
     static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
                   "sum() cannot be used on an aggregate function");
     static_assert(is_numeric_t<wrap_operand_t<T>>::value, "sum() requires a numeric expression as argument");
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/alias.h b/include/sqlpp11/alias.h
index 0a041a9e..197862cf 100644
--- a/include/sqlpp11/alias.h
+++ b/include/sqlpp11/alias.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_ALIAS_H
-#define SQLPP_ALIAS_H
+#ifndef SQLPP11_ALIAS_H
+#define SQLPP11_ALIAS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/serializer.h>
@@ -70,6 +70,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/alias_operators.h b/include/sqlpp11/alias_operators.h
index 0a03eb3f..da318f19 100644
--- a/include/sqlpp11/alias_operators.h
+++ b/include/sqlpp11/alias_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_ALIAS_OPERATORS_H
-#define SQLPP_ALIAS_OPERATORS_H
+#ifndef SQLPP11_ALIAS_OPERATORS_H
+#define SQLPP11_ALIAS_OPERATORS_H
 
 #include <sqlpp11/alias.h>
 
@@ -35,10 +35,10 @@ namespace sqlpp
   struct alias_operators
   {
     template <typename alias_provider>
-    expression_alias_t<Expr, alias_provider> as(const alias_provider&) const
+    expression_alias_t<Expr, alias_provider> as(const alias_provider& /*unused*/) const
     {
       return {*static_cast<const Expr*>(this)};
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/alias_provider.h b/include/sqlpp11/alias_provider.h
index 3c1abbd4..b77a9e20 100644
--- a/include/sqlpp11/alias_provider.h
+++ b/include/sqlpp11/alias_provider.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_ALIAS_PROVIDER_H
-#define SQLPP_ALIAS_PROVIDER_H
+#ifndef SQLPP11_ALIAS_PROVIDER_H
+#define SQLPP11_ALIAS_PROVIDER_H
 
 #include <type_traits>
 #include <sqlpp11/char_sequence.h>
@@ -100,7 +100,7 @@ namespace sqlpp
     SQLPP_ALIAS_PROVIDER(z)
     SQLPP_ALIAS_PROVIDER(left)
     SQLPP_ALIAS_PROVIDER(right)
-  }
-}
+  }  // namespace alias
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/all_of.h b/include/sqlpp11/all_of.h
index b7a2ea85..0a23a168 100644
--- a/include/sqlpp11/all_of.h
+++ b/include/sqlpp11/all_of.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_ALL_OF_H
-#define SQLPP_ALL_OF_H
+#ifndef SQLPP11_ALL_OF_H
+#define SQLPP11_ALL_OF_H
 
 #include <sqlpp11/alias.h>
 #include <sqlpp11/interpret.h>
@@ -47,7 +47,7 @@ namespace sqlpp
   };
 
   template <typename Table>
-  auto all_of(Table) -> all_of_t<Table>
+  auto all_of(Table /*unused*/) -> all_of_t<Table>
   {
     return {};
   }
@@ -60,11 +60,11 @@ namespace sqlpp
     using _serialize_check = assert_no_stand_alone_all_of_t;
     using T = all_of_t<Table>;
 
-    static Context& _(const T&, const Context&)
+    static Context& _(const T& /*unused*/, const Context& /*unused*/)
     {
       _serialize_check{};
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/any.h b/include/sqlpp11/any.h
index d3f125c2..d8e86d04 100644
--- a/include/sqlpp11/any.h
+++ b/include/sqlpp11/any.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_ANY_H
-#define SQLPP_ANY_H
+#ifndef SQLPP11_ANY_H
+#define SQLPP11_ANY_H
 
 #include <sqlpp11/data_types/boolean.h>
 #include <sqlpp11/char_sequence.h>
@@ -76,6 +76,6 @@ namespace sqlpp
     // FIXME: can we accept non-values like NULL here?
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/assignment.h b/include/sqlpp11/assignment.h
index 7517f8f5..529d20ae 100644
--- a/include/sqlpp11/assignment.h
+++ b/include/sqlpp11/assignment.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_ASSIGNMENT_H
-#define SQLPP_ASSIGNMENT_H
+#ifndef SQLPP11_ASSIGNMENT_H
+#define SQLPP11_ASSIGNMENT_H
 
 #include <sqlpp11/default_value.h>
 #include <sqlpp11/null.h>
@@ -77,6 +77,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/auto_alias.h b/include/sqlpp11/auto_alias.h
index 43ce044c..f54628c5 100644
--- a/include/sqlpp11/auto_alias.h
+++ b/include/sqlpp11/auto_alias.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_AUTO_ALIAS_H
-#define SQLPP_AUTO_ALIAS_H
+#ifndef SQLPP11_AUTO_ALIAS_H
+#define SQLPP11_AUTO_ALIAS_H
 
 #include <sqlpp11/alias.h>
 
@@ -56,10 +56,10 @@ namespace sqlpp
     {
       using type = expression_alias_t<T, typename T::_auto_alias_t>;
     };
-  }
+  }  // namespace detail
 
   template <typename T>
   using auto_alias_t = typename detail::auto_alias_impl<T>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/bad_expression.h b/include/sqlpp11/bad_expression.h
index 3aa43f0c..c8c37712 100644
--- a/include/sqlpp11/bad_expression.h
+++ b/include/sqlpp11/bad_expression.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BAD_EXPRESSION_H
-#define SQLPP_BAD_EXPRESSION_H
+#ifndef SQLPP11_BAD_EXPRESSION_H
+#define SQLPP11_BAD_EXPRESSION_H
 
 #include <sqlpp11/portable_static_assert.h>
 #include <sqlpp11/type_traits.h>
@@ -38,7 +38,7 @@ namespace sqlpp
   struct bad_expression
   {
     template <typename... T>
-    bad_expression(T&&...)
+    bad_expression(T&&... /*unused*/)
     {
     }
     using _traits = make_traits<ValueType, tag::is_expression>;
@@ -53,6 +53,6 @@ namespace sqlpp
 
     static Context& _(const T&, Context&);
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/basic_expression_operators.h b/include/sqlpp11/basic_expression_operators.h
index ffa56525..f4665b73 100644
--- a/include/sqlpp11/basic_expression_operators.h
+++ b/include/sqlpp11/basic_expression_operators.h
@@ -25,8 +25,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_BASIC_EXPRESSION_OPERATORS_H
-#define SQLPP_DETAIL_BASIC_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_BASIC_EXPRESSION_OPERATORS_H
+#define SQLPP11_BASIC_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/value_type_fwd.h>
 #include <sqlpp11/bad_expression.h>
@@ -82,7 +82,7 @@ namespace sqlpp
     {
       using type = Expr<wrap_operand_t<Lhs>, wrap_operand_t<Rhs>>;
     };
-  }
+  }  // namespace detail
   template <template <typename Lhs, typename Rhs> class Expr, typename Lhs, typename Rhs>
   using comparison_expression_t =
       typename detail::comparison_expression_impl<check_comparison_t<Lhs, Rhs>::value, Expr, Lhs, Rhs>::type;
@@ -100,7 +100,7 @@ namespace sqlpp
     {
       using type = Expr<Lhs, Rhs...>;
     };
-  }
+  }  // namespace detail
   template <typename Check, template <typename Lhs, typename... Rhs> class Expr, typename Lhs, typename... Rhs>
   using in_expression_t = typename detail::in_expression_impl<Check::value, Expr, Lhs, Rhs...>::type;
 
@@ -300,6 +300,6 @@ namespace sqlpp
       return {*static_cast<const Expr*>(this)};
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/boolean_expression.h b/include/sqlpp11/boolean_expression.h
index a0652103..8da7fc7a 100644
--- a/include/sqlpp11/boolean_expression.h
+++ b/include/sqlpp11/boolean_expression.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BOOLEAN_EXPRESSION_H
-#define SQLPP_BOOLEAN_EXPRESSION_H
+#ifndef SQLPP11_BOOLEAN_EXPRESSION_H
+#define SQLPP11_BOOLEAN_EXPRESSION_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/interpretable.h>
@@ -39,8 +39,7 @@ namespace sqlpp
     using _nodes = detail::type_vector<>;
 
     template <typename Expr>
-    boolean_expression_t(Expr expr)
-        : _expr(expr)
+    boolean_expression_t(Expr expr) : _expr(expr)
     {
       static_assert(is_expression_t<Expr>::value, "boolean_expression requires a boolean expression argument");
       static_assert(is_boolean_t<Expr>::value, "boolean_expression requires a boolean expression argument");
@@ -63,7 +62,7 @@ namespace sqlpp
   }
 
   template <typename Database, typename T>
-  boolean_expression_t<Database> boolean_expression(const Database&, T t)
+  boolean_expression_t<Database> boolean_expression(const Database& /*unused*/, T t)
   {
     return boolean_expression<Database>(t);
   }
@@ -79,6 +78,6 @@ namespace sqlpp
       return serialize(t._expr, context);
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/case.h b/include/sqlpp11/case.h
index c59ff791..beface1a 100644
--- a/include/sqlpp11/case.h
+++ b/include/sqlpp11/case.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_CASE_H
-#define SQLPP_CASE_H
+#ifndef SQLPP11_CASE_H
+#define SQLPP11_CASE_H
 
 #include <sqlpp11/char_sequence.h>
 #include <sqlpp11/data_types/boolean.h>
@@ -87,7 +87,7 @@ namespace sqlpp
   class case_then_t
   {
     template <typename Else>
-    auto _else_impl(consistent_t, Else else_) -> case_t<When, Then, Else>
+    auto _else_impl(consistent_t /*unused*/, Else else_) -> case_t<When, Then, Else>
     {
       return {_when, _then, else_};
     }
@@ -121,7 +121,7 @@ namespace sqlpp
   class case_when_t
   {
     template <typename Then>
-    auto _then_impl(consistent_t, Then t) -> case_then_t<When, wrap_operand_t<Then>>
+    auto _then_impl(consistent_t /*unused*/, Then t) -> case_then_t<When, wrap_operand_t<Then>>
     {
       return {_when, t};
     }
@@ -172,20 +172,20 @@ namespace sqlpp
   namespace detail
   {
     template <typename When>
-    auto case_when_impl(consistent_t, When when) -> case_when_t<wrap_operand_t<When>>
+    auto case_when_impl(consistent_t /*unused*/, When when) -> case_when_t<wrap_operand_t<When>>
     {
       return {when};
     }
 
     template <typename Check, typename When>
     auto case_when_impl(Check, When when) -> inconsistent<Check>;
-  }
+  }  // namespace detail
 
   template <typename When>
   auto case_when(When when) -> decltype(detail::case_when_impl(check_case_when_t<When>{}, when))
   {
     return detail::case_when_impl(check_case_when_t<When>{}, when);
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/char_sequence.h b/include/sqlpp11/char_sequence.h
index 88920c22..58d294dd 100644
--- a/include/sqlpp11/char_sequence.h
+++ b/include/sqlpp11/char_sequence.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_CHAR_SEQUENCE_H
-#define SQLPP_CHAR_SEQUENCE_H
+#ifndef SQLPP11_CHAR_SEQUENCE_H
+#define SQLPP11_CHAR_SEQUENCE_H
 
 #include <sqlpp11/detail/index_sequence.h>
 
@@ -41,18 +41,18 @@ namespace sqlpp
     };
   };
 
-  template <std::size_t N, const char(&s)[N], typename T>
+  template <std::size_t N, const char (&s)[N], typename T>
   struct make_char_sequence_impl;
 
-  template <std::size_t N, const char(&s)[N], std::size_t... i>
+  template <std::size_t N, const char (&s)[N], std::size_t... i>
   struct make_char_sequence_impl<N, s, sqlpp::detail::index_sequence<i...>>
   {
     using type = char_sequence<s[i]...>;
   };
 
-  template <std::size_t N, const char(&Input)[N]>
+  template <std::size_t N, const char (&Input)[N]>
   using make_char_sequence =
       typename make_char_sequence_impl<sizeof(Input), Input, sqlpp::detail::make_index_sequence<sizeof(Input)>>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/chrono.h b/include/sqlpp11/chrono.h
index 49ae37d8..157f51eb 100644
--- a/include/sqlpp11/chrono.h
+++ b/include/sqlpp11/chrono.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_CHRONO_H
-#define SQLPP_CHRONO_H
+#ifndef SQLPP11_CHRONO_H
+#define SQLPP11_CHRONO_H
 
 #include <date.h>
 
@@ -51,7 +51,7 @@ namespace sqlpp
       const auto dp = floor<days>(t);
       return std::chrono::duration_cast<std::chrono::microseconds>(::date::make_time(t - dp).to_duration());
     }
-  }
-}
+  }  // namespace chrono
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/column.h b/include/sqlpp11/column.h
index fe22efc4..3b8497dd 100644
--- a/include/sqlpp11/column.h
+++ b/include/sqlpp11/column.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_COLUMN_H
-#define SQLPP_COLUMN_H
+#ifndef SQLPP11_COLUMN_H
+#define SQLPP11_COLUMN_H
 
 #include <sqlpp11/alias.h>
 #include <sqlpp11/column_fwd.h>
@@ -78,7 +78,7 @@ namespace sqlpp
     }
 
     template <typename alias_provider>
-    expression_alias_t<column_t, alias_provider> as(const alias_provider&) const
+    expression_alias_t<column_t, alias_provider> as(const alias_provider& /*unused*/) const
     {
       return {*this};
     }
@@ -92,13 +92,13 @@ namespace sqlpp
       return {*this, {rhs{t}}};
     }
 
-    auto operator=(null_t) const -> assignment_t<column_t, null_t>
+    auto operator=(null_t /*unused*/) const -> assignment_t<column_t, null_t>
     {
       static_assert(can_be_null_t<column_t>::value, "column cannot be null");
       return {*this, null_t{}};
     }
 
-    auto operator=(default_value_t) const -> assignment_t<column_t, default_value_t>
+    auto operator=(default_value_t /*unused*/) const -> assignment_t<column_t, default_value_t>
     {
       return {*this, default_value_t{}};
     }
@@ -123,12 +123,12 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = column_t<Args1, Args2>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << name_of<typename T::_table>::char_ptr() << '.' << name_of<T>::char_ptr();
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/column_fwd.h b/include/sqlpp11/column_fwd.h
index 6eb4415f..68f025ca 100644
--- a/include/sqlpp11/column_fwd.h
+++ b/include/sqlpp11/column_fwd.h
@@ -24,13 +24,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_COLUMN_FWD_H
-#define SQLPP_COLUMN_FWD_H
+#ifndef SQLPP11_COLUMN_FWD_H
+#define SQLPP11_COLUMN_FWD_H
 
 namespace sqlpp
 {
   template <typename Table, typename ColumnSpec>
   struct column_t;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/connection.h b/include/sqlpp11/connection.h
index 0b55fd52..b569fd4a 100644
--- a/include/sqlpp11/connection.h
+++ b/include/sqlpp11/connection.h
@@ -24,14 +24,14 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_CONNECTION_H
-#define SQLPP_CONNECTION_H
+#ifndef SQLPP11_CONNECTION_H
+#define SQLPP11_CONNECTION_H
 
 namespace sqlpp
 {
   struct connection
   {
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/consistent.h b/include/sqlpp11/consistent.h
index f60edd0e..6dbc8eb9 100644
--- a/include/sqlpp11/consistent.h
+++ b/include/sqlpp11/consistent.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_CONSISTENT_H
-#define SQLPP_CONSISTENT_H
+#ifndef SQLPP11_CONSISTENT_H
+#define SQLPP11_CONSISTENT_H
 
 #include <type_traits>
 
@@ -35,6 +35,6 @@ namespace sqlpp
   {
     static void _(){};
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/cte.h b/include/sqlpp11/cte.h
index cc7a8827..95cca8d3 100644
--- a/include/sqlpp11/cte.h
+++ b/include/sqlpp11/cte.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_CTE_H
-#define SQLPP_CTE_H
+#ifndef SQLPP11_CTE_H
+#define SQLPP11_CTE_H
 
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
@@ -86,7 +86,7 @@ namespace sqlpp
   struct cte_ref_t;
 
   template <typename AliasProvider, typename Statement, typename... FieldSpecs>
-  auto from_table(cte_t<AliasProvider, Statement, FieldSpecs...>) -> cte_ref_t<AliasProvider>
+  auto from_table(cte_t<AliasProvider, Statement, FieldSpecs...> /*unused*/) -> cte_ref_t<AliasProvider>
   {
     return cte_ref_t<AliasProvider>{};
   }
@@ -208,7 +208,7 @@ namespace sqlpp
     auto _union_impl(Check, Rhs rhs) const -> inconsistent<Check>;
 
     template <typename Flag, typename Rhs>
-    auto _union_impl(consistent_t, Rhs rhs) const
+    auto _union_impl(consistent_t /*unused*/, Rhs rhs) const
         -> cte_t<AliasProvider, cte_union_t<Flag, Statement, Rhs>, FieldSpecs...>
     {
       return cte_union_t<Flag, Statement, Rhs>{_statement, rhs};
@@ -277,7 +277,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = cte_ref_t<AliasProvider>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << name_of<T>::char_ptr();
       return context;
@@ -285,10 +285,10 @@ namespace sqlpp
   };
 
   template <typename AliasProvider>
-  auto cte(const AliasProvider&) -> cte_ref_t<AliasProvider>
+  auto cte(const AliasProvider & /*unused*/) -> cte_ref_t<AliasProvider>
   {
     return {};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/custom_query.h b/include/sqlpp11/custom_query.h
index abaf0df9..7099f306 100644
--- a/include/sqlpp11/custom_query.h
+++ b/include/sqlpp11/custom_query.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_CUSTOM_QUERY_H
-#define SQLPP_CUSTOM_QUERY_H
+#ifndef SQLPP11_CUSTOM_QUERY_H
+#define SQLPP11_CUSTOM_QUERY_H
 
 #include <sqlpp11/connection.h>
 #include <sqlpp11/detail/get_first.h>
@@ -59,7 +59,7 @@ namespace sqlpp
       using _result_type_provider = typename unhide<_maybe_hidden_result_type_provider>::type;
       using _result_methods_t = typename _result_type_provider::template _result_methods_t<_result_type_provider>;
     };
-  }
+  }  // namespace detail
 
   template <typename Database, typename... Parts>
   struct custom_query_t : private detail::custom_parts_t<Database, Parts...>::_result_methods_t
@@ -143,12 +143,13 @@ namespace sqlpp
   }
 
   template <typename Database, typename... Parts>
-  auto dynamic_custom_query(const Database&, Parts... parts) -> custom_query_t<Database, wrap_operand_t<Parts>...>
+  auto dynamic_custom_query(const Database& /*unused*/, Parts... parts)
+      -> custom_query_t<Database, wrap_operand_t<Parts>...>
   {
     static_assert(sizeof...(Parts) > 0, "custom query requires at least one query argument");
     static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
 
     return custom_query_t<Database, wrap_operand_t<Parts>...>(parts...);
   }
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types.h b/include/sqlpp11/data_types.h
index 92a9c9ae..c9776077 100644
--- a/include/sqlpp11/data_types.h
+++ b/include/sqlpp11/data_types.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DATA_TYPES_H
-#define SQLPP_DATA_TYPES_H
+#ifndef SQLPP11_DATA_TYPES_H
+#define SQLPP11_DATA_TYPES_H
 
 #include <sqlpp11/data_types/boolean.h>
 #include <sqlpp11/data_types/integral.h>
diff --git a/include/sqlpp11/data_types/boolean.h b/include/sqlpp11/data_types/boolean.h
index cd865481..67b5aa2e 100644
--- a/include/sqlpp11/data_types/boolean.h
+++ b/include/sqlpp11/data_types/boolean.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BOOLEAN_H
-#define SQLPP_BOOLEAN_H
+#ifndef SQLPP11_DATA_TYPES_BOOLEAN_H
+#define SQLPP11_DATA_TYPES_BOOLEAN_H
 
 #include <sqlpp11/data_types/boolean/data_type.h>
 #include <sqlpp11/data_types/boolean/operand.h>
diff --git a/include/sqlpp11/data_types/boolean/column_operators.h b/include/sqlpp11/data_types/boolean/column_operators.h
index 7ae416be..3175a676 100644
--- a/include/sqlpp11/data_types/boolean/column_operators.h
+++ b/include/sqlpp11/data_types/boolean/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BOOLEAN_COLUMN_OPERATORS_H
-#define SQLPP_BOOLEAN_COLUMN_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_BOOLEAN_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_BOOLEAN_COLUMN_OPERATORS_H
 
 #include <sqlpp11/data_types/column_operators.h>
 
@@ -37,5 +37,5 @@ namespace sqlpp
   struct column_operators<Column, boolean>
   {
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/boolean/data_type.h b/include/sqlpp11/data_types/boolean/data_type.h
index 7589d829..dc8929db 100644
--- a/include/sqlpp11/data_types/boolean/data_type.h
+++ b/include/sqlpp11/data_types/boolean/data_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BOOLEAN_DATA_TYPE_H
-#define SQLPP_BOOLEAN_DATA_TYPE_H
+#ifndef SQLPP11_DATA_TYPES_BOOLEAN_DATA_TYPE_H
+#define SQLPP11_DATA_TYPES_BOOLEAN_DATA_TYPE_H
 
 #include <sqlpp11/type_traits.h>
 
@@ -41,6 +41,6 @@ namespace sqlpp
   };
 
   using bit = sqlpp::boolean;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/boolean/expression_operators.h b/include/sqlpp11/data_types/boolean/expression_operators.h
index d9de12eb..246f56a0 100644
--- a/include/sqlpp11/data_types/boolean/expression_operators.h
+++ b/include/sqlpp11/data_types/boolean/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BOOLEAN_EXPRESSION_OPERATORS_H
-#define SQLPP_BOOLEAN_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_BOOLEAN_EXPRESSION_OPERATORS_H
+#define SQLPP11_DATA_TYPES_BOOLEAN_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/expression_return_types.h>
 #include <sqlpp11/operand_check.h>
@@ -59,6 +59,6 @@ namespace sqlpp
     using check = consistent_t;
     using type = logical_not_t<wrap_operand_t<T>>;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/boolean/operand.h b/include/sqlpp11/data_types/boolean/operand.h
index 68301c6b..b211dab3 100644
--- a/include/sqlpp11/data_types/boolean/operand.h
+++ b/include/sqlpp11/data_types/boolean/operand.h
@@ -24,8 +24,10 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BOOLEAN_OPERAND_H
-#define SQLPP_BOOLEAN_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_BOOLEAN_OPERAND_H
+#define SQLPP11_DATA_TYPES_BOOLEAN_OPERAND_H
+
+#include <ciso646>  // Required for some compilers to use aliases for boolean operators
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/alias_operators.h>
@@ -59,7 +61,7 @@ namespace sqlpp
 
     bool _is_trivial() const
     {
-      return _t == false;
+      return not _t;
     }
 
     _value_t _t;
@@ -77,6 +79,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/boolean/parameter_value.h b/include/sqlpp11/data_types/boolean/parameter_value.h
index 796ef207..ee6375d0 100644
--- a/include/sqlpp11/data_types/boolean/parameter_value.h
+++ b/include/sqlpp11/data_types/boolean/parameter_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BOOLEAN_PARAMETER_VALUE_H
-#define SQLPP_BOOLEAN_PARAMETER_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_BOOLEAN_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_BOOLEAN_PARAMETER_VALUE_H
 
 #include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/data_types/parameter_value_base.h>
@@ -47,6 +47,6 @@ namespace sqlpp
       target._bind_boolean_parameter(index, &_value, _is_null);
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/boolean/result_field.h b/include/sqlpp11/data_types/boolean/result_field.h
index 76544e29..a2c6db39 100644
--- a/include/sqlpp11/data_types/boolean/result_field.h
+++ b/include/sqlpp11/data_types/boolean/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BOOLEAN_RESULT_FIELD_H
-#define SQLPP_BOOLEAN_RESULT_FIELD_H
+#ifndef SQLPP11_DATA_TYPES_BOOLEAN_RESULT_FIELD_H
+#define SQLPP11_DATA_TYPES_BOOLEAN_RESULT_FIELD_H
 
 #include <sqlpp11/basic_expression_operators.h>
 #include <sqlpp11/result_field.h>
@@ -51,6 +51,6 @@ namespace sqlpp
       target._post_bind_boolean_result(index, &this->_value, &this->_is_null);
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/boolean/wrap_operand.h b/include/sqlpp11/data_types/boolean/wrap_operand.h
index ba0ec29e..3b66b452 100644
--- a/include/sqlpp11/data_types/boolean/wrap_operand.h
+++ b/include/sqlpp11/data_types/boolean/wrap_operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_BOOLEAN_WRAP_OPERAND_H
-#define SQLPP_BOOLEAN_WRAP_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_BOOLEAN_WRAP_OPERAND_H
+#define SQLPP11_DATA_TYPES_BOOLEAN_WRAP_OPERAND_H
 
 #include <sqlpp11/wrap_operand.h>
 
@@ -38,6 +38,6 @@ namespace sqlpp
   {
     using type = boolean_operand;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/column_operators.h b/include/sqlpp11/data_types/column_operators.h
index f57511ae..1273c465 100644
--- a/include/sqlpp11/data_types/column_operators.h
+++ b/include/sqlpp11/data_types/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_COLUMN_OPERATORS_H
-#define SQLPP_COLUMN_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_COLUMN_OPERATORS_H
 
 #include <sqlpp11/wrong.h>
 
@@ -36,6 +36,6 @@ namespace sqlpp
   {
     static_assert(wrong_t<column_operators>::value, "Missing column operators for ValueType");
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/day_point.h b/include/sqlpp11/data_types/day_point.h
index 5c43f96c..7818e2c6 100644
--- a/include/sqlpp11/data_types/day_point.h
+++ b/include/sqlpp11/data_types/day_point.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DAY_POINT_H
-#define SQLPP_DAY_POINT_H
+#ifndef SQLPP11_DATA_TYPES_DAY_POINT_H
+#define SQLPP11_DATA_TYPES_DAY_POINT_H
 
 #include <sqlpp11/data_types/day_point/data_type.h>
 #include <sqlpp11/data_types/day_point/operand.h>
diff --git a/include/sqlpp11/data_types/day_point/column_operators.h b/include/sqlpp11/data_types/day_point/column_operators.h
index 540264af..ea1fda0a 100644
--- a/include/sqlpp11/data_types/day_point/column_operators.h
+++ b/include/sqlpp11/data_types/day_point/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DAY_POINT_COLUMN_OPERATORS_H
-#define SQLPP_DAY_POINT_COLUMN_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_DAY_POINT_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_DAY_POINT_COLUMN_OPERATORS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/assignment.h>
@@ -40,5 +40,5 @@ namespace sqlpp
     template <typename T>
     using _is_valid_operand = is_valid_operand<day_point, T>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/day_point/data_type.h b/include/sqlpp11/data_types/day_point/data_type.h
index 9be108a0..0cddf09c 100644
--- a/include/sqlpp11/data_types/day_point/data_type.h
+++ b/include/sqlpp11/data_types/day_point/data_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DAY_POINT_DATA_TYPE_H
-#define SQLPP_DAY_POINT_DATA_TYPE_H
+#ifndef SQLPP11_DATA_TYPES_DAY_POINT_DATA_TYPE_H
+#define SQLPP11_DATA_TYPES_DAY_POINT_DATA_TYPE_H
 
 #include <sqlpp11/chrono.h>
 #include <sqlpp11/type_traits.h>
@@ -44,5 +44,5 @@ namespace sqlpp
   };
 
   using date = day_point;
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/day_point/expression_operators.h b/include/sqlpp11/data_types/day_point/expression_operators.h
index efe7adf7..2ff20718 100644
--- a/include/sqlpp11/data_types/day_point/expression_operators.h
+++ b/include/sqlpp11/data_types/day_point/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DAY_POINT_EXPRESSION_OPERATORS_H
-#define SQLPP_DAY_POINT_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_DAY_POINT_EXPRESSION_OPERATORS_H
+#define SQLPP11_DATA_TYPES_DAY_POINT_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/expression_operators.h>
 #include <sqlpp11/basic_expression_operators.h>
@@ -38,5 +38,5 @@ namespace sqlpp
   struct expression_operators<Expression, day_point> : public basic_expression_operators<Expression>
   {
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/day_point/operand.h b/include/sqlpp11/data_types/day_point/operand.h
index fc8599cb..cfcaf957 100644
--- a/include/sqlpp11/data_types/day_point/operand.h
+++ b/include/sqlpp11/data_types/day_point/operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DAY_POINT_OPERAND_H
-#define SQLPP_DAY_POINT_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_DAY_POINT_OPERAND_H
+#define SQLPP11_DATA_TYPES_DAY_POINT_OPERAND_H
 
 #include <date.h>
 #include <sqlpp11/chrono.h>
@@ -45,9 +45,7 @@ namespace sqlpp
 
     using _value_t = ::sqlpp::chrono::day_point;
 
-    day_point_operand() : _t{}
-    {
-    }
+    day_point_operand() = default;
 
     day_point_operand(_value_t t) : _t(t)
     {
@@ -80,5 +78,5 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/day_point/parameter_value.h b/include/sqlpp11/data_types/day_point/parameter_value.h
index 12738827..bb8b5387 100644
--- a/include/sqlpp11/data_types/day_point/parameter_value.h
+++ b/include/sqlpp11/data_types/day_point/parameter_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DAY_POINT_PARAMETER_VALUE_H
-#define SQLPP_DAY_POINT_PARAMETER_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_DAY_POINT_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_DAY_POINT_PARAMETER_VALUE_H
 
 #include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/data_types/parameter_value_base.h>
@@ -49,5 +49,5 @@ namespace sqlpp
       target._bind_date_parameter(index, &_value, _is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/day_point/result_field.h b/include/sqlpp11/data_types/day_point/result_field.h
index 23f572b0..520615ee 100644
--- a/include/sqlpp11/data_types/day_point/result_field.h
+++ b/include/sqlpp11/data_types/day_point/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DAY_POINT_RESULT_FIELD_H
-#define SQLPP_DAY_POINT_RESULT_FIELD_H
+#ifndef SQLPP11_DATA_TYPES_DAY_POINT_RESULT_FIELD_H
+#define SQLPP11_DATA_TYPES_DAY_POINT_RESULT_FIELD_H
 
 #include <sqlpp11/basic_expression_operators.h>
 #include <sqlpp11/result_field.h>
@@ -68,5 +68,5 @@ namespace sqlpp
     }
     return os;
   }
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/day_point/wrap_operand.h b/include/sqlpp11/data_types/day_point/wrap_operand.h
index a695cb24..7e4f61c4 100644
--- a/include/sqlpp11/data_types/day_point/wrap_operand.h
+++ b/include/sqlpp11/data_types/day_point/wrap_operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DAY_POINT_WRAP_OPERAND_H
-#define SQLPP_DAY_POINT_WRAP_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_DAY_POINT_WRAP_OPERAND_H
+#define SQLPP11_DATA_TYPES_DAY_POINT_WRAP_OPERAND_H
 
 #include <utility>
 #include <sqlpp11/type_traits.h>
@@ -41,5 +41,5 @@ namespace sqlpp
   {
     using type = day_point_operand;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/floating_point.h b/include/sqlpp11/data_types/floating_point.h
index ff9a6179..07ea8ae5 100644
--- a/include/sqlpp11/data_types/floating_point.h
+++ b/include/sqlpp11/data_types/floating_point.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FLOATING_POINT_H
-#define SQLPP_FLOATING_POINT_H
+#ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_H
+#define SQLPP11_DATA_TYPES_FLOATING_POINT_H
 
 #include <sqlpp11/data_types/floating_point/data_type.h>
 #include <sqlpp11/data_types/floating_point/operand.h>
diff --git a/include/sqlpp11/data_types/floating_point/column_operators.h b/include/sqlpp11/data_types/floating_point/column_operators.h
index 6daf5131..1949da6e 100644
--- a/include/sqlpp11/data_types/floating_point/column_operators.h
+++ b/include/sqlpp11/data_types/floating_point/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FLOATING_POINT_COLUMN_OPERATORS_H
-#define SQLPP_FLOATING_POINT_COLUMN_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_FLOATING_POINT_COLUMN_OPERATORS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/assignment.h>
@@ -76,5 +76,5 @@ namespace sqlpp
       return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/floating_point/data_type.h b/include/sqlpp11/data_types/floating_point/data_type.h
index 6c7e6a2f..daacd358 100644
--- a/include/sqlpp11/data_types/floating_point/data_type.h
+++ b/include/sqlpp11/data_types/floating_point/data_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FLOATING_POINT_DATA_TYPE_H
-#define SQLPP_FLOATING_POINT_DATA_TYPE_H
+#ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_DATA_TYPE_H
+#define SQLPP11_DATA_TYPES_FLOATING_POINT_DATA_TYPE_H
 
 #include <sqlpp11/type_traits.h>
 
@@ -39,5 +39,5 @@ namespace sqlpp
     template <typename T>
     using _is_valid_operand = is_numeric_t<T>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/floating_point/expression_operators.h b/include/sqlpp11/data_types/floating_point/expression_operators.h
index 371a9527..063cf6e3 100644
--- a/include/sqlpp11/data_types/floating_point/expression_operators.h
+++ b/include/sqlpp11/data_types/floating_point/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FLOATING_POINT_EXPRESSION_OPERATORS_H
-#define SQLPP_FLOATING_POINT_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_EXPRESSION_OPERATORS_H
+#define SQLPP11_DATA_TYPES_FLOATING_POINT_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/expression_return_types.h>
 #include <sqlpp11/operand_check.h>
@@ -82,5 +82,5 @@ namespace sqlpp
     using check = consistent_t;
     using type = unary_minus_t<floating_point, wrap_operand_t<T>>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/floating_point/operand.h b/include/sqlpp11/data_types/floating_point/operand.h
index ed53764c..5a375288 100644
--- a/include/sqlpp11/data_types/floating_point/operand.h
+++ b/include/sqlpp11/data_types/floating_point/operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FLOATING_POINT_OPERAND_H
-#define SQLPP_FLOATING_POINT_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_OPERAND_H
+#define SQLPP11_DATA_TYPES_FLOATING_POINT_OPERAND_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/alias_operators.h>
@@ -75,5 +75,5 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/floating_point/parameter_value.h b/include/sqlpp11/data_types/floating_point/parameter_value.h
index 88c2cd02..11df153f 100644
--- a/include/sqlpp11/data_types/floating_point/parameter_value.h
+++ b/include/sqlpp11/data_types/floating_point/parameter_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FLOATING_POINT_PARAMETER_VALUE_H
-#define SQLPP_FLOATING_POINT_PARAMETER_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_FLOATING_POINT_PARAMETER_VALUE_H
 
 #include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/data_types/parameter_value_base.h>
@@ -49,5 +49,5 @@ namespace sqlpp
       target._bind_floating_point_parameter(index, &_value, _is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/floating_point/result_field.h b/include/sqlpp11/data_types/floating_point/result_field.h
index a644b80b..2d298337 100644
--- a/include/sqlpp11/data_types/floating_point/result_field.h
+++ b/include/sqlpp11/data_types/floating_point/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FLOATING_POINT_RESULT_FIELD_H
-#define SQLPP_FLOATING_POINT_RESULT_FIELD_H
+#ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_RESULT_FIELD_H
+#define SQLPP11_DATA_TYPES_FLOATING_POINT_RESULT_FIELD_H
 
 #include <sqlpp11/exception.h>
 #include <sqlpp11/result_field.h>
@@ -52,5 +52,5 @@ namespace sqlpp
       target._post_bind_floating_point_result(index, &this->_value, &this->_is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/floating_point/wrap_operand.h b/include/sqlpp11/data_types/floating_point/wrap_operand.h
index 2c38b8ea..3d79b160 100644
--- a/include/sqlpp11/data_types/floating_point/wrap_operand.h
+++ b/include/sqlpp11/data_types/floating_point/wrap_operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FLOATING_POINT_WRAP_OPERAND_H
-#define SQLPP_FLOATING_POINT_WRAP_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_WRAP_OPERAND_H
+#define SQLPP11_DATA_TYPES_FLOATING_POINT_WRAP_OPERAND_H
 
 #include <utility>
 #include <sqlpp11/wrap_operand.h>
@@ -39,5 +39,5 @@ namespace sqlpp
   {
     using type = floating_point_operand;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/integral.h b/include/sqlpp11/data_types/integral.h
index 3b420ff2..848df2b0 100644
--- a/include/sqlpp11/data_types/integral.h
+++ b/include/sqlpp11/data_types/integral.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTEGRAL_H
-#define SQLPP_INTEGRAL_H
+#ifndef SQLPP11_DATA_TYPES_INTEGRAL_H
+#define SQLPP11_DATA_TYPES_INTEGRAL_H
 
 #include <sqlpp11/data_types/integral/data_type.h>
 #include <sqlpp11/data_types/integral/operand.h>
diff --git a/include/sqlpp11/data_types/integral/column_operators.h b/include/sqlpp11/data_types/integral/column_operators.h
index ee271fd7..75872df5 100644
--- a/include/sqlpp11/data_types/integral/column_operators.h
+++ b/include/sqlpp11/data_types/integral/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTEGRAL_COLUMN_OPERATORS_H
-#define SQLPP_INTEGRAL_COLUMN_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_INTEGRAL_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_INTEGRAL_COLUMN_OPERATORS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/assignment.h>
@@ -77,6 +77,6 @@ namespace sqlpp
       return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}};
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/integral/data_type.h b/include/sqlpp11/data_types/integral/data_type.h
index cc60e273..957f8428 100644
--- a/include/sqlpp11/data_types/integral/data_type.h
+++ b/include/sqlpp11/data_types/integral/data_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTEGRAL_DATA_TYPE_H
-#define SQLPP_INTEGRAL_DATA_TYPE_H
+#ifndef SQLPP11_DATA_TYPES_INTEGRAL_DATA_TYPE_H
+#define SQLPP11_DATA_TYPES_INTEGRAL_DATA_TYPE_H
 
 #include <sqlpp11/type_traits.h>
 
@@ -44,5 +44,5 @@ namespace sqlpp
   using smallint = integral;
   using integer = integral;
   using bigint = integral;
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/integral/expression_operators.h b/include/sqlpp11/data_types/integral/expression_operators.h
index 71e7a876..79006c2b 100644
--- a/include/sqlpp11/data_types/integral/expression_operators.h
+++ b/include/sqlpp11/data_types/integral/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTEGRAL_EXPRESSION_OPERATORS_H
-#define SQLPP_INTEGRAL_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_INTEGRAL_EXPRESSION_OPERATORS_H
+#define SQLPP11_DATA_TYPES_INTEGRAL_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/expression_return_types.h>
 #include <sqlpp11/operand_check.h>
@@ -132,5 +132,5 @@ namespace sqlpp
     using check = consistent_t;
     using type = bitwise_or_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/integral/operand.h b/include/sqlpp11/data_types/integral/operand.h
index 4625f06b..06a00e14 100644
--- a/include/sqlpp11/data_types/integral/operand.h
+++ b/include/sqlpp11/data_types/integral/operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTEGRAL_OPERAND_H
-#define SQLPP_INTEGRAL_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_INTEGRAL_OPERAND_H
+#define SQLPP11_DATA_TYPES_INTEGRAL_OPERAND_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/alias_operators.h>
@@ -77,6 +77,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/integral/parameter_value.h b/include/sqlpp11/data_types/integral/parameter_value.h
index 8c29b9fc..af98bb62 100644
--- a/include/sqlpp11/data_types/integral/parameter_value.h
+++ b/include/sqlpp11/data_types/integral/parameter_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTEGRAL_PARAMETER_VALUE_H
-#define SQLPP_INTEGRAL_PARAMETER_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_INTEGRAL_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_INTEGRAL_PARAMETER_VALUE_H
 
 #include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/data_types/parameter_value_base.h>
@@ -47,5 +47,5 @@ namespace sqlpp
       target._bind_integral_parameter(index, &_value, _is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/integral/result_field.h b/include/sqlpp11/data_types/integral/result_field.h
index d703bb55..aee172f9 100644
--- a/include/sqlpp11/data_types/integral/result_field.h
+++ b/include/sqlpp11/data_types/integral/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTEGRAL_RESULT_FIELD_H
-#define SQLPP_INTEGRAL_RESULT_FIELD_H
+#ifndef SQLPP11_DATA_TYPES_INTEGRAL_RESULT_FIELD_H
+#define SQLPP11_DATA_TYPES_INTEGRAL_RESULT_FIELD_H
 
 #include <sqlpp11/basic_expression_operators.h>
 #include <sqlpp11/result_field.h>
@@ -51,5 +51,5 @@ namespace sqlpp
       target._post_bind_integral_result(index, &this->_value, &this->_is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/integral/wrap_operand.h b/include/sqlpp11/data_types/integral/wrap_operand.h
index d6381b67..7be263e2 100644
--- a/include/sqlpp11/data_types/integral/wrap_operand.h
+++ b/include/sqlpp11/data_types/integral/wrap_operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTEGRAL_WRAP_OPERAND_H
-#define SQLPP_INTEGRAL_WRAP_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_INTEGRAL_WRAP_OPERAND_H
+#define SQLPP11_DATA_TYPES_INTEGRAL_WRAP_OPERAND_H
 
 #include <utility>
 #include <sqlpp11/wrap_operand.h>
@@ -35,9 +35,11 @@ namespace sqlpp
   struct integral_operand;
 
   template <typename T>
-  struct wrap_operand<T, typename std::enable_if<std::is_integral<T>::value and not std::is_same<bool, T>::value and not std::is_unsigned<T>::value>::type>
+  struct wrap_operand<T,
+                      typename std::enable_if<std::is_integral<T>::value and not std::is_same<bool, T>::value and
+                                              not std::is_unsigned<T>::value>::type>
   {
     using type = integral_operand;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/no_value.h b/include/sqlpp11/data_types/no_value.h
index 312cab93..55f454e0 100644
--- a/include/sqlpp11/data_types/no_value.h
+++ b/include/sqlpp11/data_types/no_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_VALUE_H
-#define SQLPP_NO_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_NO_VALUE_H
+#define SQLPP11_DATA_TYPES_NO_VALUE_H
 
 #include <sqlpp11/data_types/no_value/data_type.h>
 #include <sqlpp11/data_types/no_value/operand.h>
diff --git a/include/sqlpp11/data_types/no_value/column_operators.h b/include/sqlpp11/data_types/no_value/column_operators.h
index 3417f2ae..10cf4ff8 100644
--- a/include/sqlpp11/data_types/no_value/column_operators.h
+++ b/include/sqlpp11/data_types/no_value/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_VALUE_COLUMN_OPERATORS_H
-#define SQLPP_NO_VALUE_COLUMN_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_NO_VALUE_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_NO_VALUE_COLUMN_OPERATORS_H
 
 #include <sqlpp11/data_types/column_operators.h>
 
@@ -37,5 +37,5 @@ namespace sqlpp
   struct column_operators<Base, no_value_t>
   {
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/no_value/data_type.h b/include/sqlpp11/data_types/no_value/data_type.h
index df98a11f..8deb6bed 100644
--- a/include/sqlpp11/data_types/no_value/data_type.h
+++ b/include/sqlpp11/data_types/no_value/data_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_VALUE_DATA_TYPE_H
-#define SQLPP_NO_VALUE_DATA_TYPE_H
+#ifndef SQLPP11_DATA_TYPES_NO_VALUE_DATA_TYPE_H
+#define SQLPP11_DATA_TYPES_NO_VALUE_DATA_TYPE_H
 
 #include <sqlpp11/type_traits.h>
 
@@ -39,6 +39,6 @@ namespace sqlpp
     template <typename T>
     using _is_valid_operand = wrong_t<T>;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/no_value/expression_operators.h b/include/sqlpp11/data_types/no_value/expression_operators.h
index cd8f7175..ffd1552a 100644
--- a/include/sqlpp11/data_types/no_value/expression_operators.h
+++ b/include/sqlpp11/data_types/no_value/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_VALUE_EXPRESSION_OPERATORS_H
-#define SQLPP_NO_VALUE_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_NO_VALUE_EXPRESSION_OPERATORS_H
+#define SQLPP11_DATA_TYPES_NO_VALUE_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/expression_return_types.h>
 #include <sqlpp11/expression_operators.h>
@@ -37,6 +37,6 @@ namespace sqlpp
   struct expression_operators<Expression, no_value_t> : public basic_expression_operators<Expression>
   {
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/no_value/operand.h b/include/sqlpp11/data_types/no_value/operand.h
index cbda37f3..625e40d8 100644
--- a/include/sqlpp11/data_types/no_value/operand.h
+++ b/include/sqlpp11/data_types/no_value/operand.h
@@ -24,12 +24,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_VALUE_OPERAND_H
-#define SQLPP_NO_VALUE_OPERAND_H
-
-namespace sqlpp
-{
-  // There is no no_value operand
-}
+#ifndef SQLPP11_DATA_TYPES_NO_VALUE_OPERAND_H
+#define SQLPP11_DATA_TYPES_NO_VALUE_OPERAND_H
 
 #endif
diff --git a/include/sqlpp11/data_types/no_value/parameter_value.h b/include/sqlpp11/data_types/no_value/parameter_value.h
index 0a822237..8c8f9916 100644
--- a/include/sqlpp11/data_types/no_value/parameter_value.h
+++ b/include/sqlpp11/data_types/no_value/parameter_value.h
@@ -24,12 +24,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_VALUE_PARAMETER_VALUE_H
-#define SQLPP_NO_VALUE_PARAMETER_VALUE_H
-
-namespace sqlpp
-{
-  // There is no no_value parameter
-}
+#ifndef SQLPP11_DATA_TYPES_NO_VALUE_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_NO_VALUE_PARAMETER_VALUE_H
 
 #endif
diff --git a/include/sqlpp11/data_types/no_value/result_field.h b/include/sqlpp11/data_types/no_value/result_field.h
index 647b6c0a..1aa55222 100644
--- a/include/sqlpp11/data_types/no_value/result_field.h
+++ b/include/sqlpp11/data_types/no_value/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_VALUE_RESULT_FIELD_H
-#define SQLPP_NO_VALUE_RESULT_FIELD_H
+#ifndef SQLPP11_DATA_TYPES_NO_VALUE_RESULT_FIELD_H
+#define SQLPP11_DATA_TYPES_NO_VALUE_RESULT_FIELD_H
 
 #include <sqlpp11/result_field.h>
 #include <sqlpp11/data_types/no_value/data_type.h>
@@ -37,12 +37,12 @@ namespace sqlpp
   struct result_field_t<Db, field_spec_t<NameType, no_value_t, CanBeNull, NullIsTrivialValue>>
   {
     template <typename Target>
-    void _bind(Target&, size_t)
+    void _bind(Target& /*unused*/, size_t /*unused*/)
     {
     }
 
     template <typename Target>
-    void _post_bind(Target&, size_t)
+    void _post_bind(Target& /*unused*/, size_t /*unused*/)
     {
     }
 
@@ -62,11 +62,12 @@ namespace sqlpp
 
   template <typename Db, typename NameType, bool CanBeNull, bool NullIsTrivialValue>
   inline std::ostream& operator<<(
-      std::ostream& os, const result_field_t<Db, field_spec_t<NameType, no_value_t, CanBeNull, NullIsTrivialValue>>&)
+      std::ostream& os,
+      const result_field_t<Db, field_spec_t<NameType, no_value_t, CanBeNull, NullIsTrivialValue>>& /*unused*/)
   {
     os << "NULL";
     return os;
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/no_value/wrap_operand.h b/include/sqlpp11/data_types/no_value/wrap_operand.h
index 545eb09c..3814d04e 100644
--- a/include/sqlpp11/data_types/no_value/wrap_operand.h
+++ b/include/sqlpp11/data_types/no_value/wrap_operand.h
@@ -24,12 +24,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_VALUE_WRAP_OPERAND_H
-#define SQLPP_NO_VALUE_WRAP_OPERAND_H
-
-namespace sqlpp
-{
-  // There is no no_value operand
-}
+#ifndef SQLPP11_DATA_TYPES_NO_VALUE_WRAP_OPERAND_H
+#define SQLPP11_DATA_TYPES_NO_VALUE_WRAP_OPERAND_H
 
 #endif
diff --git a/include/sqlpp11/data_types/parameter_value.h b/include/sqlpp11/data_types/parameter_value.h
index 1fbcc5a7..c5841f75 100644
--- a/include/sqlpp11/data_types/parameter_value.h
+++ b/include/sqlpp11/data_types/parameter_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PARAMETER_VALUE_H
-#define SQLPP_PARAMETER_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_PARAMETER_VALUE_H
 
 #include <sqlpp11/wrong.h>
 
@@ -36,6 +36,6 @@ namespace sqlpp
   {
     static_assert(wrong_t<parameter_value_t>::value, "Missing parameter value type for ValueType");
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/parameter_value_base.h b/include/sqlpp11/data_types/parameter_value_base.h
index 491666d4..b75f78ca 100644
--- a/include/sqlpp11/data_types/parameter_value_base.h
+++ b/include/sqlpp11/data_types/parameter_value_base.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PARAMETER_VALUE_BASE_H
-#define SQLPP_PARAMETER_VALUE_BASE_H
+#ifndef SQLPP11_DATA_TYPES_PARAMETER_VALUE_BASE_H
+#define SQLPP11_DATA_TYPES_PARAMETER_VALUE_BASE_H
 
 #include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/tvin.h>
@@ -94,5 +94,5 @@ namespace sqlpp
     _cpp_storage_type _value;
     bool _is_null;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/text.h b/include/sqlpp11/data_types/text.h
index 2c9327c7..1d3d0df6 100644
--- a/include/sqlpp11/data_types/text.h
+++ b/include/sqlpp11/data_types/text.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TEXT_H
-#define SQLPP_TEXT_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_H
+#define SQLPP11_DATA_TYPES_TEXT_H
 
 #include <sqlpp11/data_types/text/data_type.h>
 #include <sqlpp11/data_types/text/operand.h>
diff --git a/include/sqlpp11/data_types/text/column_operators.h b/include/sqlpp11/data_types/text/column_operators.h
index fdafacb3..8e1f7650 100644
--- a/include/sqlpp11/data_types/text/column_operators.h
+++ b/include/sqlpp11/data_types/text/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TEXT_COLUMN_OPERATORS_H
-#define SQLPP_TEXT_COLUMN_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_TEXT_COLUMN_OPERATORS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/assignment.h>
@@ -53,5 +53,5 @@ namespace sqlpp
               concat_t<Column, wrap_operand_t<T>>{*static_cast<const Column*>(this), rhs{t}}};
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/text/concat.h b/include/sqlpp11/data_types/text/concat.h
index 25164882..6102cc24 100644
--- a/include/sqlpp11/data_types/text/concat.h
+++ b/include/sqlpp11/data_types/text/concat.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_CONCAT_H
-#define SQLPP_CONCAT_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_CONCAT_H
+#define SQLPP11_DATA_TYPES_TEXT_CONCAT_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/char_sequence.h>
@@ -98,6 +98,6 @@ namespace sqlpp
 
     return {args...};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/text/data_type.h b/include/sqlpp11/data_types/text/data_type.h
index 6215dacb..d3ed84eb 100644
--- a/include/sqlpp11/data_types/text/data_type.h
+++ b/include/sqlpp11/data_types/text/data_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TEXT_DATA_TYPE_H
-#define SQLPP_TEXT_DATA_TYPE_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_DATA_TYPE_H
+#define SQLPP11_DATA_TYPES_TEXT_DATA_TYPE_H
 
 #include <sqlpp11/type_traits.h>
 
@@ -45,5 +45,5 @@ namespace sqlpp
   using char_ = text;
   using binary = text;
   using varbinary = text;
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/text/expression_operators.h b/include/sqlpp11/data_types/text/expression_operators.h
index 065b6965..6802a795 100644
--- a/include/sqlpp11/data_types/text/expression_operators.h
+++ b/include/sqlpp11/data_types/text/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TEXT_EXPRESSION_OPERATORS_H
-#define SQLPP_TEXT_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_EXPRESSION_OPERATORS_H
+#define SQLPP11_DATA_TYPES_TEXT_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/expression_operators.h>
 #include <sqlpp11/basic_expression_operators.h>
@@ -76,5 +76,5 @@ namespace sqlpp
     using check = consistent_t;
     using type = concat_t<wrap_operand_t<L>, wrap_operand_t<R>>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/text/like.h b/include/sqlpp11/data_types/text/like.h
index 9eae60b6..288e4cdb 100644
--- a/include/sqlpp11/data_types/text/like.h
+++ b/include/sqlpp11/data_types/text/like.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_LIKE_H
-#define SQLPP_LIKE_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_LIKE_H
+#define SQLPP11_DATA_TYPES_TEXT_LIKE_H
 
 #include <sqlpp11/expression_operators.h>
 #include <sqlpp11/alias_operators.h>
@@ -93,6 +93,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/text/operand.h b/include/sqlpp11/data_types/text/operand.h
index d67a938e..fc2fda1c 100644
--- a/include/sqlpp11/data_types/text/operand.h
+++ b/include/sqlpp11/data_types/text/operand.h
@@ -24,10 +24,11 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TEXT_OPERAND_H
-#define SQLPP_TEXT_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_OPERAND_H
+#define SQLPP11_DATA_TYPES_TEXT_OPERAND_H
 
 #include <string>
+#include <utility>
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/alias_operators.h>
 #include <sqlpp11/serializer.h>
@@ -44,11 +45,9 @@ namespace sqlpp
 
     using _value_t = std::string;
 
-    text_operand() : _t{}
-    {
-    }
+    text_operand() = default;
 
-    text_operand(_value_t t) : _t(t)
+    text_operand(_value_t t) : _t(std::move(t))
     {
     }
 
@@ -78,5 +77,5 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/text/parameter_value.h b/include/sqlpp11/data_types/text/parameter_value.h
index 10d69d06..cf7bbf07 100644
--- a/include/sqlpp11/data_types/text/parameter_value.h
+++ b/include/sqlpp11/data_types/text/parameter_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TEXT_PARAMETER_VALUE_H
-#define SQLPP_TEXT_PARAMETER_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_TEXT_PARAMETER_VALUE_H
 
 #include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/data_types/parameter_value_base.h>
@@ -49,5 +49,5 @@ namespace sqlpp
       target._bind_text_parameter(index, &_value, _is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/text/result_field.h b/include/sqlpp11/data_types/text/result_field.h
index a4d6f97c..6d82cf51 100644
--- a/include/sqlpp11/data_types/text/result_field.h
+++ b/include/sqlpp11/data_types/text/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TEXT_RESULT_FIELD_H
-#define SQLPP_TEXT_RESULT_FIELD_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_RESULT_FIELD_H
+#define SQLPP11_DATA_TYPES_TEXT_RESULT_FIELD_H
 
 #include <sqlpp11/basic_expression_operators.h>
 #include <sqlpp11/result_field.h>
@@ -48,9 +48,13 @@ namespace sqlpp
     {
       target._bind_text_result(index, &text, &len);
       if (text)
+      {
         this->_value.assign(text, len);
+      }
       else
+      {
         this->_value.assign("");
+      }
       this->_is_null = (text == nullptr);
     }
 
@@ -59,9 +63,13 @@ namespace sqlpp
     {
       target._post_bind_text_result(index, &text, &len);
       if (text)
+      {
         this->_value.assign(text, len);
+      }
       else
+      {
         this->_value.assign("");
+      }
       this->_is_null = (text == nullptr);
     }
   };
@@ -74,10 +82,8 @@ namespace sqlpp
     {
       return os << "NULL";
     }
-    else
-    {
-      return os << e.value();
-    }
+
+    return os << e.value();
   }
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/text/wrap_operand.h b/include/sqlpp11/data_types/text/wrap_operand.h
index f80e26d8..c2318e43 100644
--- a/include/sqlpp11/data_types/text/wrap_operand.h
+++ b/include/sqlpp11/data_types/text/wrap_operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TEXT_WRAP_OPERAND_H
-#define SQLPP_TEXT_WRAP_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_TEXT_WRAP_OPERAND_H
+#define SQLPP11_DATA_TYPES_TEXT_WRAP_OPERAND_H
 
 #include <utility>
 #include <sqlpp11/type_traits.h>
@@ -42,5 +42,5 @@ namespace sqlpp
   {
     using type = text_operand;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_of_day.h b/include/sqlpp11/data_types/time_of_day.h
index 5eb1a630..62d7d2cd 100644
--- a/include/sqlpp11/data_types/time_of_day.h
+++ b/include/sqlpp11/data_types/time_of_day.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_OF_DAY_H
-#define SQLPP_TIME_OF_DAY_H
+#ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_H
+#define SQLPP11_DATA_TYPES_TIME_OF_DAY_H
 
 #include <sqlpp11/data_types/time_of_day/data_type.h>
 #include <sqlpp11/data_types/time_of_day/operand.h>
diff --git a/include/sqlpp11/data_types/time_of_day/column_operators.h b/include/sqlpp11/data_types/time_of_day/column_operators.h
index cbe989a8..f0e9f023 100644
--- a/include/sqlpp11/data_types/time_of_day/column_operators.h
+++ b/include/sqlpp11/data_types/time_of_day/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_OF_DAY_COLUMN_OPERATOR_H
-#define SQLPP_TIME_OF_DAY_COLUMN_OPERATOR_H
+#ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_TIME_OF_DAY_COLUMN_OPERATORS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/assignment.h>
@@ -40,5 +40,5 @@ namespace sqlpp
     template <typename T>
     using _is_valid_operand = is_valid_operand<time_of_day, T>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_of_day/data_type.h b/include/sqlpp11/data_types/time_of_day/data_type.h
index d58dcc10..96881446 100644
--- a/include/sqlpp11/data_types/time_of_day/data_type.h
+++ b/include/sqlpp11/data_types/time_of_day/data_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_OF_DAY_DATA_TYPE_H
-#define SQLPP_TIME_OF_DAY_DATA_TYPE_H
+#ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_DATA_TYPE_H
+#define SQLPP11_DATA_TYPES_TIME_OF_DAY_DATA_TYPE_H
 
 #include <sqlpp11/chrono.h>
 #include <sqlpp11/type_traits.h>
@@ -40,5 +40,5 @@ namespace sqlpp
     template <typename T>
     using _is_valid_operand = is_time_of_day_t<T>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_of_day/expression_operators.h b/include/sqlpp11/data_types/time_of_day/expression_operators.h
index 1c75de8f..388ae1d8 100644
--- a/include/sqlpp11/data_types/time_of_day/expression_operators.h
+++ b/include/sqlpp11/data_types/time_of_day/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_OF_DAY_EXPRESSION_OPERATORS_H
-#define SQLPP_TIME_OF_DAY_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_EXPRESSION_OPERATORS_H
+#define SQLPP11_DATA_TYPES_TIME_OF_DAY_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/expression_operators.h>
 #include <sqlpp11/basic_expression_operators.h>
@@ -39,5 +39,5 @@ namespace sqlpp
   struct expression_operators<Expression, time_of_day> : public basic_expression_operators<Expression>
   {
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_of_day/operand.h b/include/sqlpp11/data_types/time_of_day/operand.h
index bcac1e49..b628b95c 100644
--- a/include/sqlpp11/data_types/time_of_day/operand.h
+++ b/include/sqlpp11/data_types/time_of_day/operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_OF_DAY_OPERAND_H
-#define SQLPP_TIME_OF_DAY_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_OPERAND_H
+#define SQLPP11_DATA_TYPES_TIME_OF_DAY_OPERAND_H
 
 #include <sqlpp11/chrono.h>
 #include <sqlpp11/type_traits.h>
@@ -79,5 +79,5 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_of_day/parameter_value.h b/include/sqlpp11/data_types/time_of_day/parameter_value.h
index 79075b34..e062c32f 100644
--- a/include/sqlpp11/data_types/time_of_day/parameter_value.h
+++ b/include/sqlpp11/data_types/time_of_day/parameter_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_OF_DAY_PARAMETER_VALUE_H
-#define SQLPP_TIME_OF_DAY_PARAMETER_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_TIME_OF_DAY_PARAMETER_VALUE_H
 
 #include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/data_types/parameter_value_base.h>
@@ -49,5 +49,5 @@ namespace sqlpp
       target._bind_time_of_day_parameter(index, &_value, _is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_of_day/result_field.h b/include/sqlpp11/data_types/time_of_day/result_field.h
index 511fe8d6..17e6bfd8 100644
--- a/include/sqlpp11/data_types/time_of_day/result_field.h
+++ b/include/sqlpp11/data_types/time_of_day/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_OF_DAY_RESULT_FIELD_H
-#define SQLPP_TIME_OF_DAY_RESULT_FIELD_H
+#ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_RESULT_FIELD_H
+#define SQLPP11_DATA_TYPES_TIME_OF_DAY_RESULT_FIELD_H
 
 #include <sqlpp11/chrono.h>
 #include <sqlpp11/basic_expression_operators.h>
@@ -68,5 +68,5 @@ namespace sqlpp
     }
     return os;
   }
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_of_day/wrap_operand.h b/include/sqlpp11/data_types/time_of_day/wrap_operand.h
index ba53fe5c..b4faf20c 100644
--- a/include/sqlpp11/data_types/time_of_day/wrap_operand.h
+++ b/include/sqlpp11/data_types/time_of_day/wrap_operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_OF_DAY_WRAP_OPERAND_H
-#define SQLPP_TIME_OF_DAY_WRAP_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_WRAP_OPERAND_H
+#define SQLPP11_DATA_TYPES_TIME_OF_DAY_WRAP_OPERAND_H
 
 #include <sqlpp11/wrap_operand.h>
 #include <sqlpp11/data_types/time_of_day/operand.h>
@@ -37,5 +37,5 @@ namespace sqlpp
   {
     using type = time_of_day_operand<std::chrono::duration<Rep, Period>>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_point.h b/include/sqlpp11/data_types/time_point.h
index 83e481b7..85332cd0 100644
--- a/include/sqlpp11/data_types/time_point.h
+++ b/include/sqlpp11/data_types/time_point.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_POINT_H
-#define SQLPP_TIME_POINT_H
+#ifndef SQLPP11_DATA_TYPES_TIME_POINT_H
+#define SQLPP11_DATA_TYPES_TIME_POINT_H
 
 #include <sqlpp11/data_types/time_point/data_type.h>
 #include <sqlpp11/data_types/time_point/operand.h>
diff --git a/include/sqlpp11/data_types/time_point/column_operators.h b/include/sqlpp11/data_types/time_point/column_operators.h
index c59d7869..96896a30 100644
--- a/include/sqlpp11/data_types/time_point/column_operators.h
+++ b/include/sqlpp11/data_types/time_point/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_POINT_COLUMN_OPERATOR_H
-#define SQLPP_TIME_POINT_COLUMN_OPERATOR_H
+#ifndef SQLPP11_DATA_TYPES_TIME_POINT_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_TIME_POINT_COLUMN_OPERATORS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/assignment.h>
@@ -40,5 +40,5 @@ namespace sqlpp
     template <typename T>
     using _is_valid_operand = is_valid_operand<time_point, T>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_point/data_type.h b/include/sqlpp11/data_types/time_point/data_type.h
index ad3f727e..6021b222 100644
--- a/include/sqlpp11/data_types/time_point/data_type.h
+++ b/include/sqlpp11/data_types/time_point/data_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_POINT_DATA_TYPE_H
-#define SQLPP_TIME_POINT_DATA_TYPE_H
+#ifndef SQLPP11_DATA_TYPES_TIME_POINT_DATA_TYPE_H
+#define SQLPP11_DATA_TYPES_TIME_POINT_DATA_TYPE_H
 
 #include <sqlpp11/chrono.h>
 #include <sqlpp11/type_traits.h>
@@ -40,5 +40,5 @@ namespace sqlpp
     template <typename T>
     using _is_valid_operand = is_day_or_time_point_t<T>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_point/expression_operators.h b/include/sqlpp11/data_types/time_point/expression_operators.h
index 743ec5af..5e4c0b4a 100644
--- a/include/sqlpp11/data_types/time_point/expression_operators.h
+++ b/include/sqlpp11/data_types/time_point/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_POINT_EXPRESSION_OPERATORS_H
-#define SQLPP_TIME_POINT_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_TIME_POINT_EXPRESSION_OPERATORS_H
+#define SQLPP11_DATA_TYPES_TIME_POINT_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/expression_operators.h>
 #include <sqlpp11/basic_expression_operators.h>
@@ -39,5 +39,5 @@ namespace sqlpp
   struct expression_operators<Expression, time_point> : public basic_expression_operators<Expression>
   {
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_point/operand.h b/include/sqlpp11/data_types/time_point/operand.h
index eb82f545..d3053acd 100644
--- a/include/sqlpp11/data_types/time_point/operand.h
+++ b/include/sqlpp11/data_types/time_point/operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_POINT_OPERAND_H
-#define SQLPP_TIME_POINT_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_TIME_POINT_OPERAND_H
+#define SQLPP11_DATA_TYPES_TIME_POINT_OPERAND_H
 
 #include <sqlpp11/chrono.h>
 #include <sqlpp11/type_traits.h>
@@ -82,5 +82,5 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_point/parameter_value.h b/include/sqlpp11/data_types/time_point/parameter_value.h
index 276c6942..a05b0cf6 100644
--- a/include/sqlpp11/data_types/time_point/parameter_value.h
+++ b/include/sqlpp11/data_types/time_point/parameter_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_POINT_PARAMETER_VALUE_H
-#define SQLPP_TIME_POINT_PARAMETER_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_TIME_POINT_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_TIME_POINT_PARAMETER_VALUE_H
 
 #include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/data_types/parameter_value_base.h>
@@ -49,5 +49,5 @@ namespace sqlpp
       target._bind_date_time_parameter(index, &_value, _is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_point/result_field.h b/include/sqlpp11/data_types/time_point/result_field.h
index 4310de86..2b6c4031 100644
--- a/include/sqlpp11/data_types/time_point/result_field.h
+++ b/include/sqlpp11/data_types/time_point/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_POINT_RESULT_FIELD_H
-#define SQLPP_TIME_POINT_RESULT_FIELD_H
+#ifndef SQLPP11_DATA_TYPES_TIME_POINT_RESULT_FIELD_H
+#define SQLPP11_DATA_TYPES_TIME_POINT_RESULT_FIELD_H
 
 #include <sqlpp11/chrono.h>
 #include <sqlpp11/basic_expression_operators.h>
@@ -71,5 +71,5 @@ namespace sqlpp
     }
     return os;
   }
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/time_point/wrap_operand.h b/include/sqlpp11/data_types/time_point/wrap_operand.h
index 0e52d46c..7420870c 100644
--- a/include/sqlpp11/data_types/time_point/wrap_operand.h
+++ b/include/sqlpp11/data_types/time_point/wrap_operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TIME_POINT_WRAP_OPERAND_H
-#define SQLPP_TIME_POINT_WRAP_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_TIME_POINT_WRAP_OPERAND_H
+#define SQLPP11_DATA_TYPES_TIME_POINT_WRAP_OPERAND_H
 
 #include <sqlpp11/wrap_operand.h>
 #include <sqlpp11/data_types/time_point/operand.h>
@@ -37,5 +37,5 @@ namespace sqlpp
   {
     using type = time_point_operand<Period>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/unsigned_integral.h b/include/sqlpp11/data_types/unsigned_integral.h
index b37cdbaa..35ebddd9 100644
--- a/include/sqlpp11/data_types/unsigned_integral.h
+++ b/include/sqlpp11/data_types/unsigned_integral.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNSIGNED_INTEGRAL_H
-#define SQLPP_UNSIGNED_INTEGRAL_H
+#ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_H
+#define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_H
 
 #include <sqlpp11/data_types/unsigned_integral/data_type.h>
 #include <sqlpp11/data_types/unsigned_integral/operand.h>
diff --git a/include/sqlpp11/data_types/unsigned_integral/column_operators.h b/include/sqlpp11/data_types/unsigned_integral/column_operators.h
index ea98038b..ec714121 100644
--- a/include/sqlpp11/data_types/unsigned_integral/column_operators.h
+++ b/include/sqlpp11/data_types/unsigned_integral/column_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNSIGNED_INTEGRAL_COLUMN_OPERATORS_H
-#define SQLPP_UNSIGNED_INTEGRAL_COLUMN_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_COLUMN_OPERATORS_H
+#define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_COLUMN_OPERATORS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/assignment.h>
@@ -77,6 +77,6 @@ namespace sqlpp
       return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}};
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/unsigned_integral/data_type.h b/include/sqlpp11/data_types/unsigned_integral/data_type.h
index 9a4d4269..84014b4d 100644
--- a/include/sqlpp11/data_types/unsigned_integral/data_type.h
+++ b/include/sqlpp11/data_types/unsigned_integral/data_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNSIGNED_INTEGRAL_DATA_TYPE_H
-#define SQLPP_UNSIGNED_INTEGRAL_DATA_TYPE_H
+#ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_DATA_TYPE_H
+#define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_DATA_TYPE_H
 
 #include <sqlpp11/type_traits.h>
 
@@ -44,5 +44,5 @@ namespace sqlpp
   using smallint_unsigned = unsigned_integral;
   using integer_unsigned = unsigned_integral;
   using bigint_unsigned = unsigned_integral;
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/unsigned_integral/expression_operators.h b/include/sqlpp11/data_types/unsigned_integral/expression_operators.h
index bb5730b7..b72ce3cb 100644
--- a/include/sqlpp11/data_types/unsigned_integral/expression_operators.h
+++ b/include/sqlpp11/data_types/unsigned_integral/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNSIGNED_INTEGRAL_EXPRESSION_OPERATORS_H
-#define SQLPP_UNSIGNED_INTEGRAL_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_EXPRESSION_OPERATORS_H
+#define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/expression_return_types.h>
 #include <sqlpp11/operand_check.h>
@@ -113,5 +113,5 @@ namespace sqlpp
     using check = consistent_t;
     using type = bitwise_or_t<wrap_operand_t<L>, unsigned_integral, wrap_operand_t<R>>;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/unsigned_integral/operand.h b/include/sqlpp11/data_types/unsigned_integral/operand.h
index 2fa70619..7c6037e7 100644
--- a/include/sqlpp11/data_types/unsigned_integral/operand.h
+++ b/include/sqlpp11/data_types/unsigned_integral/operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNSIGNED_INTEGRAL_OPERAND_H
-#define SQLPP_UNSIGNED_INTEGRAL_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_OPERAND_H
+#define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_OPERAND_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/alias_operators.h>
@@ -77,6 +77,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/data_types/unsigned_integral/parameter_value.h b/include/sqlpp11/data_types/unsigned_integral/parameter_value.h
index c7ed7548..64e0b81d 100644
--- a/include/sqlpp11/data_types/unsigned_integral/parameter_value.h
+++ b/include/sqlpp11/data_types/unsigned_integral/parameter_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNSIGNED_INTEGRAL_PARAMETER_VALUE_H
-#define SQLPP_UNSIGNED_INTEGRAL_PARAMETER_VALUE_H
+#ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_PARAMETER_VALUE_H
+#define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_PARAMETER_VALUE_H
 
 #include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/data_types/parameter_value_base.h>
@@ -47,5 +47,5 @@ namespace sqlpp
       target._bind_unsigned_integral_parameter(index, &_value, _is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/unsigned_integral/result_field.h b/include/sqlpp11/data_types/unsigned_integral/result_field.h
index 1a54eaa9..19f68037 100644
--- a/include/sqlpp11/data_types/unsigned_integral/result_field.h
+++ b/include/sqlpp11/data_types/unsigned_integral/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNSIGNED_INTEGRAL_RESULT_FIELD_H
-#define SQLPP_UNSIGNED_INTEGRAL_RESULT_FIELD_H
+#ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_RESULT_FIELD_H
+#define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_RESULT_FIELD_H
 
 #include <sqlpp11/basic_expression_operators.h>
 #include <sqlpp11/result_field.h>
@@ -51,5 +51,5 @@ namespace sqlpp
       target._post_bind_unsigned_integral_result(index, &this->_value, &this->_is_null);
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/data_types/unsigned_integral/wrap_operand.h b/include/sqlpp11/data_types/unsigned_integral/wrap_operand.h
index 501d4a55..1e9dd7cb 100644
--- a/include/sqlpp11/data_types/unsigned_integral/wrap_operand.h
+++ b/include/sqlpp11/data_types/unsigned_integral/wrap_operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNSIGNED_INTEGRAL_WRAP_OPERAND_H
-#define SQLPP_UNSIGNED_INTEGRAL_WRAP_OPERAND_H
+#ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_WRAP_OPERAND_H
+#define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_WRAP_OPERAND_H
 
 #include <utility>
 #include <sqlpp11/wrap_operand.h>
@@ -35,9 +35,11 @@ namespace sqlpp
   struct unsigned_integral_operand;
 
   template <typename T>
-  struct wrap_operand<T, typename std::enable_if<std::is_integral<T>::value and not std::is_same<bool, T>::value and std::is_unsigned<T>::value>::type>
+  struct wrap_operand<T,
+                      typename std::enable_if<std::is_integral<T>::value and not std::is_same<bool, T>::value and
+                                              std::is_unsigned<T>::value>::type>
   {
     using type = unsigned_integral_operand;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/default_value.h b/include/sqlpp11/default_value.h
index 83d9dc00..a3fe714b 100644
--- a/include/sqlpp11/default_value.h
+++ b/include/sqlpp11/default_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DEFAULT_VALUE_H
-#define SQLPP_DEFAULT_VALUE_H
+#ifndef SQLPP11_DEFAULT_VALUE_H
+#define SQLPP11_DEFAULT_VALUE_H
 
 #include <sqlpp11/data_types/no_value.h>
 
@@ -48,7 +48,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using Operand = default_value_t;
 
-    static Context& _(const Operand&, Context& context)
+    static Context& _(const Operand& /*unused*/, Context& context)
     {
       context << "DEFAULT";
       return context;
@@ -56,6 +56,6 @@ namespace sqlpp
   };
 
   constexpr default_value_t default_value = {};
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/copy_tuple_args.h b/include/sqlpp11/detail/copy_tuple_args.h
index 9126ebbc..5b94c2cb 100644
--- a/include/sqlpp11/detail/copy_tuple_args.h
+++ b/include/sqlpp11/detail/copy_tuple_args.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_COPY_TUPLE_ARGS_H
-#define SQLPP_DETAIL_COPY_TUPLE_ARGS_H
+#ifndef SQLPP11_DETAIL_COPY_TUPLE_ARGS_H
+#define SQLPP11_DETAIL_COPY_TUPLE_ARGS_H
 
 #include <tuple>
 #include <sqlpp11/auto_alias.h>
@@ -49,7 +49,7 @@ namespace sqlpp
     template <typename T>
     struct as_column_tuple<all_of_t<T>>
     {
-      static typename all_of_t<T>::_column_tuple_t _(all_of_t<T>)
+      static typename all_of_t<T>::_column_tuple_t _(all_of_t<T> /*unused*/)
       {
         return {};
       }
@@ -84,7 +84,7 @@ namespace sqlpp
     {
       return std::tuple_cat(as_column_tuple<Columns>::_(columns)...);
     }
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/enable_if.h b/include/sqlpp11/detail/enable_if.h
index 4f4cead7..c2c882b6 100644
--- a/include/sqlpp11/detail/enable_if.h
+++ b/include/sqlpp11/detail/enable_if.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_ENABLE_IF_H
-#define SQLPP_DETAIL_ENABLE_IF_H
+#ifndef SQLPP11_DETAIL_ENABLE_IF_H
+#define SQLPP11_DETAIL_ENABLE_IF_H
 
 #include <utility>
 
@@ -35,7 +35,7 @@ namespace sqlpp
   {
     template <bool B, typename T = void>
     using enable_if_t = typename std::enable_if<B, T>::type;
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/field_index_sequence.h b/include/sqlpp11/detail/field_index_sequence.h
index b932ed5c..22e2abc0 100644
--- a/include/sqlpp11/detail/field_index_sequence.h
+++ b/include/sqlpp11/detail/field_index_sequence.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_FIELD_INDEX_SEQUENCE_H
-#define SQLPP_DETAIL_FIELD_INDEX_SEQUENCE_H
+#ifndef SQLPP11_DETAIL_FIELD_INDEX_SEQUENCE_H
+#define SQLPP11_DETAIL_FIELD_INDEX_SEQUENCE_H
 
 #include <type_traits>
 #include <sqlpp11/field_spec.h>
@@ -80,7 +80,7 @@ namespace sqlpp
     template <std::size_t StartIndex, typename... Fields>
     using make_field_index_sequence =
         typename make_field_index_sequence_impl<field_index_sequence<StartIndex>, Fields...>::type;
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/get_first.h b/include/sqlpp11/detail/get_first.h
index 927fde9f..85466f0e 100644
--- a/include/sqlpp11/detail/get_first.h
+++ b/include/sqlpp11/detail/get_first.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_GET_FIRST_H
-#define SQLPP_DETAIL_GET_FIRST_H
+#ifndef SQLPP11_DETAIL_GET_FIRST_H
+#define SQLPP11_DETAIL_GET_FIRST_H
 
 #include <type_traits>
 
@@ -51,7 +51,7 @@ namespace sqlpp
 
     template <template <typename> class Predicate, typename Default, typename... T>
     using get_first_if = typename get_first_if_impl<Predicate, Default, T...>::type;
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/get_last.h b/include/sqlpp11/detail/get_last.h
index 04cb16ce..3d64f97c 100644
--- a/include/sqlpp11/detail/get_last.h
+++ b/include/sqlpp11/detail/get_last.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_GET_LAST_H
-#define SQLPP_DETAIL_GET_LAST_H
+#ifndef SQLPP11_DETAIL_GET_LAST_H
+#define SQLPP11_DETAIL_GET_LAST_H
 
 #include <type_traits>
 
@@ -51,7 +51,7 @@ namespace sqlpp
 
     template <template <typename> class Predicate, typename Default, typename... T>
     using get_last_if = typename get_last_if_impl<Predicate, Default, T...>::type;
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/index_sequence.h b/include/sqlpp11/detail/index_sequence.h
index 41e1b2f6..9e9d5df3 100644
--- a/include/sqlpp11/detail/index_sequence.h
+++ b/include/sqlpp11/detail/index_sequence.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_INDEX_SEQUENCE_H
-#define SQLPP_DETAIL_INDEX_SEQUENCE_H
+#ifndef SQLPP11_DETAIL_INDEX_SEQUENCE_H
+#define SQLPP11_DETAIL_INDEX_SEQUENCE_H
 
 #include <type_traits>
 
@@ -57,7 +57,7 @@ namespace sqlpp
 
     template <std::size_t N>
     using make_index_sequence = typename make_index_sequence_impl<index_sequence<>, N>::type;
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/pick_arg.h b/include/sqlpp11/detail/pick_arg.h
index c70f6da1..8df4a8b7 100644
--- a/include/sqlpp11/detail/pick_arg.h
+++ b/include/sqlpp11/detail/pick_arg.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_PICK_ARG_H
-#define SQLPP_DETAIL_PICK_ARG_H
+#ifndef SQLPP11_DETAIL_PICK_ARG_H
+#define SQLPP11_DETAIL_PICK_ARG_H
 
 #include <type_traits>
 
@@ -34,13 +34,13 @@ namespace sqlpp
   namespace detail
   {
     template <typename Target, typename Statement, typename Term>
-    typename Target::_data_t pick_arg_impl(Statement /* statement */, Term term, const std::true_type&)
+    typename Target::_data_t pick_arg_impl(Statement /* statement */, Term term, const std::true_type& /*unused*/)
     {
       return term;
     }
 
     template <typename Target, typename Statement, typename Term>
-    typename Target::_data_t pick_arg_impl(Statement statement, Term /* term */, const std::false_type&)
+    typename Target::_data_t pick_arg_impl(Statement statement, Term /* term */, const std::false_type& /*unused*/)
     {
       return Target::_get_member(statement)._data;
     }
@@ -51,7 +51,7 @@ namespace sqlpp
     {
       return pick_arg_impl<Target>(statement, term, std::is_same<typename Target::_data_t, Term>());
     }
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/sum.h b/include/sqlpp11/detail/sum.h
index 443d4616..8a0b762b 100644
--- a/include/sqlpp11/detail/sum.h
+++ b/include/sqlpp11/detail/sum.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_SUM_H
-#define SQLPP_DETAIL_SUM_H
+#ifndef SQLPP11_DETAIL_SUM_H
+#define SQLPP11_DETAIL_SUM_H
 
 namespace sqlpp
 {
@@ -54,7 +54,7 @@ namespace sqlpp
     {
       return arg + sum(rest...);
     }
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/type_set.h b/include/sqlpp11/detail/type_set.h
index a3981743..ebbb2293 100644
--- a/include/sqlpp11/detail/type_set.h
+++ b/include/sqlpp11/detail/type_set.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_TYPE_SET_H
-#define SQLPP_DETAIL_TYPE_SET_H
+#ifndef SQLPP11_DETAIL_TYPE_SET_H
+#define SQLPP11_DETAIL_TYPE_SET_H
 
 #include <type_traits>
 #include <sqlpp11/wrong.h>
@@ -262,7 +262,7 @@ namespace sqlpp
 
     template <typename T>
     using make_name_of_set_t = typename make_name_of_set<T>::type;
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/type_vector.h b/include/sqlpp11/detail/type_vector.h
index 6d89aab3..06cb4ba1 100644
--- a/include/sqlpp11/detail/type_vector.h
+++ b/include/sqlpp11/detail/type_vector.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_TYPE_VECTOR_H
-#define SQLPP_DETAIL_TYPE_VECTOR_H
+#ifndef SQLPP11_DETAIL_TYPE_VECTOR_H
+#define SQLPP11_DETAIL_TYPE_VECTOR_H
 
 #include <sqlpp11/wrong.h>
 
@@ -83,7 +83,7 @@ namespace sqlpp
     {
       static constexpr std::size_t value = sizeof...(T);
     };
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/detail/void.h b/include/sqlpp11/detail/void.h
index 10d48199..aa7d326d 100644
--- a/include/sqlpp11/detail/void.h
+++ b/include/sqlpp11/detail/void.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_VOID_H
-#define SQLPP_DETAIL_VOID_H
+#ifndef SQLPP11_DETAIL_VOID_H
+#define SQLPP11_DETAIL_VOID_H
 
 namespace sqlpp
 {
@@ -39,7 +39,7 @@ namespace sqlpp
 
     template <typename T>
     using void_t = typename void_impl<T>::type;
-  }
-}
+  }  // namespace detail
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/dynamic_join.h b/include/sqlpp11/dynamic_join.h
index fc7e742d..cf778234 100644
--- a/include/sqlpp11/dynamic_join.h
+++ b/include/sqlpp11/dynamic_join.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DYNAMIC_JOIN_H
-#define SQLPP_DYNAMIC_JOIN_H
+#ifndef SQLPP11_DYNAMIC_JOIN_H
+#define SQLPP11_DYNAMIC_JOIN_H
 
 #include <sqlpp11/dynamic_pre_join.h>
 
@@ -61,6 +61,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/dynamic_pre_join.h b/include/sqlpp11/dynamic_pre_join.h
index ed3dab9a..4ca3b5fe 100644
--- a/include/sqlpp11/dynamic_pre_join.h
+++ b/include/sqlpp11/dynamic_pre_join.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DYNAMIC_PRE_JOIN_H
-#define SQLPP_DYNAMIC_PRE_JOIN_H
+#ifndef SQLPP11_DYNAMIC_PRE_JOIN_H
+#define SQLPP11_DYNAMIC_PRE_JOIN_H
 
 #include <sqlpp11/join_types.h>
 #include <sqlpp11/on.h>
@@ -167,6 +167,6 @@ namespace sqlpp
   {
     return {dynamic_pre_join_t<cross_join_t, Table>{table}, {}};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/dynamic_select_column_list.h b/include/sqlpp11/dynamic_select_column_list.h
index 30beffbc..a7ec8727 100644
--- a/include/sqlpp11/dynamic_select_column_list.h
+++ b/include/sqlpp11/dynamic_select_column_list.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SELECT_COLUMN_LIST_FWD_H
-#define SQLPP_SELECT_COLUMN_LIST_FWD_H
+#ifndef SQLPP11_DYNAMIC_SELECT_COLUMN_LIST_H
+#define SQLPP11_DYNAMIC_SELECT_COLUMN_LIST_H
 
 #include <vector>
 #include <string>
@@ -87,9 +87,13 @@ namespace sqlpp
       for (const auto column : t._dynamic_columns)
       {
         if (first)
+        {
           first = false;
+        }
         else
+        {
           context << ',';
+        }
         serialize(column, context);
       }
       return context;
@@ -101,11 +105,11 @@ namespace sqlpp
   {
     using T = dynamic_select_column_list<void>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/eval.h b/include/sqlpp11/eval.h
index 26760bf5..d07faae7 100644
--- a/include/sqlpp11/eval.h
+++ b/include/sqlpp11/eval.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_EVAL_H
-#define SQLPP_EVAL_H
+#ifndef SQLPP11_EVAL_H
+#define SQLPP11_EVAL_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/field_spec.h>
@@ -61,6 +61,6 @@ namespace sqlpp
   {
     return eval(db, verbatim<ValueType>(sql_code));
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/exception.h b/include/sqlpp11/exception.h
index c531c2b1..36fcda9e 100644
--- a/include/sqlpp11/exception.h
+++ b/include/sqlpp11/exception.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_EXCEPTION_H
-#define SQLPP_EXCEPTION_H
+#ifndef SQLPP11_EXCEPTION_H
+#define SQLPP11_EXCEPTION_H
 
 #include <stdexcept>
 
@@ -41,6 +41,6 @@ namespace sqlpp
     {
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/exists.h b/include/sqlpp11/exists.h
index 5cab7395..2aaa9a50 100644
--- a/include/sqlpp11/exists.h
+++ b/include/sqlpp11/exists.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_EXISTS_H
-#define SQLPP_EXISTS_H
+#ifndef SQLPP11_EXISTS_H
+#define SQLPP11_EXISTS_H
 
 #include <sqlpp11/char_sequence.h>
 #include <sqlpp11/data_types/boolean.h>
@@ -98,6 +98,6 @@ namespace sqlpp
     static_assert(is_select_t<wrap_operand_t<T>>::value, "exists() requires a select expression as argument");
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/expression.h b/include/sqlpp11/expression.h
index 68b99aaa..2d81a4f1 100644
--- a/include/sqlpp11/expression.h
+++ b/include/sqlpp11/expression.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_EXPRESSION_H
-#define SQLPP_EXPRESSION_H
+#ifndef SQLPP11_EXPRESSION_H
+#define SQLPP11_EXPRESSION_H
 
 #include <sqlpp11/alias.h>
 #include <sqlpp11/data_types/boolean.h>
@@ -253,6 +253,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/expression_fwd.h b/include/sqlpp11/expression_fwd.h
index 1ae8355f..220ab439 100644
--- a/include/sqlpp11/expression_fwd.h
+++ b/include/sqlpp11/expression_fwd.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_EXPRESSION_FWD_H
-#define SQLPP_EXPRESSION_FWD_H
+#ifndef SQLPP11_EXPRESSION_FWD_H
+#define SQLPP11_EXPRESSION_FWD_H
 
 namespace sqlpp
 {
@@ -147,7 +147,7 @@ namespace sqlpp
       using _traits = make_traits<ValueType>;
       static constexpr const char* _name = "|";
     };
-  }
+  }  // namespace op
 
   template <typename Lhs, typename O, typename Rhs>
   struct binary_expression_t;
@@ -234,7 +234,7 @@ namespace sqlpp
     {
       using type = typename Expr::_rhs_t;
     };
-  }
+  }  // namespace detail
 
   // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2086629
   template <typename Expr>
@@ -249,6 +249,6 @@ namespace sqlpp
 
   template <typename Expr>
   using rhs_t = typename detail::rhs_impl<Expr>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/expression_operators.h b/include/sqlpp11/expression_operators.h
index 2ead994a..c2cefbcc 100644
--- a/include/sqlpp11/expression_operators.h
+++ b/include/sqlpp11/expression_operators.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_EXPRESSION_OPERATORS_H
-#define SQLPP_EXPRESSION_OPERATORS_H
+#ifndef SQLPP11_EXPRESSION_OPERATORS_H
+#define SQLPP11_EXPRESSION_OPERATORS_H
 
 #include <sqlpp11/wrong.h>
 
@@ -36,6 +36,6 @@ namespace sqlpp
   {
     static_assert(wrong_t<expression_operators>::value, "Missing expression operators for ValueType");
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/expression_return_types.h b/include/sqlpp11/expression_return_types.h
index bbec6f6f..95ac4619 100644
--- a/include/sqlpp11/expression_return_types.h
+++ b/include/sqlpp11/expression_return_types.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_EXPRESSION_RETURN_TYPES_H
-#define SQLPP_EXPRESSION_RETURN_TYPES_H
+#ifndef SQLPP11_EXPRESSION_RETURN_TYPES_H
+#define SQLPP11_EXPRESSION_RETURN_TYPES_H
 
 #include <sqlpp11/bad_expression.h>
 
@@ -138,6 +138,6 @@ namespace sqlpp
   };
   template <typename T, typename Defer>
   using return_type_unary_minus_t = typename return_type_unary_minus<T, Defer>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/field_spec.h b/include/sqlpp11/field_spec.h
index 53d6189f..2e1418de 100644
--- a/include/sqlpp11/field_spec.h
+++ b/include/sqlpp11/field_spec.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FIELD_SPEC_H
-#define SQLPP_FIELD_SPEC_H
+#ifndef SQLPP11_FIELD_SPEC_H
+#define SQLPP11_FIELD_SPEC_H
 
 #include <sqlpp11/multi_column.h>
 
@@ -110,10 +110,10 @@ namespace sqlpp
       using type =
           multi_field_spec_t<AliasProvider, std::tuple<typename make_field_spec_impl<Select, NamedExprs>::type...>>;
     };
-  }
+  }  // namespace detail
 
   template <typename Select, typename NamedExpr>
   using make_field_spec_t = typename detail::make_field_spec_impl<Select, NamedExpr>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/for_update.h b/include/sqlpp11/for_update.h
index 0ee3471a..aeff3c3d 100644
--- a/include/sqlpp11/for_update.h
+++ b/include/sqlpp11/for_update.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FOR_UPDATE_H
-#define SQLPP_FOR_UPDATE_H
+#ifndef SQLPP11_FOR_UPDATE_H
+#define SQLPP11_FOR_UPDATE_H
 
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/policy_update.h>
@@ -162,7 +162,7 @@ namespace sqlpp
     using _serialize_check = serialize_check_of<Context>;
     using T = for_update_data_t;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << " FOR UPDATE ";
       return context;
@@ -174,6 +174,6 @@ namespace sqlpp
   {
     return statement_t<void, no_for_update_t>().for_update(std::forward<T>(t));
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/from.h b/include/sqlpp11/from.h
index afdc810f..1e897903 100644
--- a/include/sqlpp11/from.h
+++ b/include/sqlpp11/from.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FROM_H
-#define SQLPP_FROM_H
+#ifndef SQLPP11_FROM_H
+#define SQLPP11_FROM_H
 
 #include <sqlpp11/detail/sum.h>
 #include <sqlpp11/dynamic_join.h>
@@ -125,7 +125,7 @@ namespace sqlpp
 
     private:
       template <typename DynamicJoin>
-      auto _add_impl(DynamicJoin dynamicJoin, consistent_t) -> void
+      auto _add_impl(DynamicJoin dynamicJoin, consistent_t /*unused*/) -> void
       {
         _data._dynamic_tables.emplace_back(from_table(dynamicJoin));
       }
@@ -279,7 +279,7 @@ namespace sqlpp
       auto _from_impl(Check, Table table) const -> inconsistent<Check>;
 
       template <typename Database, typename Table>
-      auto _from_impl(consistent_t, Table table) const
+      auto _from_impl(consistent_t /*unused*/, Table table) const
           -> _new_statement_t<consistent_t, from_t<Database, from_table_t<Table>>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
@@ -314,11 +314,11 @@ namespace sqlpp
   }
 
   template <typename Database, typename T>
-  auto dynamic_from(const Database&, T&& t)
+  auto dynamic_from(const Database& /*unused*/, T&& t)
       -> decltype(statement_t<Database, no_from_t>().dynamic_from(std::forward<T>(t)))
   {
     return statement_t<Database, no_from_t>().dynamic_from(std::forward<T>(t));
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/functions.h b/include/sqlpp11/functions.h
index bb208eb3..e867b656 100644
--- a/include/sqlpp11/functions.h
+++ b/include/sqlpp11/functions.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_FUNCTIONS_H
-#define SQLPP_FUNCTIONS_H
+#ifndef SQLPP11_FUNCTIONS_H
+#define SQLPP11_FUNCTIONS_H
 
 #include <sqlpp11/parameter.h>
 #include <sqlpp11/parameter_list.h>
@@ -108,9 +108,13 @@ namespace sqlpp
       for (const auto& entry : t._container)
       {
         if (first)
+        {
           first = false;
+        }
         else
+        {
           context << ',';
+        }
 
         serialize_operand(value(entry), context);
       }
@@ -128,10 +132,10 @@ namespace sqlpp
   }
 
   template <typename T>
-  constexpr const char* get_sql_name(const T&)
+  constexpr const char* get_sql_name(const T& /*unused*/)
   {
     return name_of<T>::char_ptr();
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/group_by.h b/include/sqlpp11/group_by.h
index 5a8c420b..3066e917 100644
--- a/include/sqlpp11/group_by.h
+++ b/include/sqlpp11/group_by.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_GROUP_BY_H
-#define SQLPP_GROUP_BY_H
+#ifndef SQLPP11_GROUP_BY_H
+#define SQLPP11_GROUP_BY_H
 
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
@@ -100,7 +100,7 @@ namespace sqlpp
 
     private:
       template <typename Expression>
-      void _add_impl(Expression expression, const std::true_type&)
+      void _add_impl(Expression expression, const std::true_type& /*unused*/)
       {
         return _data._dynamic_expressions.emplace_back(expression);
       }
@@ -238,7 +238,7 @@ namespace sqlpp
       auto _group_by_impl(Check, Expressions... expressions) const -> inconsistent<Check>;
 
       template <typename Database, typename... Expressions>
-      auto _group_by_impl(consistent_t, Expressions... expressions) const
+      auto _group_by_impl(consistent_t /*unused*/, Expressions... expressions) const
           -> _new_statement_t<consistent_t, group_by_t<Database, Expressions...>>
       {
         static_assert(not detail::has_duplicates<Expressions...>::value,
@@ -260,11 +260,15 @@ namespace sqlpp
     static Context& _(const T& t, Context& context)
     {
       if (sizeof...(Expressions) == 0 and t._dynamic_expressions.empty())
+      {
         return context;
+      }
       context << " GROUP BY ";
       interpret_tuple(t._expressions, ',', context);
       if (sizeof...(Expressions) and not t._dynamic_expressions.empty())
+      {
         context << ',';
+      }
       interpret_list(t._dynamic_expressions, ',', context);
       return context;
     }
@@ -277,11 +281,11 @@ namespace sqlpp
   }
 
   template <typename Database, typename... T>
-  auto dynamic_group_by(const Database&, T&&... t)
+  auto dynamic_group_by(const Database& /*unused*/, T&&... t)
       -> decltype(statement_t<Database, no_group_by_t>().dynamic_group_by(std::forward<T>(t)...))
   {
     return statement_t<Database, no_group_by_t>().dynamic_group_by(std::forward<T>(t)...);
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/having.h b/include/sqlpp11/having.h
index d2cd2e8b..ee451fb5 100644
--- a/include/sqlpp11/having.h
+++ b/include/sqlpp11/having.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_HAVING_H
-#define SQLPP_HAVING_H
+#ifndef SQLPP11_HAVING_H
+#define SQLPP11_HAVING_H
 
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
@@ -101,7 +101,7 @@ namespace sqlpp
 
     private:
       template <typename Expr>
-      void _add_impl(Expr expression, const std::true_type&)
+      void _add_impl(Expr expression, const std::true_type& /*unused*/)
       {
         return _data._dynamic_expressions.emplace_back(expression);
       }
@@ -281,7 +281,7 @@ namespace sqlpp
       auto _having_impl(Check, Expression expression) const -> inconsistent<Check>;
 
       template <typename Database, typename Expression>
-      auto _having_impl(consistent_t, Expression expression) const
+      auto _having_impl(consistent_t /*unused*/, Expression expression) const
           -> _new_statement_t<consistent_t, having_t<Database, Expression>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
@@ -302,7 +302,9 @@ namespace sqlpp
       context << " HAVING ";
       serialize(t._expression, context);
       if (not t._dynamic_expressions.empty())
+      {
         context << " AND ";
+      }
       interpret_list(t._dynamic_expressions, " AND ", context);
       return context;
     }
@@ -315,11 +317,11 @@ namespace sqlpp
   }
 
   template <typename Database, typename T>
-  auto dynamic_having(const Database&, T&& t)
+  auto dynamic_having(const Database& /*unused*/, T&& t)
       -> decltype(statement_t<Database, no_having_t>().dynamic_having(std::forward<T>(t)))
   {
     return statement_t<Database, no_having_t>().dynamic_having(std::forward<T>(t));
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/hidden.h b/include/sqlpp11/hidden.h
index 76861ee2..fa31d8c9 100644
--- a/include/sqlpp11/hidden.h
+++ b/include/sqlpp11/hidden.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_HIDDEN_H
-#define SQLPP_HIDDEN_H
+#ifndef SQLPP11_HIDDEN_H
+#define SQLPP11_HIDDEN_H
 
 #include <sqlpp11/serializer.h>
 
@@ -51,7 +51,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = hidden_t<Clause>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       return context;
     }
@@ -62,5 +62,5 @@ namespace sqlpp
   {
     return {part};
   }
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/in.h b/include/sqlpp11/in.h
index 1ad51217..3f1c7fbb 100644
--- a/include/sqlpp11/in.h
+++ b/include/sqlpp11/in.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_IN_H
-#define SQLPP_IN_H
+#ifndef SQLPP11_IN_H
+#define SQLPP11_IN_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/char_sequence.h>
@@ -83,9 +83,13 @@ namespace sqlpp
       serialize(t._operand, context);
       context << " IN(";
       if (sizeof...(Args) == 1)
+      {
         serialize(std::get<0>(t._args), context);
+      }
       else
+      {
         interpret_tuple(t._args, ',', context);
+      }
       context << ')';
       return context;
     }
@@ -97,7 +101,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = in_t<Operand>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       serialize(boolean_operand{false}, context);
       return context;
@@ -130,6 +134,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/in_fwd.h b/include/sqlpp11/in_fwd.h
index 281137d8..4a5c8677 100644
--- a/include/sqlpp11/in_fwd.h
+++ b/include/sqlpp11/in_fwd.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_IN_FWD_H
-#define SQLPP_IN_FWD_H
+#ifndef SQLPP11_IN_FWD_H
+#define SQLPP11_IN_FWD_H
 
 namespace sqlpp
 {
@@ -33,6 +33,6 @@ namespace sqlpp
   struct in_t;
   template <typename Operand, typename... Args>
   struct not_in_t;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/inconsistent.h b/include/sqlpp11/inconsistent.h
index 0a46c929..82e83ec2 100644
--- a/include/sqlpp11/inconsistent.h
+++ b/include/sqlpp11/inconsistent.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INCONSISTENT_H
-#define SQLPP_INCONSISTENT_H
+#ifndef SQLPP11_INCONSISTENT_H
+#define SQLPP11_INCONSISTENT_H
 
 #include <utility>
 
@@ -40,6 +40,6 @@ namespace sqlpp
   template <typename Check>
   using inconsistent = typename std::enable_if<not std::is_same<consistent_t, Check>::value, Check>::type;
 #endif
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/insert.h b/include/sqlpp11/insert.h
index 5b635977..e1672cff 100644
--- a/include/sqlpp11/insert.h
+++ b/include/sqlpp11/insert.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INSERT_H
-#define SQLPP_INSERT_H
+#ifndef SQLPP11_INSERT_H
+#define SQLPP11_INSERT_H
 
 #include <sqlpp11/statement.h>
 #include <sqlpp11/connection.h>
@@ -94,7 +94,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = insert_name_t;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << "INSERT";
 
@@ -107,7 +107,7 @@ namespace sqlpp
 
   inline auto insert() -> blank_insert_t<void>
   {
-    return {blank_insert_t<void>()};
+    return {};
   }
 
   template <typename Table>
@@ -117,18 +117,19 @@ namespace sqlpp
   }
 
   template <typename Database>
-  constexpr auto dynamic_insert(const Database&) -> decltype(blank_insert_t<Database>())
+  constexpr auto dynamic_insert(const Database & /*unused*/) -> decltype(blank_insert_t<Database>())
   {
     static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
     return {blank_insert_t<Database>()};
   }
 
   template <typename Database, typename Table>
-  constexpr auto dynamic_insert_into(const Database&, Table table) -> decltype(blank_insert_t<Database>().into(table))
+  constexpr auto dynamic_insert_into(const Database& /*unused*/, Table table)
+      -> decltype(blank_insert_t<Database>().into(table))
   {
     static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
     return {blank_insert_t<Database>().into(table)};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/insert_value.h b/include/sqlpp11/insert_value.h
index ba6f7223..e78c9043 100644
--- a/include/sqlpp11/insert_value.h
+++ b/include/sqlpp11/insert_value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INSERT_VALUE_H
-#define SQLPP_INSERT_VALUE_H
+#ifndef SQLPP11_INSERT_VALUE_H
+#define SQLPP11_INSERT_VALUE_H
 
 #include <sqlpp11/default_value.h>
 #include <sqlpp11/null.h>
@@ -53,7 +53,7 @@ namespace sqlpp
         using _nodes = detail::type_vector<>;
       };
     };
-  }
+  }  // namespace detail
 
   template <typename Column>
   struct insert_value_t
@@ -75,11 +75,12 @@ namespace sqlpp
     {
     }
 
-    insert_value_t(const rhs_wrap_t<null_t, _trivial_value_is_null>&) : _is_null(true), _is_default(false), _value{}
+    insert_value_t(const rhs_wrap_t<null_t, _trivial_value_is_null>& /*unused*/)
+        : _is_null(true), _is_default(false), _value{}
     {
     }
 
-    insert_value_t(const rhs_wrap_t<default_value_t, _trivial_value_is_null>&)
+    insert_value_t(const rhs_wrap_t<default_value_t, _trivial_value_is_null>& /*unused*/)
         : _is_null(false), _is_default(true), _value{}
     {
     }
@@ -108,12 +109,16 @@ namespace sqlpp
         context << "NULL";
       }
       else if (t._is_default)
+      {
         context << "DEFAULT";
+      }
       else
+      {
         serialize_operand(t._value, context);
+      }
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/insert_value_list.h b/include/sqlpp11/insert_value_list.h
index 2eed4b1b..1eb29bf2 100644
--- a/include/sqlpp11/insert_value_list.h
+++ b/include/sqlpp11/insert_value_list.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INSERT_VALUE_LIST_H
-#define SQLPP_INSERT_VALUE_LIST_H
+#ifndef SQLPP11_INSERT_VALUE_LIST_H
+#define SQLPP11_INSERT_VALUE_LIST_H
 
 #include <sqlpp11/assignment.h>
 #include <sqlpp11/column_fwd.h>
@@ -60,7 +60,7 @@ namespace sqlpp
       using set_columns = detail::make_type_set_t<First, Columns...>;
       static constexpr bool value = detail::is_subset_of<required_columns, set_columns>::value;
     };
-  }
+  }  // namespace detail
 
   struct insert_default_values_data_t
   {
@@ -180,10 +180,9 @@ namespace sqlpp
       static_check_t<not detail::has_duplicates<typename lhs<Assignments>::type...>::value,
                      assert_insert_set_no_duplicates_t>,
       static_check_t<logic::none_t<must_not_insert<Assignments>::value...>::value, assert_insert_set_allowed_t>,
-      static_check_t<
-          sizeof...(Assignments) == 0 or
-              detail::make_joined_set_t<required_tables_of<typename lhs<Assignments>::type>...>::size::value == 1,
-          assert_insert_set_single_table_t>>;
+      static_check_t<sizeof...(Assignments) == 0 or detail::make_joined_set_t<required_tables_of<
+                                                        typename lhs<Assignments>::type>...>::size::value == 1,
+                     assert_insert_set_single_table_t>>;
 
   // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
   //  template <typename... Assignments>
@@ -272,7 +271,7 @@ namespace sqlpp
 
     private:
       template <typename Assignment>
-      void _add_impl(Assignment assignment, const std::true_type&)
+      void _add_impl(Assignment assignment, const std::true_type& /*unused*/)
       {
         _data._dynamic_columns.emplace_back(simple_column_t<lhs_t<Assignment>>{assignment._lhs});
         _data._dynamic_values.emplace_back(assignment._rhs);
@@ -378,7 +377,7 @@ namespace sqlpp
 
     private:
       template <typename... Assignments>
-      void _add_impl(const std::true_type&, Assignments... assignments)
+      void _add_impl(const std::true_type& /*unused*/, Assignments... assignments)
       {
         return _data._insert_values.emplace_back(insert_value_t<lhs_t<Assignments>>{assignments._rhs}...);
       }
@@ -529,7 +528,7 @@ namespace sqlpp
       auto _columns_impl(Check, Columns... cols) const -> inconsistent<Check>;
 
       template <typename... Columns>
-      auto _columns_impl(consistent_t, Columns... cols) const
+      auto _columns_impl(consistent_t /*unused*/, Columns... cols) const
           -> _new_statement_t<consistent_t, column_list_t<Columns...>>
       {
         static_assert(not detail::has_duplicates<Columns...>::value,
@@ -549,7 +548,7 @@ namespace sqlpp
       auto _set_impl(Check, Assignments... assignments) const -> inconsistent<Check>;
 
       template <typename Database, typename... Assignments>
-      auto _set_impl(consistent_t, Assignments... assignments) const
+      auto _set_impl(consistent_t /*unused*/, Assignments... assignments) const
           -> _new_statement_t<consistent_t, insert_list_t<Database, Assignments...>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
@@ -565,7 +564,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = insert_default_values_data_t;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << " DEFAULT VALUES";
       return context;
@@ -588,9 +587,13 @@ namespace sqlpp
       for (const auto& row : t._insert_values)
       {
         if (not first)
+        {
           context << ',';
+        }
         else
+        {
           first = false;
+        }
         context << '(';
         interpret_tuple(row, ",", context);
         context << ')';
@@ -617,12 +620,16 @@ namespace sqlpp
         context << " (";
         interpret_tuple(t._columns, ",", context);
         if (sizeof...(Assignments) and not t._dynamic_columns.empty())
+        {
           context << ',';
+        }
         interpret_list(t._dynamic_columns, ',', context);
         context << ") VALUES(";
         interpret_tuple(t._values, ",", context);
         if (sizeof...(Assignments) and not t._dynamic_values.empty())
+        {
           context << ',';
+        }
         interpret_list(t._dynamic_values, ',', context);
         context << ")";
       }
@@ -643,6 +650,6 @@ namespace sqlpp
   {
     return statement_t<Database, no_insert_value_list_t>().dynamic_set(assignments...);
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/interpret.h b/include/sqlpp11/interpret.h
index 4d376451..41fee4e5 100644
--- a/include/sqlpp11/interpret.h
+++ b/include/sqlpp11/interpret.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTERPRET_H
-#define SQLPP_INTERPRET_H
+#ifndef SQLPP11_INTERPRET_H
+#define SQLPP11_INTERPRET_H
 
 #include <sqlpp11/interpreter.h>
 
@@ -36,6 +36,6 @@ namespace sqlpp
   {
     return interpreter_t<Context, T>::_(t, context);
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/interpret_tuple.h b/include/sqlpp11/interpret_tuple.h
index 13b46ca9..f0de500f 100644
--- a/include/sqlpp11/interpret_tuple.h
+++ b/include/sqlpp11/interpret_tuple.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTERPRET_TUPLE_H
-#define SQLPP_INTERPRET_TUPLE_H
+#ifndef SQLPP11_INTERPRET_TUPLE_H
+#define SQLPP11_INTERPRET_TUPLE_H
 
 #include <tuple>
 #include <sqlpp11/type_traits.h>
@@ -36,14 +36,20 @@ namespace sqlpp
 {
   template <typename Element, typename Separator, typename Context, typename UseBraces>
   static void interpret_tuple_element(
-      const Element& element, const Separator& separator, Context& context, const UseBraces&, size_t index)
+      const Element& element, const Separator& separator, Context& context, const UseBraces& /*unused*/, size_t index)
   {
     if (index)
+    {
       context << separator;
+    }
     if (UseBraces::value)
+    {
       serialize_operand(element, context);
+    }
     else
+    {
       serialize(element, context);
+    }
   }
 
   template <typename Tuple, typename Separator, typename Context, typename UseBraces, size_t... Is>
@@ -51,7 +57,8 @@ namespace sqlpp
                             const Separator& separator,
                             Context& context,
                             const UseBraces& useBraces,
-                            const detail::index_sequence<Is...>&) -> Context &
+                            const detail::index_sequence<Is...> &
+                            /*unused*/) -> Context&
   {
     // Note: A braced-init-list does guarantee the order of evaluation according to 12.6.1 [class.explicit.init]
     // paragraph 2 and 8.5.4 [dcl.init.list] paragraph 4.
@@ -66,18 +73,18 @@ namespace sqlpp
   }
 
   template <typename Tuple, typename Separator, typename Context>
-  auto interpret_tuple(const Tuple& t, const Separator& separator, Context& context) -> Context &
+  auto interpret_tuple(const Tuple& t, const Separator& separator, Context& context) -> Context&
   {
     return interpret_tuple_impl(t, separator, context, std::true_type{},
                                 detail::make_index_sequence<std::tuple_size<Tuple>::value>{});
   }
 
   template <typename Tuple, typename Separator, typename Context>
-  auto interpret_tuple_without_braces(const Tuple& t, const Separator& separator, Context& context) -> Context &
+  auto interpret_tuple_without_braces(const Tuple& t, const Separator& separator, Context& context) -> Context&
   {
     return interpret_tuple_impl(t, separator, context, std::false_type{},
                                 detail::make_index_sequence<std::tuple_size<Tuple>::value>{});
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/interpretable.h b/include/sqlpp11/interpretable.h
index b93a897a..139d2809 100644
--- a/include/sqlpp11/interpretable.h
+++ b/include/sqlpp11/interpretable.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTERPRETABLE_H
-#define SQLPP_INTERPRETABLE_H
+#ifndef SQLPP11_INTERPRETABLE_H
+#define SQLPP11_INTERPRETABLE_H
 
 #include <memory>
 #include <sqlpp11/serializer_context.h>
@@ -130,11 +130,13 @@ namespace sqlpp
         context << ')';
       }
       else
+      {
         t.serialize(context);
+      }
 
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/interpretable_list.h b/include/sqlpp11/interpretable_list.h
index dc11d0ae..acdd2f83 100644
--- a/include/sqlpp11/interpretable_list.h
+++ b/include/sqlpp11/interpretable_list.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTERPRETABLE_LIST_H
-#define SQLPP_INTERPRETABLE_LIST_H
+#ifndef SQLPP11_INTERPRETABLE_LIST_H
+#define SQLPP11_INTERPRETABLE_LIST_H
 
 #include <sqlpp11/interpretable.h>
 #include <vector>
@@ -96,7 +96,7 @@ namespace sqlpp
     using T = interpretable_list_t<void>;
 
     template <typename Separator>
-    static Context& _(const T&, const Separator& /* separator */, Context& context)
+    static Context& _(const T& /*unused*/, const Separator& /* separator */, Context& context)
     {
       return context;
     }
@@ -108,6 +108,6 @@ namespace sqlpp
   {
     return serializable_list_interpreter_t<Context, T>::_(t, separator, context);
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/interpreter.h b/include/sqlpp11/interpreter.h
index 0605c5a7..dc0a160d 100644
--- a/include/sqlpp11/interpreter.h
+++ b/include/sqlpp11/interpreter.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTERPRETER_H
-#define SQLPP_INTERPRETER_H
+#ifndef SQLPP11_INTERPRETER_H
+#define SQLPP11_INTERPRETER_H
 
 #include <sqlpp11/wrong.h>
 
@@ -34,11 +34,11 @@ namespace sqlpp
   template <typename Context, typename T, typename Enable = void>
   struct interpreter_t
   {
-    static void _(const T&, Context&)
+    static void _(const T& /*unused*/, Context& /*unused*/)
     {
       static_assert(wrong_t<interpreter_t>::value, "missing interpreter specialization");
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/into.h b/include/sqlpp11/into.h
index 4f6ea14b..cdf90ec1 100644
--- a/include/sqlpp11/into.h
+++ b/include/sqlpp11/into.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_INTO_H
-#define SQLPP_INTO_H
+#ifndef SQLPP11_INTO_H
+#define SQLPP11_INTO_H
 
 #include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/detail/type_set.h>
@@ -179,7 +179,8 @@ namespace sqlpp
       auto _into_impl(Check, Table table) const -> inconsistent<Check>;
 
       template <typename Database, typename Table>
-      auto _into_impl(consistent_t, Table table) const -> _new_statement_t<consistent_t, into_t<Database, Table>>
+      auto _into_impl(consistent_t /*unused*/, Table table) const
+          -> _new_statement_t<consistent_t, into_t<Database, Table>>
       {
         static_assert(required_tables_of<into_t<Database, Table>>::size::value == 0,
                       "argument depends on another table in into()");
@@ -209,6 +210,6 @@ namespace sqlpp
   {
     return statement_t<void, no_into_t>().into(std::forward<T>(t));
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/is_not_null.h b/include/sqlpp11/is_not_null.h
index 1f4b9c33..de763f7b 100644
--- a/include/sqlpp11/is_not_null.h
+++ b/include/sqlpp11/is_not_null.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_IS_NOT_NULL_H
-#define SQLPP_IS_NOT_NULL_H
+#ifndef SQLPP11_IS_NOT_NULL_H
+#define SQLPP11_IS_NOT_NULL_H
 
 #include <sqlpp11/data_types/boolean.h>
 #include <sqlpp11/type_traits.h>
@@ -83,6 +83,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/is_null.h b/include/sqlpp11/is_null.h
index 97fdc047..38275d4b 100644
--- a/include/sqlpp11/is_null.h
+++ b/include/sqlpp11/is_null.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_IS_NULL_H
-#define SQLPP_IS_NULL_H
+#ifndef SQLPP11_IS_NULL_H
+#define SQLPP11_IS_NULL_H
 
 #include <sqlpp11/data_types/boolean.h>
 #include <sqlpp11/type_traits.h>
@@ -83,6 +83,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/is_null_fwd.h b/include/sqlpp11/is_null_fwd.h
index 78b5bf91..e0e420bf 100644
--- a/include/sqlpp11/is_null_fwd.h
+++ b/include/sqlpp11/is_null_fwd.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_IS_NULL_FWD_H
-#define SQLPP_IS_NULL_FWD_H
+#ifndef SQLPP11_IS_NULL_FWD_H
+#define SQLPP11_IS_NULL_FWD_H
 
 namespace sqlpp
 {
@@ -33,6 +33,6 @@ namespace sqlpp
   struct is_null_t;
   template <typename Operand>
   struct is_not_null_t;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/join.h b/include/sqlpp11/join.h
index 09ecb8fa..cf05da0d 100644
--- a/include/sqlpp11/join.h
+++ b/include/sqlpp11/join.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_JOIN_H
-#define SQLPP_JOIN_H
+#ifndef SQLPP11_JOIN_H
+#define SQLPP11_JOIN_H
 
 #include <sqlpp11/join_types.h>
 #include <sqlpp11/pre_join.h>
@@ -95,6 +95,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/join_types.h b/include/sqlpp11/join_types.h
index 50b01ed8..55561981 100644
--- a/include/sqlpp11/join_types.h
+++ b/include/sqlpp11/join_types.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_JOIN_TYPES_H
-#define SQLPP_JOIN_TYPES_H
+#ifndef SQLPP11_JOIN_TYPES_H
+#define SQLPP11_JOIN_TYPES_H
 
 #include <sqlpp11/type_traits.h>
 
@@ -68,6 +68,6 @@ namespace sqlpp
 
     static constexpr const char* _name = " CROSS";
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/limit.h b/include/sqlpp11/limit.h
index 0b35d50f..481037e1 100644
--- a/include/sqlpp11/limit.h
+++ b/include/sqlpp11/limit.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_LIMIT_H
-#define SQLPP_LIMIT_H
+#ifndef SQLPP11_LIMIT_H
+#define SQLPP11_LIMIT_H
 
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/policy_update.h>
@@ -278,7 +278,7 @@ namespace sqlpp
       auto _limit_impl(Check, Arg arg) const -> inconsistent<Check>;
 
       template <typename Arg>
-      auto _limit_impl(consistent_t, Arg arg) const -> _new_statement_t<consistent_t, limit_t<Arg>>
+      auto _limit_impl(consistent_t /*unused*/, Arg arg) const -> _new_statement_t<consistent_t, limit_t<Arg>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this), limit_data_t<Arg>{arg}};
       }
@@ -324,10 +324,10 @@ namespace sqlpp
   }
 
   template <typename Database>
-  auto dynamic_limit(const Database&) -> decltype(statement_t<Database, no_limit_t>().dynamic_limit())
+  auto dynamic_limit(const Database & /*unused*/) -> decltype(statement_t<Database, no_limit_t>().dynamic_limit())
   {
     return statement_t<Database, no_limit_t>().dynamic_limit();
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/logic.h b/include/sqlpp11/logic.h
index 543cbf05..c82003ab 100644
--- a/include/sqlpp11/logic.h
+++ b/include/sqlpp11/logic.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_LOGIC_H
-#define SQLPP_DETAIL_LOGIC_H
+#ifndef SQLPP11_LOGIC_H
+#define SQLPP11_LOGIC_H
 
 #include <ciso646>  // Required for some compilers to use aliases for boolean operators
 #include <type_traits>
@@ -84,7 +84,7 @@ namespace sqlpp
 
     template <typename T>
     using identity_t = T;
-  }
-}
+  }  // namespace logic
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/multi_column.h b/include/sqlpp11/multi_column.h
index a8bd1377..67886749 100644
--- a/include/sqlpp11/multi_column.h
+++ b/include/sqlpp11/multi_column.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_MULTI_COLUMN_H
-#define SQLPP_MULTI_COLUMN_H
+#ifndef SQLPP11_MULTI_COLUMN_H
+#define SQLPP11_MULTI_COLUMN_H
 
 #include <sqlpp11/logic.h>
 #include <sqlpp11/detail/type_set.h>
@@ -63,7 +63,7 @@ namespace sqlpp
     ~multi_column_t() = default;
 
     template <typename AliasProvider>
-    multi_column_alias_t<AliasProvider, Columns...> as(const AliasProvider&)
+    multi_column_alias_t<AliasProvider, Columns...> as(const AliasProvider& /*unused*/)
     {
       return {*this};
     }
@@ -109,7 +109,7 @@ namespace sqlpp
     using _serialize_check = serialize_check_of<Context, Columns...>;
     using T = multi_column_t<void, Columns...>;
 
-    static void _(const T&, Context&)
+    static void _(const T& /*unused*/, Context& /*unused*/)
     {
       static_assert(wrong_t<serializer_t>::value, "multi_column must be used with an alias");
     }
@@ -133,13 +133,13 @@ namespace sqlpp
     template <typename... Columns>
     using make_multi_column_t =
         copy_tuple_args_t<multi_column_t, void, decltype(column_tuple_merge(std::declval<Columns>()...))>;
-  }
+  }  // namespace detail
 
   template <typename... Columns>
   auto multi_column(Columns... columns) -> detail::make_multi_column_t<Columns...>
   {
     return detail::make_multi_column_t<Columns...>(std::tuple_cat(detail::as_column_tuple<Columns>::_(columns)...));
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/named_interpretable.h b/include/sqlpp11/named_interpretable.h
index 75f798d7..108dbaf4 100644
--- a/include/sqlpp11/named_interpretable.h
+++ b/include/sqlpp11/named_interpretable.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NAMED_SERIALIZABLE_H
-#define SQLPP_NAMED_SERIALIZABLE_H
+#ifndef SQLPP11_NAMED_INTERPRETABLE_H
+#define SQLPP11_NAMED_INTERPRETABLE_H
 
 #include <memory>
 #include <sqlpp11/serializer_context.h>
@@ -140,11 +140,13 @@ namespace sqlpp
         context << ')';
       }
       else
+      {
         t.serialize(context);
+      }
 
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/no_data.h b/include/sqlpp11/no_data.h
index f823747b..a8596d0c 100644
--- a/include/sqlpp11/no_data.h
+++ b/include/sqlpp11/no_data.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_DATA_H
-#define SQLPP_NO_DATA_H
+#ifndef SQLPP11_NO_DATA_H
+#define SQLPP11_NO_DATA_H
 
 #include <type_traits>
 #include <sqlpp11/serializer.h>
@@ -42,10 +42,10 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = no_data_t;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       return context;
     }
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/no_name.h b/include/sqlpp11/no_name.h
index 2ba2e9e2..515376a2 100644
--- a/include/sqlpp11/no_name.h
+++ b/include/sqlpp11/no_name.h
@@ -24,13 +24,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NO_NAME_H
-#define SQLPP_NO_NAME_H
+#ifndef SQLPP11_NO_NAME_H
+#define SQLPP11_NO_NAME_H
 
 namespace sqlpp
 {
   struct no_name_t
   {
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/noop.h b/include/sqlpp11/noop.h
index 3236e226..5d0ee40d 100644
--- a/include/sqlpp11/noop.h
+++ b/include/sqlpp11/noop.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NOOP_H
-#define SQLPP_NOOP_H
+#ifndef SQLPP11_NOOP_H
+#define SQLPP11_NOOP_H
 
 #include <type_traits>
 #include <sqlpp11/data_types/no_value.h>
@@ -87,7 +87,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = noop;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       return context;
     }
@@ -97,5 +97,5 @@ namespace sqlpp
   struct is_noop : std::is_same<T, noop>
   {
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/not_in.h b/include/sqlpp11/not_in.h
index eae91869..08261a71 100644
--- a/include/sqlpp11/not_in.h
+++ b/include/sqlpp11/not_in.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NOT_IN_H
-#define SQLPP_NOT_IN_H
+#ifndef SQLPP11_NOT_IN_H
+#define SQLPP11_NOT_IN_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/char_sequence.h>
@@ -83,9 +83,13 @@ namespace sqlpp
       serialize_operand(t._operand, context);
       context << " NOT IN(";
       if (sizeof...(Args) == 1)
+      {
         serialize(std::get<0>(t._args), context);
+      }
       else
+      {
         interpret_tuple(t._args, ',', context);
+      }
       context << ')';
       return context;
     }
@@ -97,7 +101,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = not_in_t<Operand>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       serialize(boolean_operand{true}, context);
       return context;
@@ -130,6 +134,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/null.h b/include/sqlpp11/null.h
index cde00e65..7e8f8431 100644
--- a/include/sqlpp11/null.h
+++ b/include/sqlpp11/null.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_NULL_H
-#define SQLPP_NULL_H
+#ifndef SQLPP11_NULL_H
+#define SQLPP11_NULL_H
 
 #include <sqlpp11/data_types/no_value.h>
 
@@ -43,7 +43,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using Operand = null_t;
 
-    static Context& _(const Operand&, Context& context)
+    static Context& _(const Operand& /*unused*/, Context& context)
     {
       context << "NULL";
       return context;
@@ -51,6 +51,6 @@ namespace sqlpp
   };
 
   constexpr null_t null = {};
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/offset.h b/include/sqlpp11/offset.h
index fa2f9e1c..943946de 100644
--- a/include/sqlpp11/offset.h
+++ b/include/sqlpp11/offset.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_OFFSET_H
-#define SQLPP_OFFSET_H
+#ifndef SQLPP11_OFFSET_H
+#define SQLPP11_OFFSET_H
 
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/policy_update.h>
@@ -292,7 +292,7 @@ namespace sqlpp
       auto _offset_impl(Check, Arg arg) const -> inconsistent<Check>;
 
       template <typename Arg>
-      auto _offset_impl(consistent_t, Arg arg) const -> _new_statement_t<consistent_t, offset_t<Arg>>
+      auto _offset_impl(consistent_t /*unused*/, Arg arg) const -> _new_statement_t<consistent_t, offset_t<Arg>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this), offset_data_t<Arg>{arg}};
       }
@@ -338,10 +338,10 @@ namespace sqlpp
   }
 
   template <typename Database>
-  auto dynamic_offset(const Database&) -> decltype(statement_t<Database, no_offset_t>().dynamic_offset())
+  auto dynamic_offset(const Database & /*unused*/) -> decltype(statement_t<Database, no_offset_t>().dynamic_offset())
   {
     return statement_t<Database, no_offset_t>().dynamic_offset();
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/on.h b/include/sqlpp11/on.h
index 9a66b784..d16a44df 100644
--- a/include/sqlpp11/on.h
+++ b/include/sqlpp11/on.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_ON_H
-#define SQLPP_ON_H
+#ifndef SQLPP11_ON_H
+#define SQLPP11_ON_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/interpretable_list.h>
@@ -69,7 +69,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = on_t<unconditional_t>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       return context;
     }
@@ -88,6 +88,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/operand_check.h b/include/sqlpp11/operand_check.h
index 4060d7dc..6775334e 100644
--- a/include/sqlpp11/operand_check.h
+++ b/include/sqlpp11/operand_check.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_OPERAND_CHECK_H
-#define SQLPP_OPERAND_CHECK_H
+#ifndef SQLPP11_OPERAND_CHECK_H
+#define SQLPP11_OPERAND_CHECK_H
 
 #include <sqlpp11/wrap_operand.h>
 #include <sqlpp11/detail/enable_if.h>
@@ -70,6 +70,6 @@ namespace sqlpp
 
   template <typename L, template <typename> class LPred, typename R, template <typename> class RPred>
   using unwrapped_binary_operand_check_t = typename binary_operand_check<L, LPred, R, RPred>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/order_by.h b/include/sqlpp11/order_by.h
index 16d564cd..1ca1758d 100644
--- a/include/sqlpp11/order_by.h
+++ b/include/sqlpp11/order_by.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_ORDER_BY_H
-#define SQLPP_ORDER_BY_H
+#ifndef SQLPP11_ORDER_BY_H
+#define SQLPP11_ORDER_BY_H
 
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/interpret_tuple.h>
@@ -98,7 +98,7 @@ namespace sqlpp
 
     private:
       template <typename Expression>
-      void _add_impl(Expression expression, const std::true_type&)
+      void _add_impl(Expression expression, const std::true_type& /*unused*/)
       {
         return _data._dynamic_expressions.emplace_back(expression);
       }
@@ -236,7 +236,7 @@ namespace sqlpp
       auto _order_by_impl(Check, Expressions... expressions) const -> inconsistent<Check>;
 
       template <typename Database, typename... Expressions>
-      auto _order_by_impl(consistent_t, Expressions... expressions) const
+      auto _order_by_impl(consistent_t /*unused*/, Expressions... expressions) const
           -> _new_statement_t<consistent_t, order_by_t<Database, Expressions...>>
       {
         static_assert(not detail::has_duplicates<Expressions...>::value,
@@ -258,11 +258,15 @@ namespace sqlpp
     static Context& _(const T& t, Context& context)
     {
       if (sizeof...(Expressions) == 0 and t._dynamic_expressions.empty())
+      {
         return context;
+      }
       context << " ORDER BY ";
       interpret_tuple(t._expressions, ',', context);
       if (sizeof...(Expressions) and not t._dynamic_expressions.empty())
+      {
         context << ',';
+      }
       interpret_list(t._dynamic_expressions, ',', context);
       return context;
     }
@@ -275,11 +279,11 @@ namespace sqlpp
   }
 
   template <typename Database, typename... T>
-  auto dynamic_order_by(const Database&, T&&... t)
+  auto dynamic_order_by(const Database& /*unused*/, T&&... t)
       -> decltype(statement_t<Database, no_order_by_t>().dynamic_order_by(std::forward<T>(t)...))
   {
     return statement_t<Database, no_order_by_t>().dynamic_order_by(std::forward<T>(t)...);
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/parameter.h b/include/sqlpp11/parameter.h
index e3722d50..f7034a49 100644
--- a/include/sqlpp11/parameter.h
+++ b/include/sqlpp11/parameter.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PARAMETER_H
-#define SQLPP_PARAMETER_H
+#ifndef SQLPP11_PARAMETER_H
+#define SQLPP11_PARAMETER_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/alias_provider.h>
@@ -46,9 +46,7 @@ namespace sqlpp
 
     using _instance_t = member_t<NameType, parameter_value_t<ValueType>>;
 
-    parameter_t()
-    {
-    }
+    parameter_t() = default;
 
     parameter_t(const parameter_t&) = default;
     parameter_t(parameter_t&&) = default;
@@ -63,7 +61,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = parameter_t<ValueType, NameType>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << "?";
       return context;
@@ -71,19 +69,20 @@ namespace sqlpp
   };
 
   template <typename NamedExpr>
-  auto parameter(const NamedExpr&) -> parameter_t<value_type_of<NamedExpr>, NamedExpr>
+  auto parameter(const NamedExpr & /*unused*/) -> parameter_t<value_type_of<NamedExpr>, NamedExpr>
   {
     static_assert(is_selectable_t<NamedExpr>::value, "not a named expression");
     return {};
   }
 
   template <typename ValueType, typename AliasProvider>
-  auto parameter(const ValueType&, const AliasProvider&) -> parameter_t<wrap_operand_t<ValueType>, AliasProvider>
+  auto parameter(const ValueType& /*unused*/, const AliasProvider & /*unused*/)
+      -> parameter_t<wrap_operand_t<ValueType>, AliasProvider>
   {
     static_assert(is_value_type_t<ValueType>::value, "first argument is not a value type");
     static_assert(is_alias_provider_t<AliasProvider>::value, "second argument is not an alias provider");
     return {};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/parameter_list.h b/include/sqlpp11/parameter_list.h
index 4052a61d..e19ee5e5 100644
--- a/include/sqlpp11/parameter_list.h
+++ b/include/sqlpp11/parameter_list.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PARAMETER_LIST_H
-#define SQLPP_PARAMETER_LIST_H
+#ifndef SQLPP11_PARAMETER_LIST_H
+#define SQLPP11_PARAMETER_LIST_H
 
 #include <tuple>
 #include <sqlpp11/type_traits.h>
@@ -46,9 +46,7 @@ namespace sqlpp
     using _member_tuple_t = std::tuple<typename Parameter::_instance_t...>;
     using size = std::integral_constant<std::size_t, sizeof...(Parameter)>;
 
-    parameter_list_t()
-    {
-    }
+    parameter_list_t() = default;
 
     template <typename Target>
     void _bind(Target& target) const
@@ -58,7 +56,7 @@ namespace sqlpp
 
   private:
     template <typename Target, size_t... Is>
-    void _bind_impl(Target& target, const detail::index_sequence<Is...>&) const
+    void _bind_impl(Target& target, const detail::index_sequence<Is...>& /*unused*/) const
     {
       using swallow = int[];  // see interpret_tuple.h
       (void)swallow{0, (std::tuple_element<Is, _member_tuple_t>::type::operator()()._bind(target, Is), 0)...};
@@ -67,6 +65,6 @@ namespace sqlpp
 
   template <typename Exp>
   using make_parameter_list_t = parameter_list_t<parameters_of<Exp>>;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/policy_update.h b/include/sqlpp11/policy_update.h
index 70070e13..e47da9ee 100644
--- a/include/sqlpp11/policy_update.h
+++ b/include/sqlpp11/policy_update.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_POLICY_UPDATE_H
-#define SQLPP_POLICY_UPDATE_H
+#ifndef SQLPP11_POLICY_UPDATE_H
+#define SQLPP11_POLICY_UPDATE_H
 
 #include <sqlpp11/wrong.h>
 
@@ -67,6 +67,6 @@ namespace sqlpp
 
   template <typename Check, typename Policies, typename Needle, typename Replacement>
   using new_statement_t = typename new_statement_impl<Check, Policies, Needle, Replacement>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/portable_static_assert.h b/include/sqlpp11/portable_static_assert.h
index c7cbdcfb..8e78c3a7 100644
--- a/include/sqlpp11/portable_static_assert.h
+++ b/include/sqlpp11/portable_static_assert.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PORTABLE_STATIC_ASSERT_H
-#define SQLPP_PORTABLE_STATIC_ASSERT_H
+#ifndef SQLPP11_PORTABLE_STATIC_ASSERT_H
+#define SQLPP11_PORTABLE_STATIC_ASSERT_H
 
 #include <sqlpp11/consistent.h>
 #include <sqlpp11/inconsistent.h>
@@ -36,7 +36,7 @@ namespace sqlpp
   struct name : std::false_type                     \
   {                                                 \
     template <typename... T>                        \
-    name(T&&...)                                    \
+    explicit name(T&&...)                           \
     {                                               \
       static_assert(wrong_t<T...>::value, message); \
     }                                               \
@@ -57,7 +57,7 @@ namespace sqlpp
     {
       using type = consistent_t;
     };
-  }
+  }  // namespace detail
 
   template <bool Consistent, typename Assert>
   using static_check_t = typename detail::static_check_impl<Consistent, Assert>::type;
@@ -84,10 +84,10 @@ namespace sqlpp
     {
       using type = consistent_t;
     };
-  }
+  }  // namespace detail
 
   template <typename... StaticChecks>
   using static_combined_check_t = typename detail::static_combined_check_impl<StaticChecks...>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/ppgen/colops/datetime.h b/include/sqlpp11/ppgen/colops/datetime.h
index ecc134bf..15ef632b 100644
--- a/include/sqlpp11/ppgen/colops/datetime.h
+++ b/include/sqlpp11/ppgen/colops/datetime.h
@@ -29,9 +29,14 @@
 #ifndef _sqlpp__ppgen__colops__datetime_h
 #define _sqlpp__ppgen__colops__datetime_h
 
+#define SQLPP_DECLARE_COLUMN_GET_TRAITS_LAZY_date \
+  PROC_date
+#define SQLPP_DECLARE_COLUMN_GEN_TRAITS_PROC_date(...) \
+  ::sqlpp::day_point
+
 #define SQLPP_DECLARE_COLUMN_GET_TRAITS_LAZY_datetime \
   PROC_datetime
 #define SQLPP_DECLARE_COLUMN_GEN_TRAITS_PROC_datetime(...) \
-  [datetime is not implemented]
+  ::sqlpp::time_point
 
 #endif // _sqlpp__ppgen__colops__datetime_h
diff --git a/include/sqlpp11/ppgen/colops/timestamp.h b/include/sqlpp11/ppgen/colops/timestamp.h
index 6c0899ae..080be5fc 100644
--- a/include/sqlpp11/ppgen/colops/timestamp.h
+++ b/include/sqlpp11/ppgen/colops/timestamp.h
@@ -32,6 +32,6 @@
 #define SQLPP_DECLARE_COLUMN_GET_TRAITS_LAZY_timestamp \
   PROC_timestamp
 #define SQLPP_DECLARE_COLUMN_GEN_TRAITS_PROC_timestamp(...) \
-  [timestamp is not implemented]
+  ::sqlpp::time_point
 
 #endif // _sqlpp__ppgen__colops__timestamp_h
diff --git a/include/sqlpp11/pre_join.h b/include/sqlpp11/pre_join.h
index d8ef6d69..15270b09 100644
--- a/include/sqlpp11/pre_join.h
+++ b/include/sqlpp11/pre_join.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PRE_JOIN_H
-#define SQLPP_PRE_JOIN_H
+#ifndef SQLPP11_PRE_JOIN_H
+#define SQLPP11_PRE_JOIN_H
 
 #include <sqlpp11/join_types.h>
 #include <sqlpp11/noop.h>
@@ -122,7 +122,7 @@ namespace sqlpp
     auto on_impl(Check, const Expr&) const -> inconsistent<Check>;
 
     template <typename Expr>
-    auto on_impl(consistent_t, const Expr& expr) const -> join_t<pre_join_t, on_t<Expr>>
+    auto on_impl(consistent_t /*unused*/, const Expr& expr) const -> join_t<pre_join_t, on_t<Expr>>
     {
       return {*this, {expr}};
     }
@@ -158,7 +158,7 @@ namespace sqlpp
 
     template <typename JoinType, typename Lhs, typename Rhs>
     auto join_impl(Lhs lhs, Rhs rhs) -> decltype(join_impl<JoinType>(check_pre_join_t<Lhs, Rhs>{}, lhs, rhs));
-  }
+  }  // namespace detail
 
   template <typename Lhs, typename Rhs>
   auto join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<inner_join_t>(lhs, rhs))
@@ -203,13 +203,13 @@ namespace sqlpp
 
     template <typename Lhs, typename Rhs>
     auto cross_join_impl(Lhs lhs, Rhs rhs) -> decltype(cross_join_impl(check_pre_join_t<Lhs, Rhs>{}, lhs, rhs));
-  }
+  }  // namespace detail
 
   template <typename Lhs, typename Rhs>
   auto cross_join(Lhs lhs, Rhs rhs) -> decltype(detail::cross_join_impl(lhs, rhs))
   {
     return {pre_join_t<cross_join_t, Lhs, Rhs>{lhs, rhs}, {}};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/prepared_execute.h b/include/sqlpp11/prepared_execute.h
index 0080b6ee..68d200e7 100644
--- a/include/sqlpp11/prepared_execute.h
+++ b/include/sqlpp11/prepared_execute.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PREPARED_EXECUTE_H
-#define SQLPP_PREPARED_EXECUTE_H
+#ifndef SQLPP11_PREPARED_EXECUTE_H
+#define SQLPP11_PREPARED_EXECUTE_H
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
@@ -57,6 +57,6 @@ namespace sqlpp
     _parameter_list_t params;
     mutable _prepared_statement_t _prepared_statement;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/prepared_insert.h b/include/sqlpp11/prepared_insert.h
index 5e7ec2cf..25b02fd1 100644
--- a/include/sqlpp11/prepared_insert.h
+++ b/include/sqlpp11/prepared_insert.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PREPARED_INSERT_H
-#define SQLPP_PREPARED_INSERT_H
+#ifndef SQLPP11_PREPARED_INSERT_H
+#define SQLPP11_PREPARED_INSERT_H
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
@@ -57,6 +57,6 @@ namespace sqlpp
     _parameter_list_t params;
     mutable _prepared_statement_t _prepared_statement;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/prepared_remove.h b/include/sqlpp11/prepared_remove.h
index b3b4e416..bcf4c794 100644
--- a/include/sqlpp11/prepared_remove.h
+++ b/include/sqlpp11/prepared_remove.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PREPARED_REMOVE_H
-#define SQLPP_PREPARED_REMOVE_H
+#ifndef SQLPP11_PREPARED_REMOVE_H
+#define SQLPP11_PREPARED_REMOVE_H
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
@@ -57,6 +57,6 @@ namespace sqlpp
     _parameter_list_t params;
     mutable _prepared_statement_t _prepared_statement;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/prepared_select.h b/include/sqlpp11/prepared_select.h
index 57454a37..fb68d490 100644
--- a/include/sqlpp11/prepared_select.h
+++ b/include/sqlpp11/prepared_select.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PREPARED_SELECT_H
-#define SQLPP_PREPARED_SELECT_H
+#ifndef SQLPP11_PREPARED_SELECT_H
+#define SQLPP11_PREPARED_SELECT_H
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
@@ -60,6 +60,6 @@ namespace sqlpp
     _dynamic_names_t _dynamic_names;
     mutable _prepared_statement_t _prepared_statement;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/prepared_update.h b/include/sqlpp11/prepared_update.h
index a5855d1b..885e8056 100644
--- a/include/sqlpp11/prepared_update.h
+++ b/include/sqlpp11/prepared_update.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_PREPARED_UPDATE_H
-#define SQLPP_PREPARED_UPDATE_H
+#ifndef SQLPP11_PREPARED_UPDATE_H
+#define SQLPP11_PREPARED_UPDATE_H
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
@@ -57,6 +57,6 @@ namespace sqlpp
     _parameter_list_t params;
     mutable _prepared_statement_t _prepared_statement;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/remove.h b/include/sqlpp11/remove.h
index fe63205e..44bd1c52 100644
--- a/include/sqlpp11/remove.h
+++ b/include/sqlpp11/remove.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_REMOVE_H
-#define SQLPP_REMOVE_H
+#ifndef SQLPP11_REMOVE_H
+#define SQLPP11_REMOVE_H
 
 #include <sqlpp11/statement.h>
 #include <sqlpp11/connection.h>
@@ -93,7 +93,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = remove_name_t;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << "DELETE";
 
@@ -106,7 +106,7 @@ namespace sqlpp
 
   inline auto remove() -> blank_remove_t<void>
   {
-    return {blank_remove_t<void>()};
+    return {};
   }
 
   template <typename Table>
@@ -116,18 +116,18 @@ namespace sqlpp
   }
 
   template <typename Database>
-  auto dynamic_remove(const Database&) -> decltype(blank_remove_t<Database>())
+  auto dynamic_remove(const Database & /*unused*/) -> decltype(blank_remove_t<Database>())
   {
     static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
     return {blank_remove_t<Database>()};
   }
 
   template <typename Database, typename Table>
-  auto dynamic_remove_from(const Database&, Table table) -> decltype(blank_remove_t<Database>().from(table))
+  auto dynamic_remove_from(const Database& /*unused*/, Table table) -> decltype(blank_remove_t<Database>().from(table))
   {
     static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
     return {blank_remove_t<Database>().from(table)};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/result.h b/include/sqlpp11/result.h
index b93cd84c..109cdfed 100644
--- a/include/sqlpp11/result.h
+++ b/include/sqlpp11/result.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_RESULT_H
-#define SQLPP_RESULT_H
+#ifndef SQLPP11_RESULT_H
+#define SQLPP11_RESULT_H
 
 #include <iterator>
 #include <utility>
@@ -140,6 +140,6 @@ namespace sqlpp
       _result.next(_result_row);
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/result_field.h b/include/sqlpp11/result_field.h
index f7ad360b..66b2d90a 100644
--- a/include/sqlpp11/result_field.h
+++ b/include/sqlpp11/result_field.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_RESULT_FIELD_H
-#define SQLPP_RESULT_FIELD_H
+#ifndef SQLPP11_RESULT_FIELD_H
+#define SQLPP11_RESULT_FIELD_H
 
 #include <ostream>
 #include <sqlpp11/wrong.h>
@@ -66,5 +66,5 @@ namespace sqlpp
   {
     return serialize(rf, os);
   }
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/result_field_base.h b/include/sqlpp11/result_field_base.h
index 3f6d3992..10f517f0 100644
--- a/include/sqlpp11/result_field_base.h
+++ b/include/sqlpp11/result_field_base.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_RESULT_FIELD_BASE_H
-#define SQLPP_RESULT_FIELD_BASE_H
+#ifndef SQLPP11_RESULT_FIELD_BASE_H
+#define SQLPP11_RESULT_FIELD_BASE_H
 
 #include <sqlpp11/alias_operators.h>
 #include <sqlpp11/basic_expression_operators.h>
@@ -87,14 +87,18 @@ namespace sqlpp
     bool is_null() const
     {
       if (not _is_valid)
+      {
         throw exception("accessing is_null in non-existing row");
+      }
       return _is_null;
     }
 
     bool _is_trivial() const
     {
       if (not _is_valid)
+      {
         throw exception("accessing is_null in non-existing row");
+      }
 
       return value() == _cpp_storage_type{};
     }
@@ -102,7 +106,9 @@ namespace sqlpp
     _cpp_value_type value() const
     {
       if (not _is_valid)
+      {
         throw exception("accessing value in non-existing row");
+      }
 
       if (_is_null)
       {
@@ -129,5 +135,5 @@ namespace sqlpp
     bool _is_null;
     _cpp_storage_type _value;
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/result_row.h b/include/sqlpp11/result_row.h
index 8c620322..65f5d103 100644
--- a/include/sqlpp11/result_row.h
+++ b/include/sqlpp11/result_row.h
@@ -24,10 +24,11 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_RESULT_ROW_H
-#define SQLPP_RESULT_ROW_H
+#ifndef SQLPP11_RESULT_ROW_H
+#define SQLPP11_RESULT_ROW_H
 
 #include <map>
+#include <utility>
 #include <sqlpp11/data_types/text.h>
 #include <sqlpp11/detail/field_index_sequence.h>
 #include <sqlpp11/dynamic_select_column_list.h>
@@ -176,7 +177,7 @@ namespace sqlpp
         (void)swallow{(result_field<Db, Is, FieldSpecs>::_apply(callable), 0)...};
       }
     };
-  }
+  }  // namespace detail
 
   template <typename Db, typename... FieldSpecs>
   struct result_row_t
@@ -184,13 +185,13 @@ namespace sqlpp
   {
     using _field_index_sequence = detail::make_field_index_sequence<0, FieldSpecs...>;
     using _impl = detail::result_row_impl<Db, _field_index_sequence, FieldSpecs...>;
-    bool _is_valid;
+    bool _is_valid{false};
 
-    result_row_t() : _impl(), _is_valid(false)
+    result_row_t() : _impl()
     {
     }
 
-    result_row_t(const typename dynamic_select_column_list<void>::_names_t&) : _impl(), _is_valid(false)
+    result_row_t(const typename dynamic_select_column_list<void>::_names_t& /*unused*/) : _impl()
     {
     }
 
@@ -273,16 +274,16 @@ namespace sqlpp
     using _impl = detail::result_row_impl<Db, _field_index_sequence, FieldSpecs...>;
     using _field_type = result_field_t<Db, field_spec_t<no_name_t, text, true, true>>;
 
-    bool _is_valid;
+    bool _is_valid{false};
     std::vector<std::string> _dynamic_field_names;
     std::map<std::string, _field_type> _dynamic_fields;
 
-    dynamic_result_row_t() : _impl(), _is_valid(false)
+    dynamic_result_row_t() : _impl()
     {
     }
 
-    dynamic_result_row_t(const std::vector<std::string>& dynamic_field_names)
-        : _impl(), _is_valid(false), _dynamic_field_names(dynamic_field_names)
+    dynamic_result_row_t(std::vector<std::string> dynamic_field_names)
+        : _impl(), _dynamic_field_names(std::move(dynamic_field_names))
     {
       for (auto field_name : _dynamic_field_names)
       {
@@ -409,6 +410,6 @@ namespace sqlpp
   {
     row._apply(callable);
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/result_row_fwd.h b/include/sqlpp11/result_row_fwd.h
index 6bd38e2c..3562ad9f 100644
--- a/include/sqlpp11/result_row_fwd.h
+++ b/include/sqlpp11/result_row_fwd.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_RESULT_ROW_FWD_H
-#define SQLPP_RESULT_ROW_FWD_H
+#ifndef SQLPP11_RESULT_ROW_FWD_H
+#define SQLPP11_RESULT_ROW_FWD_H
 
 namespace sqlpp
 {
@@ -34,6 +34,6 @@ namespace sqlpp
 
   template <typename Db, typename... FieldSpecs>
   struct dynamic_result_row_t;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/rhs_wrap.h b/include/sqlpp11/rhs_wrap.h
index 4e136afe..4d8ccb91 100644
--- a/include/sqlpp11/rhs_wrap.h
+++ b/include/sqlpp11/rhs_wrap.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_RHS_WRAP_H
-#define SQLPP_RHS_WRAP_H
+#ifndef SQLPP11_RHS_WRAP_H
+#define SQLPP11_RHS_WRAP_H
 
 #include <sqlpp11/default_value.h>
 #include <sqlpp11/null.h>
@@ -38,7 +38,7 @@ namespace sqlpp
     template <typename Expr, typename Enable = void>
     struct rhs_is_trivial_t
     {
-      static constexpr bool _(const Expr&)
+      static constexpr bool _(const Expr& /*unused*/)
       {
         return false;
       }
@@ -71,24 +71,20 @@ namespace sqlpp
         {
           return t.is_null();
         }
-        else
+
+        if (t.is_null())
         {
-          if (t.is_null())
-          {
-            return false;
-          }
-          else
-          {
-            return t._is_trivial();
-          }
+          return false;
         }
+
+        return t._is_trivial();
       }
     };
 
     template <typename Expr, typename Enable = void>
     struct rhs_is_null_t
     {
-      static constexpr bool _(const Expr&)
+      static constexpr bool _(const Expr& /*unused*/)
       {
         return false;
       }
@@ -111,7 +107,7 @@ namespace sqlpp
         return t.is_null();
       }
     };
-  }
+  }  // namespace detail
 
   template <typename Expr, bool TrivialValueIsNull>
   struct rhs_wrap_t
@@ -165,6 +161,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/schema.h b/include/sqlpp11/schema.h
index 4730817b..c5a94af1 100644
--- a/include/sqlpp11/schema.h
+++ b/include/sqlpp11/schema.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SCHEMA_H
-#define SQLPP_SCHEMA_H
+#ifndef SQLPP11_SCHEMA_H
+#define SQLPP11_SCHEMA_H
 
 #include <string>
 
@@ -51,6 +51,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/schema_qualified_table.h b/include/sqlpp11/schema_qualified_table.h
index 15563113..69f98036 100644
--- a/include/sqlpp11/schema_qualified_table.h
+++ b/include/sqlpp11/schema_qualified_table.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SCHEMA_QUALIFIED_TABLE_H
-#define SQLPP_SCHEMA_QUALIFIED_TABLE_H
+#ifndef SQLPP11_SCHEMA_QUALIFIED_TABLE_H
+#define SQLPP11_SCHEMA_QUALIFIED_TABLE_H
 
 #include <sqlpp11/column_fwd.h>
 #include <sqlpp11/interpret.h>
@@ -34,6 +34,8 @@
 #include <sqlpp11/table_alias.h>
 #include <sqlpp11/detail/type_set.h>
 
+#include <utility>
+
 namespace sqlpp
 {
   template <typename Table>
@@ -45,13 +47,13 @@ namespace sqlpp
     using _required_ctes = detail::type_set<>;
     using _provided_tables = detail::type_set<>;
 
-    schema_qualified_table_t(schema_t schema, Table table) : _schema(schema), _table(table)
+    schema_qualified_table_t(schema_t schema, Table table) : _schema(std::move(schema)), _table(table)
     {
     }
 
     template <typename AliasProvider>
     typename Table::template _foreign_table_alias_t<AliasProvider, schema_qualified_table_t> as(
-        const AliasProvider&) const
+        const AliasProvider& /*unused*/) const
     {
       return {*this};
     }
@@ -87,6 +89,6 @@ namespace sqlpp
 
     return {schema, table};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/select.h b/include/sqlpp11/select.h
index 0a1b301f..c375efc2 100644
--- a/include/sqlpp11/select.h
+++ b/include/sqlpp11/select.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SELECT_H
-#define SQLPP_SELECT_H
+#ifndef SQLPP11_SELECT_H
+#define SQLPP11_SELECT_H
 
 #include <sqlpp11/statement.h>
 
@@ -62,7 +62,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = select_name_t;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << "SELECT ";
 
@@ -98,17 +98,18 @@ namespace sqlpp
   }
 
   template <typename Database>
-  blank_select_t<Database> dynamic_select(const Database&)
+  blank_select_t<Database> dynamic_select(const Database& /*unused*/)
   {
     static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
     return {};
   }
 
   template <typename Database, typename... Columns>
-  auto dynamic_select(const Database&, Columns... columns) -> decltype(blank_select_t<Database>().columns(columns...))
+  auto dynamic_select(const Database& /*unused*/, Columns... columns)
+      -> decltype(blank_select_t<Database>().columns(columns...))
   {
     static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
     return blank_select_t<Database>().columns(columns...);
   }
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/select_column_list.h b/include/sqlpp11/select_column_list.h
index ae29d52f..2f87a770 100644
--- a/include/sqlpp11/select_column_list.h
+++ b/include/sqlpp11/select_column_list.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SELECT_COLUMN_LIST_H
-#define SQLPP_SELECT_COLUMN_LIST_H
+#ifndef SQLPP11_SELECT_COLUMN_LIST_H
+#define SQLPP11_SELECT_COLUMN_LIST_H
 
 #include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/detail/copy_tuple_args.h>
@@ -64,7 +64,7 @@ namespace sqlpp
                                   tag::is_selectable>;
       using _alias_t = typename Column::_alias_t;
     };
-  }
+  }  // namespace detail
 
   // SELECTED COLUMNS DATA
   template <typename Database, typename... Columns>
@@ -145,7 +145,7 @@ namespace sqlpp
 
       // private:
       template <typename NamedExpression>
-      void _add_impl(NamedExpression namedExpression, const std::true_type&)
+      void _add_impl(NamedExpression namedExpression, const std::true_type& /*unused*/)
       {
         return _data._dynamic_columns.emplace_back(auto_alias_t<NamedExpression>{namedExpression});
       }
@@ -299,7 +299,7 @@ namespace sqlpp
     template <typename Database, typename... Columns>
     using make_select_column_list_t =
         copy_tuple_args_t<select_column_list_t, Database, decltype(column_tuple_merge(std::declval<Columns>()...))>;
-  }
+  }  // namespace detail
 
   SQLPP_PORTABLE_STATIC_ASSERT(assert_selected_colums_are_selectable_t, "selected columns must be selectable");
   template <typename... T>
@@ -368,7 +368,7 @@ namespace sqlpp
       using _database_t = typename Policies::_database_t;
 
       template <typename... T>
-      static constexpr auto _check_tuple(std::tuple<T...>) -> check_selected_columns_t<T...>
+      static constexpr auto _check_tuple(std::tuple<T...> /*unused*/) -> check_selected_columns_t<T...>
       {
         return {};
       }
@@ -412,7 +412,7 @@ namespace sqlpp
       auto _columns_impl(Check, std::tuple<Args...> args) const -> inconsistent<Check>;
 
       template <typename Database, typename... Args>
-      auto _columns_impl(consistent_t, std::tuple<Args...> args) const
+      auto _columns_impl(consistent_t /*unused*/, std::tuple<Args...> args) const
           -> _new_statement_t<consistent_t, select_column_list_t<Database, Args...>>
       {
         static_assert(not detail::has_duplicates<Args...>::value, "at least one duplicate argument detected");
@@ -436,7 +436,9 @@ namespace sqlpp
     {
       interpret_tuple(t._columns, ',', context);
       if (sizeof...(Columns) and not t._dynamic_columns.empty())
+      {
         context << ',';
+      }
       serialize(t._dynamic_columns, context);
       return context;
     }
@@ -449,11 +451,11 @@ namespace sqlpp
   }
 
   template <typename Database, typename... T>
-  auto dynamic_select_columns(const Database&, T&&... t)
+  auto dynamic_select_columns(const Database& /*unused*/, T&&... t)
       -> decltype(statement_t<Database, no_select_column_list_t>().dynamic_columns(std::forward<T>(t)...))
   {
     return statement_t<Database, no_select_column_list_t>().dynamic_columns(std::forward<T>(t)...);
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/select_flag_list.h b/include/sqlpp11/select_flag_list.h
index a1caa8df..92ec5ba1 100644
--- a/include/sqlpp11/select_flag_list.h
+++ b/include/sqlpp11/select_flag_list.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SELECT_FLAG_LIST_H
-#define SQLPP_SELECT_FLAG_LIST_H
+#ifndef SQLPP11_SELECT_FLAG_LIST_H
+#define SQLPP11_SELECT_FLAG_LIST_H
 
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/interpret_tuple.h>
@@ -94,7 +94,7 @@ namespace sqlpp
 
     private:
       template <typename Flag>
-      void _add_impl(Flag flag, const std::true_type&)
+      void _add_impl(Flag flag, const std::true_type& /*unused*/)
       {
         return _data._dynamic_flags.emplace_back(flag);
       }
@@ -226,7 +226,7 @@ namespace sqlpp
       auto _flags_impl(Check, Flags... flgs) const -> inconsistent<Check>;
 
       template <typename Database, typename... Flags>
-      auto _flags_impl(consistent_t, Flags... flgs) const
+      auto _flags_impl(consistent_t /*unused*/, Flags... flgs) const
           -> _new_statement_t<consistent_t, select_flag_list_t<Database, Flags...>>
       {
         static_assert(not detail::has_duplicates<Flags...>::value,
@@ -248,11 +248,15 @@ namespace sqlpp
     static Context& _(const T& t, Context& context)
     {
       interpret_tuple(t._flags, ' ', context);
-      if (sizeof...(Flags))
+      if (sizeof...(Flags) != 0u)
+      {
         context << ' ';
+      }
       interpret_list(t._dynamic_flags, ',', context);
       if (not t._dynamic_flags.empty())
+      {
         context << ' ';
+      }
       return context;
     }
   };
@@ -264,11 +268,11 @@ namespace sqlpp
   }
 
   template <typename Database, typename T>
-  auto dynamic_select_flags(const Database&, T&& t)
+  auto dynamic_select_flags(const Database& /*unused*/, T&& t)
       -> decltype(statement_t<Database, no_select_flag_list_t>().dynamic_flags(std::forward<T>(t)))
   {
     return statement_t<Database, no_select_flag_list_t>().dynamic_flags(std::forward<T>(t));
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/select_flags.h b/include/sqlpp11/select_flags.h
index b3606e00..52616b1a 100644
--- a/include/sqlpp11/select_flags.h
+++ b/include/sqlpp11/select_flags.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SELECT_FLAGS_H
-#define SQLPP_SELECT_FLAGS_H
+#ifndef SQLPP11_SELECT_FLAGS_H
+#define SQLPP11_SELECT_FLAGS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/detail/type_set.h>
@@ -47,7 +47,7 @@ namespace sqlpp
   {
     using _serialize_check = consistent_t;
 
-    static Context& _(const all_t&, Context& context)
+    static Context& _(const all_t& /*unused*/, Context& context)
     {
       context << "ALL";
       return context;
@@ -66,7 +66,7 @@ namespace sqlpp
   {
     using _serialize_check = consistent_t;
 
-    static Context& _(const distinct_t&, Context& context)
+    static Context& _(const distinct_t& /*unused*/, Context& context)
     {
       context << "DISTINCT";
       return context;
@@ -85,12 +85,12 @@ namespace sqlpp
   {
     using _serialize_check = consistent_t;
 
-    static Context& _(const straight_join_t&, Context& context)
+    static Context& _(const straight_join_t& /*unused*/, Context& context)
     {
       context << "STRAIGHT_JOIN";
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/select_pseudo_table.h b/include/sqlpp11/select_pseudo_table.h
index 321df845..d0128c11 100644
--- a/include/sqlpp11/select_pseudo_table.h
+++ b/include/sqlpp11/select_pseudo_table.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SELECT_PSEUDO_TABLE_H
-#define SQLPP_SELECT_PSEUDO_TABLE_H
+#ifndef SQLPP11_SELECT_PSEUDO_TABLE_H
+#define SQLPP11_SELECT_PSEUDO_TABLE_H
 
 #include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/table.h>
@@ -86,6 +86,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/serialize.h b/include/sqlpp11/serialize.h
index e572eeeb..0d12217a 100644
--- a/include/sqlpp11/serialize.h
+++ b/include/sqlpp11/serialize.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SERIALIZE_H
-#define SQLPP_SERIALIZE_H
+#ifndef SQLPP11_SERIALIZE_H
+#define SQLPP11_SERIALIZE_H
 
 #include <sqlpp11/serializer.h>
 #include <sqlpp11/type_traits.h>
@@ -48,10 +48,12 @@ namespace sqlpp
       context << ')';
     }
     else
+    {
       serializer_t<Context, T>::_(t, context);
+    }
 
     return context;
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/serializer.h b/include/sqlpp11/serializer.h
index 301d95af..2adcfb98 100644
--- a/include/sqlpp11/serializer.h
+++ b/include/sqlpp11/serializer.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SERIALIZER_H
-#define SQLPP_SERIALIZER_H
+#ifndef SQLPP11_SERIALIZER_H
+#define SQLPP11_SERIALIZER_H
 
 #include <sqlpp11/portable_static_assert.h>
 #include <sqlpp11/wrong.h>
@@ -39,11 +39,11 @@ namespace sqlpp
   {
     using _serialize_check = assert_serializer_specialization_t;
 
-    static void _(const T&, Context&)
+    static void _(const T& /*unused*/, Context& /*unused*/)
     {
       _serialize_check{};
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/serializer_context.h b/include/sqlpp11/serializer_context.h
index fa646553..3a79cad3 100644
--- a/include/sqlpp11/serializer_context.h
+++ b/include/sqlpp11/serializer_context.h
@@ -23,8 +23,8 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SERIALIZER_CONTEXT_H
-#define SQLPP_SERIALIZER_CONTEXT_H
+#ifndef SQLPP11_SERIALIZER_CONTEXT_H
+#define SQLPP11_SERIALIZER_CONTEXT_H
 
 #include <ostream>
 
@@ -50,17 +50,19 @@ namespace sqlpp
         for (const auto c : arg)
         {
           if (c == '\'')
+          {
             retVal.push_back(c);
+          }
           retVal.push_back(c);
         }
         return retVal;
       }
-      else
-        return arg;
+
+      return arg;
     }
 
     std::ostream& _os;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/simple_column.h b/include/sqlpp11/simple_column.h
index 33cfdd6a..a413d327 100644
--- a/include/sqlpp11/simple_column.h
+++ b/include/sqlpp11/simple_column.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SIMPLE_COLUMN_H
-#define SQLPP_SIMPLE_COLUMN_H
+#ifndef SQLPP11_SIMPLE_COLUMN_H
+#define SQLPP11_SIMPLE_COLUMN_H
 
 #include <sqlpp11/serializer.h>
 #include <sqlpp11/type_traits.h>
@@ -54,7 +54,7 @@ namespace sqlpp
     using _serialize_check = serialize_check_of<Context, Column>;
     using T = simple_column_t<Column>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << name_of<typename T::_column_t>::char_ptr();
       return context;
@@ -66,6 +66,6 @@ namespace sqlpp
   {
     return {c};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/single_table.h b/include/sqlpp11/single_table.h
index 93881f88..34c3b5b3 100644
--- a/include/sqlpp11/single_table.h
+++ b/include/sqlpp11/single_table.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SINGLE_TABLE_H
-#define SQLPP_SINGLE_TABLE_H
+#ifndef SQLPP11_SINGLE_TABLE_H
+#define SQLPP11_SINGLE_TABLE_H
 
 #include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/detail/type_set.h>
@@ -179,7 +179,7 @@ namespace sqlpp
       auto _single_table_impl(Check, Table table) const -> inconsistent<Check>;
 
       template <typename Database, typename Table>
-      auto _single_table_impl(consistent_t, Table table) const
+      auto _single_table_impl(consistent_t /*unused*/, Table table) const
           -> _new_statement_t<consistent_t, single_table_t<Database, Table>>
       {
         static_assert(required_tables_of<single_table_t<Database, Table>>::size::value == 0,
@@ -203,6 +203,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/some.h b/include/sqlpp11/some.h
index d33a2f20..2c0ced17 100644
--- a/include/sqlpp11/some.h
+++ b/include/sqlpp11/some.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SOME_H
-#define SQLPP_SOME_H
+#ifndef SQLPP11_SOME_H
+#define SQLPP11_SOME_H
 
 #include <sqlpp11/data_types/boolean.h>
 #include <sqlpp11/detail/type_set.h>
@@ -76,6 +76,6 @@ namespace sqlpp
                   "some() requires a single column select expression as argument");
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/sort_order.h b/include/sqlpp11/sort_order.h
index 4ef59e5e..538fc3fe 100644
--- a/include/sqlpp11/sort_order.h
+++ b/include/sqlpp11/sort_order.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_SORT_ORDER_H
-#define SQLPP_SORT_ORDER_H
+#ifndef SQLPP11_SORT_ORDER_H
+#define SQLPP11_SORT_ORDER_H
 
 #include <sqlpp11/detail/type_set.h>
 
@@ -70,6 +70,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/sqlpp11.h b/include/sqlpp11/sqlpp11.h
index 722a1bcc..19fe7244 100644
--- a/include/sqlpp11/sqlpp11.h
+++ b/include/sqlpp11/sqlpp11.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_H
-#define SQLPP_H
+#ifndef SQLPP11_SQLPP11_H
+#define SQLPP11_SQLPP11_H
 
 #include <sqlpp11/alias_provider.h>
 #include <sqlpp11/data_types.h>
diff --git a/include/sqlpp11/statement.h b/include/sqlpp11/statement.h
index f3fccf49..8cc4396b 100644
--- a/include/sqlpp11/statement.h
+++ b/include/sqlpp11/statement.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_STATEMENT_H
-#define SQLPP_STATEMENT_H
+#ifndef SQLPP11_STATEMENT_H
+#define SQLPP11_STATEMENT_H
 
 #include <sqlpp11/noop.h>
 #include <sqlpp11/parameter_list.h>
@@ -150,7 +150,7 @@ namespace sqlpp
       using _parameter_check = typename std::
           conditional<detail::type_vector_size<_parameters>::value == 0, consistent_t, assert_no_parameters_t>::type;
     };
-  }
+  }  // namespace detail
 
   template <typename Db, typename... Policies>
   struct statement_t : public Policies::template _base_t<detail::statement_policies_t<Db, Policies...>>...,
@@ -197,9 +197,7 @@ namespace sqlpp
     using _alias_t = typename _result_type_provider::_alias_t;
 
     // Constructors
-    statement_t()
-    {
-    }
+    statement_t() = default;
 
     // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
     //	template <typename Statement, typename Term>
@@ -321,6 +319,6 @@ namespace sqlpp
       using _consistency_check = consistent_t;
     };
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/statement_fwd.h b/include/sqlpp11/statement_fwd.h
index f6a3341d..c626dba9 100644
--- a/include/sqlpp11/statement_fwd.h
+++ b/include/sqlpp11/statement_fwd.h
@@ -24,13 +24,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_STATEMENT_FWD_H
-#define SQLPP_STATEMENT_FWD_H
+#ifndef SQLPP11_STATEMENT_FWD_H
+#define SQLPP11_STATEMENT_FWD_H
 
 namespace sqlpp
 {
   template <typename Db, typename... Policies>
   struct statement_t;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/table.h b/include/sqlpp11/table.h
index 7e51f22d..e655c29a 100644
--- a/include/sqlpp11/table.h
+++ b/include/sqlpp11/table.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TABLE_H
-#define SQLPP_TABLE_H
+#ifndef SQLPP11_TABLE_H
+#define SQLPP11_TABLE_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/table_alias.h>
@@ -92,7 +92,7 @@ namespace sqlpp
     }
 
     template <typename AliasProvider>
-    _alias_t<AliasProvider> as(const AliasProvider&) const
+    _alias_t<AliasProvider> as(const AliasProvider& /*unused*/) const
     {
       return {*static_cast<const Table*>(this)};
     }
@@ -118,12 +118,12 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = X;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << name_of<T>::char_ptr();
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/table_alias.h b/include/sqlpp11/table_alias.h
index ae534463..633fda79 100644
--- a/include/sqlpp11/table_alias.h
+++ b/include/sqlpp11/table_alias.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TABLE_ALIAS_H
-#define SQLPP_TABLE_ALIAS_H
+#ifndef SQLPP11_TABLE_ALIAS_H
+#define SQLPP11_TABLE_ALIAS_H
 
 #include <sqlpp11/alias.h>
 #include <sqlpp11/column_fwd.h>
@@ -108,14 +108,18 @@ namespace sqlpp
     static Context& _(const T& t, Context& context)
     {
       if (requires_braces_t<Table>::value)
+      {
         context << "(";
+      }
       serialize(t._table, context);
       if (requires_braces_t<Table>::value)
+      {
         context << ")";
+      }
       context << " AS " << name_of<T>::char_ptr();
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/table_ref.h b/include/sqlpp11/table_ref.h
index e10d55c0..8a0c32a1 100644
--- a/include/sqlpp11/table_ref.h
+++ b/include/sqlpp11/table_ref.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TABLE_REF_H
-#define SQLPP_TABLE_REF_H
+#ifndef SQLPP11_TABLE_REF_H
+#define SQLPP11_TABLE_REF_H
 
 #include <utility>
 
@@ -50,6 +50,6 @@ namespace sqlpp
   {
     return t;
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/transaction.h b/include/sqlpp11/transaction.h
index 0d2a16be..8ceaf7e0 100644
--- a/include/sqlpp11/transaction.h
+++ b/include/sqlpp11/transaction.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TRANSACTION_H
-#define SQLPP_TRANSACTION_H
+#ifndef SQLPP11_TRANSACTION_H
+#define SQLPP11_TRANSACTION_H
 
 #include <stdexcept>
 #include <ciso646>
@@ -35,12 +35,13 @@ namespace sqlpp
   static constexpr bool quiet_auto_rollback = false;
   static constexpr bool report_auto_rollback = true;
 
-  enum class isolation_level {
-      undefined,            // use the current database default
-      serializable,         // highest level, stronguest guarantee
-      repeatable_read,      // DBMS holds read and write locks
-      read_committed,       // DMBS holds read locks, non-repeatable reads can occur
-      read_uncommitted      // lowest isolation level, dirty reads may occur
+  enum class isolation_level
+  {
+    undefined,        // use the current database default
+    serializable,     // highest level, stronguest guarantee
+    repeatable_read,  // DBMS holds read and write locks
+    read_committed,   // DMBS holds read locks, non-repeatable reads can occur
+    read_uncommitted  // lowest isolation level, dirty reads may occur
   };
 
   template <typename Db>
@@ -103,14 +104,16 @@ namespace sqlpp
   template <typename Db>
   transaction_t<Db> start_transaction(Db& db, bool report_unfinished_transaction = report_auto_rollback)
   {
-      return {db, report_unfinished_transaction};
+    return {db, report_unfinished_transaction};
   }
 
   template <typename Db>
-  transaction_t<Db> start_transaction(Db& db, isolation_level isolation, bool report_unfinished_transaction = report_auto_rollback)
+  transaction_t<Db> start_transaction(Db& db,
+                                      isolation_level isolation,
+                                      bool report_unfinished_transaction = report_auto_rollback)
   {
     return {db, report_unfinished_transaction, isolation};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/tvin.h b/include/sqlpp11/tvin.h
index efe0f2b1..3e62ac95 100644
--- a/include/sqlpp11/tvin.h
+++ b/include/sqlpp11/tvin.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TVIN_H
-#define SQLPP_TVIN_H
+#ifndef SQLPP11_TVIN_H
+#define SQLPP11_TVIN_H
 
 // TVIN: Trivial value is NULL
 
@@ -65,7 +65,7 @@ namespace sqlpp
     using _serialize_check = assert_tvin_with_correct_operator_t;
     using T = tvin_arg_t<Operand>;
 
-    static Context& _(const T&, Context&)
+    static Context& _(const T& /*unused*/, Context& /*unused*/)
     {
       _serialize_check{};
     }
@@ -86,7 +86,7 @@ namespace sqlpp
     {
       using type = tvin_t<T>;
     };
-  }
+  }  // namespace detail
   template <typename T>
   using allow_tvin_t = typename detail::allow_tvin_impl<T>::type;
 
@@ -132,7 +132,7 @@ namespace sqlpp
     {
       using type = std::true_type;
     };
-  }
+  }  // namespace detail
   template <typename T>
   using is_tvin_t = typename detail::is_tvin_impl<T>::type;
 
@@ -164,6 +164,6 @@ namespace sqlpp
                   "tvin() used with invalid type (only string and primitive types allowed)");
     return {{operand}};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/type_traits.h b/include/sqlpp11/type_traits.h
index 427308c6..4f0a2051 100644
--- a/include/sqlpp11/type_traits.h
+++ b/include/sqlpp11/type_traits.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_TYPE_TRAITS_H
-#define SQLPP_TYPE_TRAITS_H
+#ifndef SQLPP11_TYPE_TRAITS_H
+#define SQLPP11_TYPE_TRAITS_H
 
 #include <type_traits>
 #include <tuple>
@@ -52,7 +52,7 @@ namespace sqlpp
     {
       using type = typename T::_traits::_value_type;
     };
-  }
+  }  // namespace detail
   template <typename T>
   using value_type_of = typename detail::value_type_of_impl<T>::type;
 
@@ -112,7 +112,7 @@ namespace sqlpp
     struct can_be_null
     {
     };
-  }
+  }  // namespace tag
 
   namespace detail
   {
@@ -128,7 +128,7 @@ namespace sqlpp
     {
       using type = std::true_type;
     };
-  }
+  }  // namespace detail
   template <typename T>
   using column_spec_can_be_null_t = typename detail::column_spec_can_be_null_impl<T>::type;
 
@@ -241,7 +241,7 @@ namespace sqlpp
     {
       using type = typename T::_nodes;
     };
-  }
+  }  // namespace detail
   template <typename T>
   using nodes_of = typename detail::nodes_of_impl<T>::type;
 
@@ -336,7 +336,7 @@ namespace sqlpp
       using type =
           logic::all_t<sizeof...(Nodes) != 0, is_aggregate_expression_impl<KnownAggregates, Nodes>::type::value...>;
     };
-  }
+  }  // namespace detail
   template <typename KnownAggregates, typename T>
   using is_aggregate_expression_t = typename detail::is_aggregate_expression_impl<KnownAggregates, T>::type;
 
@@ -357,7 +357,7 @@ namespace sqlpp
     {
       using type = detail::type_vector_cat_t<typename parameters_of_impl<Nodes>::type...>;
     };
-  }
+  }  // namespace detail
   template <typename T>
   using parameters_of = typename detail::parameters_of_impl<T>::type;
 
@@ -534,6 +534,6 @@ namespace sqlpp
 
   template <typename Db>
   using serializer_context_of = typename serializer_context_of_impl<Db>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/unconditional.h b/include/sqlpp11/unconditional.h
index ac4d9349..4d48b573 100644
--- a/include/sqlpp11/unconditional.h
+++ b/include/sqlpp11/unconditional.h
@@ -24,13 +24,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNCONDITIONAL_H
-#define SQLPP_UNCONDITIONAL_H
+#ifndef SQLPP11_UNCONDITIONAL_H
+#define SQLPP11_UNCONDITIONAL_H
 
 namespace sqlpp
 {
   struct unconditional_t
   {
   };
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/union.h b/include/sqlpp11/union.h
index dd15400d..048435b5 100644
--- a/include/sqlpp11/union.h
+++ b/include/sqlpp11/union.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNION_H
-#define SQLPP_UNION_H
+#ifndef SQLPP11_UNION_H
+#define SQLPP11_UNION_H
 
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
@@ -244,7 +244,7 @@ namespace sqlpp
       auto _union_impl(Check, Rhs rhs) const -> inconsistent<Check>;
 
       template <typename Database, typename Flag, typename Rhs>
-      auto _union_impl(consistent_t, Rhs rhs) const
+      auto _union_impl(consistent_t /*unused*/, Rhs rhs) const
           -> _new_statement_t<consistent_t, union_t<Database, Flag, derived_statement_t<Policies>, Rhs>>
       {
         return {blank_union_t{}, union_data_t<Database, Flag, derived_statement_t<Policies>, Rhs>{
@@ -266,6 +266,6 @@ namespace sqlpp
     return statement_t<void, no_union_t>().union_distinct(std::forward<T>(t));
   }
   */
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/union_data.h b/include/sqlpp11/union_data.h
index 8e3e34bc..6f426568 100644
--- a/include/sqlpp11/union_data.h
+++ b/include/sqlpp11/union_data.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNION_DATA_H
-#define SQLPP_UNION_DATA_H
+#ifndef SQLPP11_UNION_DATA_H
+#define SQLPP11_UNION_DATA_H
 
 #include <sqlpp11/serializer.h>
 
@@ -65,6 +65,6 @@ namespace sqlpp
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/union_flags.h b/include/sqlpp11/union_flags.h
index 434535a1..8649f645 100644
--- a/include/sqlpp11/union_flags.h
+++ b/include/sqlpp11/union_flags.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UNION_FLAGS_H
-#define SQLPP_UNION_FLAGS_H
+#ifndef SQLPP11_UNION_FLAGS_H
+#define SQLPP11_UNION_FLAGS_H
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/detail/type_set.h>
@@ -46,7 +46,7 @@ namespace sqlpp
   {
     using _serialize_check = consistent_t;
 
-    static Context& _(const union_all_t&, Context& context)
+    static Context& _(const union_all_t& /*unused*/, Context& context)
     {
       context << "ALL";
       return context;
@@ -64,11 +64,11 @@ namespace sqlpp
   {
     using _serialize_check = consistent_t;
 
-    static Context& _(const union_distinct_t&, Context& context)
+    static Context& _(const union_distinct_t& /*unused*/, Context& context)
     {
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/update.h b/include/sqlpp11/update.h
index 85991153..8bb639b4 100644
--- a/include/sqlpp11/update.h
+++ b/include/sqlpp11/update.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UPDATE_H
-#define SQLPP_UPDATE_H
+#ifndef SQLPP11_UPDATE_H
+#define SQLPP11_UPDATE_H
 
 #include <sqlpp11/statement.h>
 #include <sqlpp11/connection.h>
@@ -94,7 +94,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = update_name_t;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       context << "UPDATE ";
 
@@ -112,12 +112,12 @@ namespace sqlpp
   }
 
   template <typename Database, typename Table>
-  constexpr auto dynamic_update(const Database&, Table table)
+  constexpr auto dynamic_update(const Database& /*unused*/, Table table)
       -> decltype(blank_update_t<Database>().single_table(table))
   {
     static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
     return {blank_update_t<Database>().single_table(table)};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/update_list.h b/include/sqlpp11/update_list.h
index a95f434c..b9b986f2 100644
--- a/include/sqlpp11/update_list.h
+++ b/include/sqlpp11/update_list.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_UPDATE_LIST_H
-#define SQLPP_UPDATE_LIST_H
+#ifndef SQLPP11_UPDATE_LIST_H
+#define SQLPP11_UPDATE_LIST_H
 
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/interpret_tuple.h>
@@ -98,7 +98,7 @@ namespace sqlpp
 
     private:
       template <typename Assignment>
-      void _add_impl(Assignment assignment, const std::true_type&)
+      void _add_impl(Assignment assignment, const std::true_type& /*unused*/)
       {
         return _data._dynamic_assignments.emplace_back(assignment);
       }
@@ -162,7 +162,7 @@ namespace sqlpp
     {
       static constexpr auto value = detail::must_not_update_impl<typename lhs<Assignment>::type>::type::value;
     };
-  }
+  }  // namespace detail
 
   template <typename... Assignments>
   using check_update_set_t = static_combined_check_t<
@@ -172,10 +172,9 @@ namespace sqlpp
                      assert_update_set_no_duplicates_t>,
       static_check_t<logic::none_t<detail::lhs_must_not_update<Assignments>::value...>::value,
                      assert_update_set_allowed_t>,
-      static_check_t<
-          sizeof...(Assignments) == 0 or
-              detail::make_joined_set_t<required_tables_of<typename lhs<Assignments>::type>...>::size::value == 1,
-          assert_update_set_single_table_t>>;
+      static_check_t<sizeof...(Assignments) == 0 or detail::make_joined_set_t<required_tables_of<
+                                                        typename lhs<Assignments>::type>...>::size::value == 1,
+                     assert_update_set_single_table_t>>;
 
   template <typename... Assignments>
   struct check_update_static_set
@@ -276,7 +275,7 @@ namespace sqlpp
       auto _set_impl(Check, Assignments... assignments) const -> inconsistent<Check>;
 
       template <typename Database, typename... Assignments>
-      auto _set_impl(consistent_t, Assignments... assignments) const
+      auto _set_impl(consistent_t /*unused*/, Assignments... assignments) const
           -> _new_statement_t<consistent_t, update_list_t<Database, Assignments...>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
@@ -297,11 +296,13 @@ namespace sqlpp
       context << " SET ";
       interpret_tuple(t._assignments, ",", context);
       if (sizeof...(Assignments) and not t._dynamic_assignments.empty())
+      {
         context << ',';
+      }
       interpret_list(t._dynamic_assignments, ',', context);
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/using.h b/include/sqlpp11/using.h
index 6586f011..8d368c5c 100644
--- a/include/sqlpp11/using.h
+++ b/include/sqlpp11/using.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_USING_H
-#define SQLPP_USING_H
+#ifndef SQLPP11_USING_H
+#define SQLPP11_USING_H
 
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/interpret_tuple.h>
@@ -90,7 +90,7 @@ namespace sqlpp
 
     private:
       template <typename Table>
-      void _add_impl(Table table, const std::true_type&)
+      void _add_impl(Table table, const std::true_type& /*unused*/)
       {
         return _data._dynamic_tables.emplace_back(table);
       }
@@ -227,7 +227,7 @@ namespace sqlpp
       auto _using_impl(Check, Tables... tables) const -> inconsistent<Check>;
 
       template <typename Database, typename... Tables>
-      auto _using_impl(consistent_t, Tables... tables) const
+      auto _using_impl(consistent_t /*unused*/, Tables... tables) const
           -> _new_statement_t<consistent_t, using_t<_database_t, Tables...>>
       {
         static_assert(not detail::has_duplicates<Tables...>::value,
@@ -248,15 +248,19 @@ namespace sqlpp
     static Context& _(const T& t, Context& context)
     {
       if (sizeof...(Tables) == 0 and t._dynamic_tables.empty())
+      {
         return context;
+      }
       context << " USING ";
       interpret_tuple(t._tables, ',', context);
       if (sizeof...(Tables) and not t._dynamic_tables.empty())
+      {
         context << ',';
+      }
       interpret_list(t._dynamic_tables, ',', context);
       return context;
     }
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/value.h b/include/sqlpp11/value.h
index 0df9a34b..b2b0a24b 100644
--- a/include/sqlpp11/value.h
+++ b/include/sqlpp11/value.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_VALUE_H
-#define SQLPP_VALUE_H
+#ifndef SQLPP11_VALUE_H
+#define SQLPP11_VALUE_H
 
 #include <sqlpp11/type_traits.h>
 
@@ -38,6 +38,6 @@ namespace sqlpp
                   "value() is to be called with non-sql-type like int, or string");
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/value_or_null.h b/include/sqlpp11/value_or_null.h
index 39fd217b..0643d5ad 100644
--- a/include/sqlpp11/value_or_null.h
+++ b/include/sqlpp11/value_or_null.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_VALUE_OR_NULL_H
-#define SQLPP_VALUE_OR_NULL_H
+#ifndef SQLPP11_VALUE_OR_NULL_H
+#define SQLPP11_VALUE_OR_NULL_H
 
 #include <sqlpp11/wrap_operand.h>
 #include <sqlpp11/type_traits.h>
@@ -44,7 +44,7 @@ namespace sqlpp
     {
     }
 
-    value_or_null_t(const null_t&) : _value(), _is_null(true)
+    value_or_null_t(const null_t& /*unused*/) : _value(), _is_null(true)
     {
     }
 
@@ -67,6 +67,6 @@ namespace sqlpp
                   "value_or_null() is to be called with non-sql-type like int, or string");
     return {t};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/value_type.h b/include/sqlpp11/value_type.h
index d7c60726..86148857 100644
--- a/include/sqlpp11/value_type.h
+++ b/include/sqlpp11/value_type.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_VALUE_TYPE_H
-#define SQLPP_VALUE_TYPE_H
+#ifndef SQLPP11_VALUE_TYPE_H
+#define SQLPP11_VALUE_TYPE_H
 
 #include <type_traits>
 #include <sqlpp11/wrap_operand.h>
@@ -34,5 +34,5 @@ namespace sqlpp
 {
   template <typename T>
   using value_type_t = value_type_of<wrap_operand_t<T>>;
-}
+}  // namespace sqlpp
 #endif
diff --git a/include/sqlpp11/value_type_fwd.h b/include/sqlpp11/value_type_fwd.h
index 9c3a641b..943c354a 100644
--- a/include/sqlpp11/value_type_fwd.h
+++ b/include/sqlpp11/value_type_fwd.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_VALUE_TYPE_FWD_H
-#define SQLPP_VALUE_TYPE_FWD_H
+#ifndef SQLPP11_VALUE_TYPE_FWD_H
+#define SQLPP11_VALUE_TYPE_FWD_H
 
 #include <sqlpp11/type_traits.h>
 
@@ -51,6 +51,6 @@ namespace sqlpp
         and ValueType::template _is_valid_assignment_operand<T>::value  // the correct value type is required, of course
         ;
   };
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/verbatim.h b/include/sqlpp11/verbatim.h
index 4a25f102..92dfd655 100644
--- a/include/sqlpp11/verbatim.h
+++ b/include/sqlpp11/verbatim.h
@@ -24,13 +24,15 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_VERBATIM_H
-#define SQLPP_VERBATIM_H
+#ifndef SQLPP11_VERBATIM_H
+#define SQLPP11_VERBATIM_H
 
 #include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/serialize.h>
 
+#include <utility>
+
 namespace sqlpp
 {
   template <typename ValueType>  // Csaba Csoma suggests: unsafe_sql instead of verbatim
@@ -42,7 +44,7 @@ namespace sqlpp
     using _can_be_null =
         std::true_type;  // since we do not know what's going on inside the verbatim, we assume it can be null
 
-    verbatim_t(std::string verbatim) : _verbatim(verbatim)
+    verbatim_t(std::string verbatim) : _verbatim(std::move(verbatim))
     {
     }
     verbatim_t(const verbatim_t&) = default;
@@ -75,8 +77,8 @@ namespace sqlpp
 
   inline auto verbatim(std::string s) -> verbatim_t<no_value_t>
   {
-    return {s};
+    return {std::move(s)};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/verbatim_table.h b/include/sqlpp11/verbatim_table.h
index 2839e4ce..1bbc59d4 100644
--- a/include/sqlpp11/verbatim_table.h
+++ b/include/sqlpp11/verbatim_table.h
@@ -24,13 +24,15 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_VERBATIM_TABLE_H
-#define SQLPP_VERBATIM_TABLE_H
+#ifndef SQLPP11_VERBATIM_TABLE_H
+#define SQLPP11_VERBATIM_TABLE_H
 
 #include <sqlpp11/table.h>
 #include <sqlpp11/char_sequence.h>
 #include <sqlpp11/data_types/no_value.h>
 
+#include <utility>
+
 namespace sqlpp
 {
   namespace detail
@@ -48,7 +50,7 @@ namespace sqlpp
       };
       using _traits = make_traits<no_value_t>;
     };
-  }
+  }  // namespace detail
 
   struct verbatim_table_t : public table_t<verbatim_table_t, detail::unusable_pseudo_column_t>
   {
@@ -60,7 +62,7 @@ namespace sqlpp
       using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
     };
 
-    verbatim_table_t(std::string representation) : _representation(representation)
+    verbatim_table_t(std::string representation) : _representation(std::move(representation))
     {
     }
 
@@ -88,8 +90,8 @@ namespace sqlpp
 
   inline verbatim_table_t verbatim_table(std::string name)
   {
-    return {name};
+    return {std::move(name)};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/where.h b/include/sqlpp11/where.h
index 516841e7..9acf0a4c 100644
--- a/include/sqlpp11/where.h
+++ b/include/sqlpp11/where.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_WHERE_H
-#define SQLPP_WHERE_H
+#ifndef SQLPP11_WHERE_H
+#define SQLPP11_WHERE_H
 
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
@@ -103,7 +103,7 @@ namespace sqlpp
 
     private:
       template <typename Expr>
-      void _add_impl(Expr expression, const std::true_type&)
+      void _add_impl(Expr expression, const std::true_type& /*unused*/)
       {
         return _data._dynamic_expressions.emplace_back(expression);
       }
@@ -349,7 +349,7 @@ namespace sqlpp
       auto _where_impl(Check, Expression expression) const -> inconsistent<Check>;
 
       template <typename Database, typename Expression>
-      auto _where_impl(consistent_t, Expression expression) const
+      auto _where_impl(consistent_t /*unused*/, Expression expression) const
           -> _new_statement_t<consistent_t, where_t<Database, Expression>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
@@ -370,7 +370,9 @@ namespace sqlpp
       context << " WHERE ";
       serialize(t._expression, context);
       if (not t._dynamic_expressions.empty())
+      {
         context << " AND ";
+      }
       interpret_list(t._dynamic_expressions, " AND ", context);
       return context;
     }
@@ -382,7 +384,7 @@ namespace sqlpp
     using _serialize_check = consistent_t;
     using T = where_data_t<void, unconditional_t>;
 
-    static Context& _(const T&, Context& context)
+    static Context& _(const T& /*unused*/, Context& context)
     {
       return context;
     }
@@ -395,7 +397,7 @@ namespace sqlpp
   }
 
   template <typename Database, typename T>
-  auto dynamic_where(const Database&, T&& t)
+  auto dynamic_where(const Database& /*unused*/, T&& t)
       -> decltype(statement_t<Database, no_where_t<false>>().dynamic_where(std::forward<T>(t)))
   {
     return statement_t<Database, no_where_t<false>>().dynamic_where(std::forward<T>(t));
@@ -405,6 +407,6 @@ namespace sqlpp
   {
     return statement_t<void, no_where_t<false>>().unconditionally();
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/with.h b/include/sqlpp11/with.h
index a9880af3..7f03ea01 100644
--- a/include/sqlpp11/with.h
+++ b/include/sqlpp11/with.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_WITH_H
-#define SQLPP_WITH_H
+#ifndef SQLPP11_WITH_H
+#define SQLPP11_WITH_H
 
 #include <sqlpp11/assignment.h>
 #include <sqlpp11/column_fwd.h>
@@ -201,7 +201,9 @@ namespace sqlpp
       // FIXME: If there is a recursive CTE, add a "RECURSIVE" here
       context << " WITH ";
       if (T::_is_recursive::value)
+      {
         context << "RECURSIVE ";
+      }
       interpret_tuple(t._expressions, ',', context);
       context << ' ';
       return context;
@@ -217,6 +219,6 @@ namespace sqlpp
                   "at least one expression in with is an incomplete common table expression");
     return {{cte...}};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/without_table_check.h b/include/sqlpp11/without_table_check.h
index 82051860..c7703a6f 100644
--- a/include/sqlpp11/without_table_check.h
+++ b/include/sqlpp11/without_table_check.h
@@ -1,3 +1,6 @@
+#ifndef SQLPP11_WITHOUT_TABLE_CHECK_H
+#define SQLPP11_WITHOUT_TABLE_CHECK_H
+
 /*
  * Copyright (c) 2016-2016, Roland Bock
  * All rights reserved.
@@ -24,9 +27,6 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_WITHOUT_TABLE_CHECK_H
-#define SQLPP_ALIAS_H
-
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/serializer.h>
 
@@ -58,10 +58,11 @@ namespace sqlpp
   template <typename Expression>
   auto without_table_check(Expression expr) -> without_table_check_t<Expression>
   {
-    static_assert(is_expression_t<Expression>::value, "invalid argument (expression expected)");
+    static_assert(is_expression_t<Expression>::value or is_alias_t<Expression>::value,
+                  "invalid argument (expression or alias expression expected)");
 
     return {expr};
   }
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/wrap_operand.h b/include/sqlpp11/wrap_operand.h
index 9cbf5929..b14b03e3 100644
--- a/include/sqlpp11/wrap_operand.h
+++ b/include/sqlpp11/wrap_operand.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_DETAIL_WRAP_OPERAND_H
-#define SQLPP_DETAIL_WRAP_OPERAND_H
+#ifndef SQLPP11_WRAP_OPERAND_H
+#define SQLPP11_WRAP_OPERAND_H
 
 namespace sqlpp
 {
@@ -37,6 +37,6 @@ namespace sqlpp
 
   template <typename T>
   using wrap_operand_t = typename wrap_operand<T>::type;
-}
+}  // namespace sqlpp
 
 #endif
diff --git a/include/sqlpp11/wrong.h b/include/sqlpp11/wrong.h
index 5eff23e6..1ed403e0 100644
--- a/include/sqlpp11/wrong.h
+++ b/include/sqlpp11/wrong.h
@@ -24,8 +24,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SQLPP_WRONG_H
-#define SQLPP_WRONG_H
+#ifndef SQLPP11_WRONG_H
+#define SQLPP11_WRONG_H
 
 #include <type_traits>
 
@@ -41,8 +41,8 @@ namespace sqlpp
     {
       using type = std::false_type;
     };
-  }
+  }  // namespace detail
   template <typename... T>
   using wrong_t = typename detail::wrong<T...>::type;
-}
+}  // namespace sqlpp
 #endif
diff --git a/test_serializer/As.cpp b/test_serializer/As.cpp
index 709148c1..86352257 100644
--- a/test_serializer/As.cpp
+++ b/test_serializer/As.cpp
@@ -29,7 +29,7 @@
 
 #include <iostream>
 
-SQLPP_ALIAS_PROVIDER(cheese);
+SQLPP_ALIAS_PROVIDER(cheese)
 
 int As(int, char* [])
 {
diff --git a/tests/Function.cpp b/tests/Function.cpp
index e31fcd5c..1b24e77f 100644
--- a/tests/Function.cpp
+++ b/tests/Function.cpp
@@ -403,11 +403,14 @@ int Function(int, char* [])
   // test verbatim
   {
     using TB = decltype(sqlpp::verbatim<sqlpp::boolean>("1"));
+    using TBS = decltype(sqlpp::verbatim<sqlpp::boolean>("1").as(kaesekuchen));
     using TI = decltype(sqlpp::verbatim<sqlpp::bigint>("42"));
     using TF = decltype(sqlpp::verbatim<sqlpp::floating_point>("1.5"));
     using TT = decltype(sqlpp::verbatim<sqlpp::text>("cheesecake"));
     static_assert(not sqlpp::is_selectable_t<TB>::value, "type requirement");
     static_assert(sqlpp::is_boolean_t<TB>::value, "type requirement");
+    static_assert(sqlpp::is_selectable_t<TBS>::value, "type requirement");
+    static_assert(sqlpp::is_boolean_t<TBS>::value, "type requirement");
     static_assert(not sqlpp::is_selectable_t<TB>::value, "type requirement");
     static_assert(sqlpp::is_integral_t<TI>::value, "type requirement");
     static_assert(not sqlpp::is_selectable_t<TI>::value, "type requirement");
diff --git a/tests/Minimalistic.cpp b/tests/Minimalistic.cpp
index 28b4bb4d..1b63a3c2 100644
--- a/tests/Minimalistic.cpp
+++ b/tests/Minimalistic.cpp
@@ -1,6 +1,6 @@
 #include <sqlpp11/sqlpp11.h>
 
-int Minimalistic(int, char* [])
+int Minimalistic(int /*unused*/, char* /*unused*/ [])
 {
   return 0;
 }
diff --git a/tests/Ppgen.cpp b/tests/Ppgen.cpp
index 3fa5d3eb..9093e473 100644
--- a/tests/Ppgen.cpp
+++ b/tests/Ppgen.cpp
@@ -60,6 +60,9 @@ SQLPP_DECLARE_TABLE(
 	(id   , int         , SQLPP_PRIMARY_KEY)
 	(name , varchar(255), SQLPP_NULL       )
 	(fatal, bool        , SQLPP_NOT_NULL   )
+	(date0, date        , SQLPP_NULL   )
+	(date1, datetime    , SQLPP_NULL   )
+	(date2, timestamp   , SQLPP_NULL   )
 )
 // clang-format on
 
diff --git a/tests/SelectType.cpp b/tests/SelectType.cpp
index f0781007..f783ce15 100644
--- a/tests/SelectType.cpp
+++ b/tests/SelectType.cpp
@@ -396,6 +396,12 @@ int SelectType(int, char* [])
     serialize(s, printer).str();
   }
 
+  {
+    auto find_query = sqlpp::dynamic_select(db).dynamic_columns(t.alpha.as(alias::a)).dynamic_from(t).unconditionally();
+    find_query.from.add(sqlpp::dynamic_join(f).on(t.alpha == f.omega));
+    find_query.selected_columns.add(sqlpp::without_table_check(f.omega.as(alias::b)));
+  }
+
   // Test that verbatim_table compiles
   {
     auto s = select(t.alpha).from(sqlpp::verbatim_table("my_unknown_table"));