From cf83978118c8193962b62afcd4df52bc1c874fc6 Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Wed, 31 Aug 2016 21:15:54 +0200
Subject: [PATCH 01/11] Migrated select clauses to returning wrapped asserts

This helps a lot in testing static asserts (and debuging expressions
with MSVC)
---
 include/sqlpp11/all_of.h                 |  4 +-
 include/sqlpp11/case.h                   | 26 ++++-----
 include/sqlpp11/custom_query.h           |  4 +-
 include/sqlpp11/dynamic_pre_join.h       | 19 +++----
 include/sqlpp11/from.h                   | 43 +++++++--------
 include/sqlpp11/group_by.h               | 58 ++++++++++----------
 include/sqlpp11/having.h                 | 26 ++++-----
 include/sqlpp11/insert_value_list.h      | 28 +++++-----
 include/sqlpp11/interpretable_list.h     |  2 +-
 include/sqlpp11/limit.h                  | 43 +++++++--------
 include/sqlpp11/offset.h                 | 43 +++++++--------
 include/sqlpp11/order_by.h               | 55 ++++++++++---------
 include/sqlpp11/policy_update.h          | 18 +++----
 include/sqlpp11/portable_static_assert.h |  8 +--
 include/sqlpp11/pre_join.h               | 48 ++++++++---------
 include/sqlpp11/rhs_wrap.h               |  2 +-
 include/sqlpp11/select_column_list.h     | 69 ++++++++++++------------
 include/sqlpp11/select_flag_list.h       | 56 ++++++++++---------
 include/sqlpp11/serializer.h             |  4 +-
 include/sqlpp11/statement.h              | 20 ++++---
 include/sqlpp11/tvin.h                   |  4 +-
 include/sqlpp11/update_list.h            | 10 ++--
 include/sqlpp11/using.h                  | 14 +++--
 include/sqlpp11/where.h                  | 18 +++----
 include/sqlpp11/with.h                   | 20 ++++---
 tests/CMakeLists.txt                     | 28 +++++-----
 tests/MockDb.h                           | 20 ++++---
 tests/Select.cpp                         |  4 +-
 28 files changed, 326 insertions(+), 368 deletions(-)

diff --git a/include/sqlpp11/all_of.h b/include/sqlpp11/all_of.h
index 32dacf55..b7a2ea85 100644
--- a/include/sqlpp11/all_of.h
+++ b/include/sqlpp11/all_of.h
@@ -27,8 +27,8 @@
 #ifndef SQLPP_ALL_OF_H
 #define SQLPP_ALL_OF_H
 
-#include <sqlpp11/interpret.h>
 #include <sqlpp11/alias.h>
+#include <sqlpp11/interpret.h>
 #include <sqlpp11/multi_column.h>
 #include <sqlpp11/portable_static_assert.h>
 
@@ -62,7 +62,7 @@ namespace sqlpp
 
     static Context& _(const T&, const Context&)
     {
-      _serialize_check::_();
+      _serialize_check{};
     }
   };
 }
diff --git a/include/sqlpp11/case.h b/include/sqlpp11/case.h
index 99a22e4b..b536d432 100644
--- a/include/sqlpp11/case.h
+++ b/include/sqlpp11/case.h
@@ -27,10 +27,10 @@
 #ifndef SQLPP_CASE_H
 #define SQLPP_CASE_H
 
-#include <sqlpp11/type_traits.h>
 #include <sqlpp11/char_sequence.h>
 #include <sqlpp11/data_types/boolean.h>
 #include <sqlpp11/detail/type_set.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -87,13 +87,13 @@ namespace sqlpp
   class case_then_t
   {
     template <typename Else>
-    auto _else_impl(const std::true_type&, Else else_) -> case_t<When, Then, Else>
+    auto _else_impl(consistent_t, Else else_) -> case_t<When, Then, Else>
     {
       return {_when, _then, else_};
     }
 
-    template <typename Else>
-    auto _else_impl(const std::false_type&, Else else_) -> void;
+    template <typename Check, typename Else>
+    auto _else_impl(Check, Else else_) -> Check;
 
   public:
     case_then_t(When when, Then then) : _when(when), _then(then)
@@ -109,7 +109,6 @@ namespace sqlpp
     template <typename Else>
     auto else_(Else else_) -> decltype(this->_else_impl(check_case_else_t<Then, Else>{}, else_))
     {
-      check_case_else_t<Then, Else>::_();
       return _else_impl(check_case_else_t<Then, Else>{}, else_);
     }
 
@@ -122,13 +121,13 @@ namespace sqlpp
   class case_when_t
   {
     template <typename Then>
-    auto _then_impl(const std::true_type&, Then t) -> case_then_t<When, wrap_operand_t<Then>>
+    auto _then_impl(consistent_t, Then t) -> case_then_t<When, wrap_operand_t<Then>>
     {
       return {_when, t};
     }
 
-    template <typename Then>
-    auto _then_impl(const std::false_type&, Then t) -> void;
+    template <typename Check, typename Then>
+    auto _then_impl(Check, Then t) -> Check;
 
   public:
     case_when_t(When when) : _when(when)
@@ -144,7 +143,6 @@ namespace sqlpp
     template <typename Then>
     auto then(Then t) -> decltype(this->_then_impl(check_case_then_t<Then>{}, t))
     {
-      check_case_then_t<Then>::_();
       return _then_impl(check_case_then_t<Then>{}, t);
     }
 
@@ -174,21 +172,19 @@ namespace sqlpp
   namespace detail
   {
     template <typename When>
-    auto case_when_impl(const std::true_type&, When when) -> case_when_t<wrap_operand_t<When>>
+    auto case_when_impl(consistent_t, When when) -> case_when_t<wrap_operand_t<When>>
     {
       return {when};
     }
 
-    template <typename When>
-    auto case_when_impl(const std::false_type&, When when) -> void;
+    template <typename Check, typename When>
+    auto case_when_impl(Check, When when) -> Check;
   }
 
   template <typename When>
   auto case_when(When when) -> decltype(detail::case_when_impl(check_case_when_t<When>{}, when))
   {
-    check_case_when_t<When>::_();
-
-    return detail::case_when_impl(typename check_case_when_t<When>::type{}, when);
+    return detail::case_when_impl(check_case_when_t<When>{}, when);
   }
 }
 
diff --git a/include/sqlpp11/custom_query.h b/include/sqlpp11/custom_query.h
index e5079968..abaf0df9 100644
--- a/include/sqlpp11/custom_query.h
+++ b/include/sqlpp11/custom_query.h
@@ -92,14 +92,14 @@ namespace sqlpp
     template <typename Db>
     auto _run(Db& db) const -> decltype(std::declval<_methods_t>()._run(db, *this))
     {
-      _run_check::_();
+      _run_check{};  // FIXME: dispatch here?
       return _methods_t::_run(db, *this);
     }
 
     template <typename Db>
     auto _prepare(Db& db) const -> decltype(std::declval<_methods_t>()._prepare(db, *this))
     {
-      _prepare_check::_();
+      _prepare_check{};  // FIXME: dispatch here?
       return _methods_t::_prepare(db, *this);
     }
 
diff --git a/include/sqlpp11/dynamic_pre_join.h b/include/sqlpp11/dynamic_pre_join.h
index 88aa9f84..da698e6c 100644
--- a/include/sqlpp11/dynamic_pre_join.h
+++ b/include/sqlpp11/dynamic_pre_join.h
@@ -91,10 +91,8 @@ namespace sqlpp
     template <typename Expr>
     auto on(Expr expr) const -> typename std::conditional<check_dynamic_join_on_t<dynamic_pre_join_t, Expr>::value,
                                                           dynamic_join_t<dynamic_pre_join_t, on_t<Expr>>,
-                                                          bad_statement>::type
+                                                          check_dynamic_join_on_t<dynamic_pre_join_t, Expr>>::type
     {
-      check_dynamic_join_on_t<dynamic_pre_join_t, Expr>::_();
-
       return {*this, {expr}};
     }
 
@@ -119,40 +117,40 @@ namespace sqlpp
   template <typename JoinType, typename Table>
   using make_dynamic_pre_join_t = typename std::conditional<check_dynamic_pre_join_t<Table>::value,
                                                             dynamic_pre_join_t<JoinType, Table>,
-                                                            bad_statement>::type;
+                                                            check_dynamic_pre_join_t<Table>>::type;
 
   template <typename Table>
   auto dynamic_join(Table table) -> make_dynamic_pre_join_t<inner_join_t, Table>
   {
-    check_dynamic_pre_join_t<Table>::_();
+    check_dynamic_pre_join_t<Table>{};  // FIXME: Failure return type?
     return {table};
   }
 
   template <typename Table>
   auto dynamic_inner_join(Table table) -> make_dynamic_pre_join_t<inner_join_t, Table>
   {
-    check_dynamic_pre_join_t<Table>::_();
+    check_dynamic_pre_join_t<Table>{};
     return {table};
   }
 
   template <typename Table>
   auto dynamic_left_outer_join(Table table) -> make_dynamic_pre_join_t<left_outer_join_t, Table>
   {
-    check_dynamic_pre_join_t<Table>::_();
+    check_dynamic_pre_join_t<Table>{};
     return {table};
   }
 
   template <typename Table>
   auto dynamic_right_outer_join(Table table) -> make_dynamic_pre_join_t<right_outer_join_t, Table>
   {
-    check_dynamic_pre_join_t<Table>::_();
+    check_dynamic_pre_join_t<Table>{};
     return {table};
   }
 
   template <typename Table>
   auto dynamic_outer_join(Table table) -> make_dynamic_pre_join_t<outer_join_t, Table>
   {
-    check_dynamic_pre_join_t<Table>::_();
+    check_dynamic_pre_join_t<Table>{};
     return {table};
   }
 
@@ -160,9 +158,8 @@ namespace sqlpp
   auto dynamic_cross_join(Table table) ->
       typename std::conditional<check_dynamic_pre_join_t<Table>::value,
                                 dynamic_join_t<dynamic_pre_join_t<cross_join_t, Table>, on_t<unconditional_t>>,
-                                bad_statement>::type
+                                check_dynamic_pre_join_t<Table>>::type
   {
-    check_dynamic_pre_join_t<Table>::_();
     return {dynamic_pre_join_t<cross_join_t, Table>{table}, {}};
   }
 }
diff --git a/include/sqlpp11/from.h b/include/sqlpp11/from.h
index 4968acbe..a226d81d 100644
--- a/include/sqlpp11/from.h
+++ b/include/sqlpp11/from.h
@@ -27,15 +27,15 @@
 #ifndef SQLPP_FROM_H
 #define SQLPP_FROM_H
 
+#include <sqlpp11/detail/sum.h>
+#include <sqlpp11/dynamic_join.h>
+#include <sqlpp11/interpret_tuple.h>
+#include <sqlpp11/interpretable_list.h>
+#include <sqlpp11/logic.h>
+#include <sqlpp11/no_data.h>
+#include <sqlpp11/policy_update.h>
 #include <sqlpp11/table_ref.h>
 #include <sqlpp11/type_traits.h>
-#include <sqlpp11/no_data.h>
-#include <sqlpp11/interpretable_list.h>
-#include <sqlpp11/interpret_tuple.h>
-#include <sqlpp11/logic.h>
-#include <sqlpp11/detail/sum.h>
-#include <sqlpp11/policy_update.h>
-#include <sqlpp11/dynamic_join.h>
 
 namespace sqlpp
 {
@@ -116,23 +116,22 @@ namespace sqlpp
       }
 
       template <typename DynamicJoin>
-      auto add(DynamicJoin dynamicJoin) ->
-          typename std::conditional<check_from_add_t<_impl_t, DynamicJoin>::value, void, bad_statement>::type
+      auto add(DynamicJoin dynamicJoin) -> typename std::
+          conditional<check_from_add_t<_impl_t, DynamicJoin>::value, void, check_from_add_t<_impl_t, DynamicJoin>>::type
       {
         using Check = check_from_add_t<_impl_t, DynamicJoin>;
-        Check::_();
         return _add_impl(dynamicJoin, Check{});
       }
 
     private:
       template <typename DynamicJoin>
-      auto _add_impl(DynamicJoin dynamicJoin, const std::true_type&) -> void
+      auto _add_impl(DynamicJoin dynamicJoin, consistent_t) -> void
       {
         _data._dynamic_tables.emplace_back(from_table(dynamicJoin));
       }
 
-      template <typename DynamicJoin>
-      auto _add_impl(DynamicJoin dynamicJoin, const std::false_type&) -> bad_statement;
+      template <typename Check, typename DynamicJoin>
+      auto _add_impl(DynamicJoin dynamicJoin, Check) -> Check;
 
     public:
       _data_t _data;
@@ -146,8 +145,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : from{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : from{std::forward<Args>(args)...}
       {
       }
 
@@ -234,8 +232,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_from{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_from{std::forward<Args>(args)...}
       {
       }
 
@@ -258,7 +255,7 @@ namespace sqlpp
       using _database_t = typename Policies::_database_t;
 
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_from_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_from_t, T>;
 
       using _consistency_check = consistent_t;
 
@@ -266,7 +263,6 @@ namespace sqlpp
       auto from(Table table) const -> _new_statement_t<check_from_static_t<Table>, from_t<void, from_table_t<Table>>>
       {
         using Check = check_from_static_t<Table>;
-        Check{}._();
         return _from_impl<void>(Check{}, table);
       }
 
@@ -275,17 +271,16 @@ namespace sqlpp
           -> _new_statement_t<check_from_dynamic_t<_database_t, Table>, from_t<_database_t, from_table_t<Table>>>
       {
         using Check = check_from_dynamic_t<_database_t, Table>;
-        Check{}._();
         return _from_impl<_database_t>(Check{}, table);
       }
 
     private:
-      template <typename Database, typename Table>
-      auto _from_impl(const std::false_type&, Table table) const -> bad_statement;
+      template <typename Database, typename Check, typename Table>
+      auto _from_impl(Check, Table table) const -> Check;
 
       template <typename Database, typename Table>
-      auto _from_impl(const std::true_type&, Table table) const
-          -> _new_statement_t<std::true_type, from_t<Database, from_table_t<Table>>>
+      auto _from_impl(consistent_t, Table table) const
+          -> _new_statement_t<consistent_t, from_t<Database, from_table_t<Table>>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
                 from_data_t<Database, from_table_t<Table>>{from_table(table)}};
diff --git a/include/sqlpp11/group_by.h b/include/sqlpp11/group_by.h
index 8dd9deb1..34210ec8 100644
--- a/include/sqlpp11/group_by.h
+++ b/include/sqlpp11/group_by.h
@@ -27,13 +27,13 @@
 #ifndef SQLPP_GROUP_BY_H
 #define SQLPP_GROUP_BY_H
 
-#include <tuple>
-#include <sqlpp11/type_traits.h>
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/interpretable_list.h>
-#include <sqlpp11/policy_update.h>
 #include <sqlpp11/logic.h>
+#include <sqlpp11/policy_update.h>
+#include <sqlpp11/type_traits.h>
+#include <tuple>
 
 namespace sqlpp
 {
@@ -67,9 +67,8 @@ namespace sqlpp
     using _nodes = detail::type_vector<Expressions...>;
 
     using _is_dynamic = is_database<Database>;
-    using _provided_aggregates = typename std::conditional<_is_dynamic::value,
-                                                           detail::type_set<>,
-                                                           detail::make_type_set_t<Expressions...>>::type;
+    using _provided_aggregates = typename std::
+        conditional<_is_dynamic::value, detail::type_set<>, detail::make_type_set_t<Expressions...>>::type;
 
     // Data
     using _data_t = group_by_data_t<Database, Expressions...>;
@@ -92,7 +91,7 @@ namespace sqlpp
         static_assert(Policies::template _no_unknown_tables<Expression>::value,
                       "expression uses tables unknown to this statement in group_by::add()");
         using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Expression>;
-        _serialize_check::_();
+        _serialize_check{};
 
         using ok = logic::all_t<_is_dynamic::value, is_expression_t<Expression>::value, _serialize_check::type::value>;
 
@@ -121,8 +120,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : group_by{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : group_by{std::forward<Args>(args)...}
       {
       }
 
@@ -148,6 +146,17 @@ namespace sqlpp
     };
   };
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_group_by_args_are_expressions_t,
+                               "arguments for group_by() must be valid expressions");
+  template <typename... Exprs>
+  struct check_group_by
+  {
+    using type = static_combined_check_t<
+        static_check_t<logic::all_t<is_expression_t<Exprs>::value...>::value, assert_group_by_args_are_expressions_t>>;
+  };
+  template <typename... Exprs>
+  using check_group_by_t = typename check_group_by<Exprs...>::type;
+
   // NO GROUP BY YET
   struct no_group_by_t
   {
@@ -178,8 +187,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_group_by{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_group_by{std::forward<Args>(args)...}
       {
       }
 
@@ -201,47 +209,37 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
-      //	  template <typename... T>
-      //	  using _check = logic::all_t<is_expression_t<T>::value...>;
-      template <typename... T>
-      struct _check : logic::all_t<is_expression_t<T>::value...>
-      {
-      };
-
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_group_by_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_group_by_t, T>;
 
       using _consistency_check = consistent_t;
 
       template <typename... Expressions>
       auto group_by(Expressions... expressions) const
-          -> _new_statement_t<_check<Expressions...>, group_by_t<void, Expressions...>>
+          -> _new_statement_t<check_group_by_t<Expressions...>, group_by_t<void, Expressions...>>
       {
         static_assert(sizeof...(Expressions), "at least one expression (e.g. a column) required in group_by()");
-        static_assert(_check<Expressions...>::value, "at least one argument is not an expression in group_by()");
 
-        return _group_by_impl<void>(_check<Expressions...>{}, expressions...);
+        return _group_by_impl<void>(check_group_by_t<Expressions...>{}, expressions...);
       }
 
       template <typename... Expressions>
       auto dynamic_group_by(Expressions... expressions) const
-          -> _new_statement_t<_check<Expressions...>, group_by_t<_database_t, Expressions...>>
+          -> _new_statement_t<check_group_by_t<Expressions...>, group_by_t<_database_t, Expressions...>>
       {
         static_assert(not std::is_same<_database_t, void>::value,
                       "dynamic_group_by must not be called in a static statement");
-        static_assert(_check<Expressions...>::value, "at least one argument is not an expression in group_by()");
 
-        return _group_by_impl<_database_t>(_check<Expressions...>{}, expressions...);
+        return _group_by_impl<_database_t>(check_group_by_t<Expressions...>{}, expressions...);
       }
 
     private:
-      template <typename Database, typename... Expressions>
-      auto _group_by_impl(const std::false_type&, Expressions... expressions) const -> bad_statement;
+      template <typename Database, typename Check, typename... Expressions>
+      auto _group_by_impl(Check, Expressions... expressions) const -> Check;
 
       template <typename Database, typename... Expressions>
-      auto _group_by_impl(const std::true_type&, Expressions... expressions) const
-          -> _new_statement_t<std::true_type, group_by_t<Database, Expressions...>>
+      auto _group_by_impl(consistent_t, Expressions... expressions) const
+          -> _new_statement_t<consistent_t, group_by_t<Database, Expressions...>>
       {
         static_assert(not detail::has_duplicates<Expressions...>::value,
                       "at least one duplicate argument detected in group_by()");
diff --git a/include/sqlpp11/having.h b/include/sqlpp11/having.h
index 4e768845..08905356 100644
--- a/include/sqlpp11/having.h
+++ b/include/sqlpp11/having.h
@@ -27,13 +27,13 @@
 #ifndef SQLPP_HAVING_H
 #define SQLPP_HAVING_H
 
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/value.h>
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/interpretable_list.h>
-#include <sqlpp11/policy_update.h>
 #include <sqlpp11/logic.h>
+#include <sqlpp11/policy_update.h>
+#include <sqlpp11/type_traits.h>
+#include <sqlpp11/value.h>
 
 namespace sqlpp
 {
@@ -92,7 +92,7 @@ namespace sqlpp
         static_assert(Policies::template _no_unknown_tables<Expr>::value,
                       "expression uses tables unknown to this statement in having::add()");
         using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Expr>;
-        _serialize_check::_();
+        _serialize_check{};
 
         using ok = logic::all_t<_is_dynamic::value, is_expression_t<Expr>::value, _serialize_check::type::value>;
 
@@ -121,8 +121,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : having{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : having{std::forward<Args>(args)...}
       {
       }
 
@@ -212,8 +211,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_having{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_having{std::forward<Args>(args)...}
       {
       }
 
@@ -244,7 +242,7 @@ namespace sqlpp
       };
 
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_having_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_having_t, T>;
 
       using _consistency_check = consistent_t;
 
@@ -253,7 +251,6 @@ namespace sqlpp
           -> _new_statement_t<check_having_static_t<Expression>, having_t<void, Expression>>
       {
         using Check = check_having_static_t<Expression>;
-        Check{}._();
 
         return _having_impl<void>(Check{}, expression);
       }
@@ -263,7 +260,6 @@ namespace sqlpp
           -> _new_statement_t<check_having_dynamic_t<_database_t, Expression>, having_t<_database_t, Expression>>
       {
         using Check = check_having_dynamic_t<_database_t, Expression>;
-        Check{}._();
 
         return _having_impl<_database_t>(Check{}, expression);
       }
@@ -275,12 +271,12 @@ namespace sqlpp
       }
 
     private:
-      template <typename Database, typename Expression>
-      auto _having_impl(const std::false_type&, Expression expression) const -> bad_statement;
+      template <typename Database, typename Check, typename Expression>
+      auto _having_impl(Check, Expression expression) const -> Check;
 
       template <typename Database, typename Expression>
-      auto _having_impl(const std::true_type&, Expression expression) const
-          -> _new_statement_t<std::true_type, having_t<Database, Expression>>
+      auto _having_impl(consistent_t, Expression expression) const
+          -> _new_statement_t<consistent_t, having_t<Database, Expression>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
                 having_data_t<Database, Expression>{expression}};
diff --git a/include/sqlpp11/insert_value_list.h b/include/sqlpp11/insert_value_list.h
index 2cae2a63..18bfde95 100644
--- a/include/sqlpp11/insert_value_list.h
+++ b/include/sqlpp11/insert_value_list.h
@@ -27,19 +27,19 @@
 #ifndef SQLPP_INSERT_VALUE_LIST_H
 #define SQLPP_INSERT_VALUE_LIST_H
 
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/portable_static_assert.h>
-#include <sqlpp11/logic.h>
+#include <sqlpp11/assignment.h>
 #include <sqlpp11/column_fwd.h>
 #include <sqlpp11/expression_fwd.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/interpretable_list.h>
-#include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/insert_value.h>
-#include <sqlpp11/simple_column.h>
+#include <sqlpp11/interpret_tuple.h>
+#include <sqlpp11/interpretable_list.h>
+#include <sqlpp11/logic.h>
 #include <sqlpp11/no_data.h>
 #include <sqlpp11/policy_update.h>
+#include <sqlpp11/portable_static_assert.h>
+#include <sqlpp11/simple_column.h>
 #include <sqlpp11/statement.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -96,8 +96,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : default_values{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : default_values{std::forward<Args>(args)...}
       {
       }
 
@@ -264,7 +263,7 @@ namespace sqlpp
         static_assert(Policies::template _no_unknown_tables<Assignment>::value,
                       "add() contains a column from a foreign table");
         using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Assignment>;
-        _serialize_check::_();
+        _serialize_check{};
 
         using ok = logic::all_t<_is_dynamic::value, is_assignment_t<Assignment>::value, _serialize_check::type::value>;
 
@@ -294,8 +293,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : insert_list{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : insert_list{std::forward<Args>(args)...}
       {
       }
 
@@ -400,8 +398,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : values{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : values{std::forward<Args>(args)...}
       {
       }
 
@@ -459,8 +456,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_insert_values{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_insert_values{std::forward<Args>(args)...}
       {
       }
 
diff --git a/include/sqlpp11/interpretable_list.h b/include/sqlpp11/interpretable_list.h
index b91f82a9..dc11d0ae 100644
--- a/include/sqlpp11/interpretable_list.h
+++ b/include/sqlpp11/interpretable_list.h
@@ -27,8 +27,8 @@
 #ifndef SQLPP_INTERPRETABLE_LIST_H
 #define SQLPP_INTERPRETABLE_LIST_H
 
-#include <vector>
 #include <sqlpp11/interpretable.h>
+#include <vector>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/limit.h b/include/sqlpp11/limit.h
index 2682ab87..d2fcb4ae 100644
--- a/include/sqlpp11/limit.h
+++ b/include/sqlpp11/limit.h
@@ -27,9 +27,9 @@
 #ifndef SQLPP_LIMIT_H
 #define SQLPP_LIMIT_H
 
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/policy_update.h>
 #include <sqlpp11/detail/type_set.h>
+#include <sqlpp11/policy_update.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -81,8 +81,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : limit{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : limit{std::forward<Args>(args)...}
       {
       }
 
@@ -115,8 +114,7 @@ namespace sqlpp
     }
 
     template <typename Limit>
-    dynamic_limit_data_t(Limit value)
-        : _initialized(true), _value(wrap_operand_t<Limit>(value))
+    dynamic_limit_data_t(Limit value) : _initialized(true), _value(wrap_operand_t<Limit>(value))
     {
     }
 
@@ -172,8 +170,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : limit{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : limit{std::forward<Args>(args)...}
       {
       }
 
@@ -197,6 +194,15 @@ namespace sqlpp
     };
   };
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_limit_is_integral, "argument for limit() must be an integral expressions");
+  template <typename T>
+  struct check_limit
+  {
+    using type = static_combined_check_t<static_check_t<is_integral_t<T>::value, assert_limit_is_integral>>;
+  };
+  template <typename T>
+  using check_limit_t = typename check_limit<wrap_operand_t<T>>::type;
+
   struct no_limit_t
   {
     using _traits = make_traits<no_value_t, tag::is_noop>;
@@ -226,8 +232,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_limit{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_limit{std::forward<Args>(args)...}
       {
       }
 
@@ -249,32 +254,28 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      template <typename T>
-      using _check = is_integral_t<wrap_operand_t<T>>;
-
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_limit_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_limit_t, T>;
 
       using _consistency_check = consistent_t;
 
       template <typename Arg>
-      auto limit(Arg arg) const -> _new_statement_t<_check<Arg>, limit_t<wrap_operand_t<Arg>>>
+      auto limit(Arg arg) const -> _new_statement_t<check_limit_t<Arg>, limit_t<wrap_operand_t<Arg>>>
       {
-        static_assert(_check<Arg>::value, "limit requires an integral value or integral parameter");
-        return _limit_impl(_check<Arg>{}, wrap_operand_t<Arg>{arg});
+        return _limit_impl(check_limit_t<Arg>{}, wrap_operand_t<Arg>{arg});
       }
 
-      auto dynamic_limit() const -> _new_statement_t<std::true_type, dynamic_limit_t<_database_t>>
+      auto dynamic_limit() const -> _new_statement_t<consistent_t, dynamic_limit_t<_database_t>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this), dynamic_limit_data_t<_database_t>{}};
       }
 
     private:
-      template <typename Arg>
-      auto _limit_impl(const std::false_type&, Arg arg) const -> bad_statement;
+      template <typename Check, typename Arg>
+      auto _limit_impl(Check, Arg arg) const -> Check;
 
       template <typename Arg>
-      auto _limit_impl(const std::true_type&, Arg arg) const -> _new_statement_t<std::true_type, limit_t<Arg>>
+      auto _limit_impl(consistent_t, 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}};
       }
diff --git a/include/sqlpp11/offset.h b/include/sqlpp11/offset.h
index 9251a6d2..8f1fd3e6 100644
--- a/include/sqlpp11/offset.h
+++ b/include/sqlpp11/offset.h
@@ -27,9 +27,9 @@
 #ifndef SQLPP_OFFSET_H
 #define SQLPP_OFFSET_H
 
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/policy_update.h>
 #include <sqlpp11/detail/type_set.h>
+#include <sqlpp11/policy_update.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -83,8 +83,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : offset{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : offset{std::forward<Args>(args)...}
       {
       }
 
@@ -117,8 +116,7 @@ namespace sqlpp
     }
 
     template <typename Offset>
-    dynamic_offset_data_t(Offset value)
-        : _initialized(true), _value(wrap_operand_t<Offset>(value))
+    dynamic_offset_data_t(Offset value) : _initialized(true), _value(wrap_operand_t<Offset>(value))
     {
     }
 
@@ -174,8 +172,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : offset{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : offset{std::forward<Args>(args)...}
       {
       }
 
@@ -211,6 +208,15 @@ namespace sqlpp
     interpretable_t<Database> _value;
   };
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_offset_is_integral, "argument for offset() must be an integral expressions");
+  template <typename T>
+  struct check_offset
+  {
+    using type = static_combined_check_t<static_check_t<is_integral_t<T>::value, assert_offset_is_integral>>;
+  };
+  template <typename T>
+  using check_offset_t = typename check_offset<wrap_operand_t<T>>::type;
+
   struct no_offset_t
   {
     using _traits = make_traits<no_value_t, tag::is_noop>;
@@ -240,8 +246,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_offset{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_offset{std::forward<Args>(args)...}
       {
       }
 
@@ -263,22 +268,18 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      template <typename T>
-      using _check = is_integral_t<wrap_operand_t<T>>;
-
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_offset_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_offset_t, T>;
 
       using _consistency_check = consistent_t;
 
       template <typename Arg>
-      auto offset(Arg arg) const -> _new_statement_t<_check<Arg>, offset_t<wrap_operand_t<Arg>>>
+      auto offset(Arg arg) const -> _new_statement_t<check_offset_t<Arg>, offset_t<wrap_operand_t<Arg>>>
       {
-        static_assert(_check<Arg>::value, "offset requires an integral value or integral parameter");
-        return _offset_impl(_check<Arg>{}, wrap_operand_t<Arg>{arg});
+        return _offset_impl(check_offset_t<Arg>{}, wrap_operand_t<Arg>{arg});
       }
 
-      auto dynamic_offset() const -> _new_statement_t<std::true_type, dynamic_offset_t<_database_t>>
+      auto dynamic_offset() const -> _new_statement_t<consistent_t, dynamic_offset_t<_database_t>>
       {
         static_assert(not std::is_same<_database_t, void>::value,
                       "dynamic_offset must not be called in a static statement");
@@ -286,11 +287,11 @@ namespace sqlpp
       }
 
     private:
-      template <typename Arg>
-      auto _offset_impl(const std::false_type&, Arg arg) const -> bad_statement;
+      template <typename Check, typename Arg>
+      auto _offset_impl(Check, Arg arg) const -> Check;
 
       template <typename Arg>
-      auto _offset_impl(const std::true_type&, Arg arg) const -> _new_statement_t<std::true_type, offset_t<Arg>>
+      auto _offset_impl(consistent_t, 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}};
       }
diff --git a/include/sqlpp11/order_by.h b/include/sqlpp11/order_by.h
index 4ac698bf..509d0950 100644
--- a/include/sqlpp11/order_by.h
+++ b/include/sqlpp11/order_by.h
@@ -27,13 +27,13 @@
 #ifndef SQLPP_ORDER_BY_H
 #define SQLPP_ORDER_BY_H
 
-#include <tuple>
-#include <sqlpp11/type_traits.h>
+#include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/interpretable.h>
-#include <sqlpp11/policy_update.h>
 #include <sqlpp11/logic.h>
-#include <sqlpp11/detail/type_set.h>
+#include <sqlpp11/policy_update.h>
+#include <sqlpp11/type_traits.h>
+#include <tuple>
 
 namespace sqlpp
 {
@@ -89,7 +89,7 @@ namespace sqlpp
         static_assert(Policies::template _no_unknown_tables<Expression>::value,
                       "expression uses tables unknown to this statement in order_by::add()");
         using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Expression>;
-        _serialize_check::_();
+        _serialize_check{};
 
         using ok = logic::all_t<_is_dynamic::value, is_sort_order_t<Expression>::value, _serialize_check::type::value>;
 
@@ -118,8 +118,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : order_by{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : order_by{std::forward<Args>(args)...}
       {
       }
 
@@ -145,6 +144,17 @@ namespace sqlpp
     };
   };
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_order_by_args_are_sort_order_expressions_t,
+                               "arguments for order_by() must be sort order expressions");
+  template <typename... Exprs>
+  struct check_order_by
+  {
+    using type = static_combined_check_t<static_check_t<logic::all_t<is_sort_order_t<Exprs>::value...>::value,
+                                                        assert_order_by_args_are_sort_order_expressions_t>>;
+  };
+  template <typename... Exprs>
+  using check_order_by_t = typename check_order_by<Exprs...>::type;
+
   // NO ORDER BY YET
   struct no_order_by_t
   {
@@ -175,8 +185,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_order_by{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_order_by{std::forward<Args>(args)...}
       {
       }
 
@@ -198,47 +207,37 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
-      //	  template <typename... T>
-      //	  using _check = logic::all_t<is_sort_order_t<T>::value...>;
-      template <typename... T>
-      struct _check : logic::all_t<is_sort_order_t<T>::value...>
-      {
-      };
-
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_order_by_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_order_by_t, T>;
 
       using _consistency_check = consistent_t;
 
       template <typename... Expressions>
       auto order_by(Expressions... expressions) const
-          -> _new_statement_t<_check<Expressions...>, order_by_t<void, Expressions...>>
+          -> _new_statement_t<check_order_by_t<Expressions...>, order_by_t<void, Expressions...>>
       {
         static_assert(sizeof...(Expressions), "at least one expression (e.g. a column) required in order_by()");
-        static_assert(_check<Expressions...>::value, "at least one argument is not a sort order in order_by()");
 
-        return _order_by_impl<void>(_check<Expressions...>{}, expressions...);
+        return _order_by_impl<void>(check_order_by_t<Expressions...>{}, expressions...);
       }
 
       template <typename... Expressions>
       auto dynamic_order_by(Expressions... expressions) const
-          -> _new_statement_t<_check<Expressions...>, order_by_t<_database_t, Expressions...>>
+          -> _new_statement_t<check_order_by_t<Expressions...>, order_by_t<_database_t, Expressions...>>
       {
         static_assert(not std::is_same<_database_t, void>::value,
                       "dynamic_order_by must not be called in a static statement");
-        static_assert(_check<Expressions...>::value, "at least one argument is not a sort order in order_by()");
 
-        return _order_by_impl<_database_t>(_check<Expressions...>{}, expressions...);
+        return _order_by_impl<_database_t>(check_order_by_t<Expressions...>{}, expressions...);
       }
 
     private:
-      template <typename Database, typename... Expressions>
-      auto _order_by_impl(const std::false_type&, Expressions... expressions) const -> bad_statement;
+      template <typename Database, typename Check, typename... Expressions>
+      auto _order_by_impl(Check, Expressions... expressions) const -> Check;
 
       template <typename Database, typename... Expressions>
-      auto _order_by_impl(const std::true_type&, Expressions... expressions) const
-          -> _new_statement_t<std::true_type, order_by_t<Database, Expressions...>>
+      auto _order_by_impl(consistent_t, Expressions... expressions) const
+          -> _new_statement_t<consistent_t, order_by_t<Database, Expressions...>>
       {
         static_assert(not detail::has_duplicates<Expressions...>::value,
                       "at least one duplicate argument detected in order_by()");
diff --git a/include/sqlpp11/policy_update.h b/include/sqlpp11/policy_update.h
index 4996e67a..b1cafabc 100644
--- a/include/sqlpp11/policy_update.h
+++ b/include/sqlpp11/policy_update.h
@@ -27,8 +27,8 @@
 #ifndef SQLPP_POLICY_UPDATE_H
 #define SQLPP_POLICY_UPDATE_H
 
-#include <sqlpp11/wrong.h>
 #include <sqlpp11/bad_statement.h>
+#include <sqlpp11/wrong.h>
 
 namespace sqlpp
 {
@@ -54,19 +54,19 @@ namespace sqlpp
   template <typename Policies, typename Needle, typename Replacement>
   using new_statement = typename Policies::template _new_statement_t<Needle, Replacement>;
 
-  template <bool, typename Policies, typename Needle, typename Replacement>
+  template <typename Check, typename Policies, typename Needle, typename Replacement>
   struct new_statement_impl
+  {
+    using type = Check;
+  };
+
+  template <typename Policies, typename Needle, typename Replacement>
+  struct new_statement_impl<consistent_t, Policies, Needle, Replacement>
   {
     using type = typename Policies::template _new_statement_t<Needle, Replacement>;
   };
 
-  template <typename Policies, typename Needle, typename Replacement>
-  struct new_statement_impl<false, Policies, Needle, Replacement>
-  {
-    using type = bad_statement;
-  };
-
-  template <bool Check, typename Policies, typename Needle, typename Replacement>
+  template <typename Check, typename Policies, typename Needle, typename Replacement>
   using new_statement_t = typename new_statement_impl<Check, Policies, Needle, Replacement>::type;
 }
 
diff --git a/include/sqlpp11/portable_static_assert.h b/include/sqlpp11/portable_static_assert.h
index bf7d3e22..dc3b94a2 100644
--- a/include/sqlpp11/portable_static_assert.h
+++ b/include/sqlpp11/portable_static_assert.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015-2015, Roland Bock
+ * Copyright (c) 2015-2016, Roland Bock
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -34,10 +34,10 @@ namespace sqlpp
 #define SQLPP_PORTABLE_STATIC_ASSERT(name, message) \
   struct name : std::false_type                     \
   {                                                 \
-    template <typename T = void>                    \
-    static void _()                                 \
+    template <typename... T>                        \
+    name(T&&...)                                    \
     {                                               \
-      static_assert(wrong_t<T>::value, message);    \
+      static_assert(wrong_t<T...>::value, message); \
     }                                               \
   }
 
diff --git a/include/sqlpp11/pre_join.h b/include/sqlpp11/pre_join.h
index 1c765493..d0c68070 100644
--- a/include/sqlpp11/pre_join.h
+++ b/include/sqlpp11/pre_join.h
@@ -29,8 +29,8 @@
 
 #include <sqlpp11/bad_statement.h>
 #include <sqlpp11/join_types.h>
-#include <sqlpp11/on.h>
 #include <sqlpp11/noop.h>
+#include <sqlpp11/on.h>
 
 namespace sqlpp
 {
@@ -106,20 +106,19 @@ namespace sqlpp
     template <typename Expr>
     auto on(Expr expr) const -> typename std::conditional<check_join_on_t<pre_join_t, Expr>::value,
                                                           join_t<pre_join_t, on_t<Expr>>,
-                                                          bad_statement>::type
+                                                          check_join_on_t<pre_join_t, Expr>>::type
     {
       using Check = check_join_on_t<pre_join_t, Expr>;
-      Check::_();
 
       return on_impl(Check{}, expr);
     }
 
   private:
-    template <typename Expr>
-    auto on_impl(const std::false_type&, const Expr&) const -> bad_statement;
+    template <typename Check, typename Expr>
+    auto on_impl(Check, const Expr&) const -> Check;
 
     template <typename Expr>
-    auto on_impl(const std::true_type&, const Expr& expr) const -> join_t<pre_join_t, on_t<Expr>>
+    auto on_impl(consistent_t, const Expr& expr) const -> join_t<pre_join_t, on_t<Expr>>
     {
       return {*this, {expr}};
     }
@@ -146,51 +145,46 @@ namespace sqlpp
   };
 
   template <typename Lhs, typename Rhs>
-  auto join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
-                                                           pre_join_t<inner_join_t, Lhs, Rhs>,
-                                                           bad_statement>::type
+  auto join(Lhs lhs, Rhs rhs) -> typename std::
+      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<inner_join_t, Lhs, Rhs>, bad_statement>::type
   {
-    check_pre_join_t<Lhs, Rhs>::_();
+    check_pre_join_t<Lhs, Rhs>{};  // FIXME: Failure return type?
 
     return {lhs, rhs};
   }
 
   template <typename Lhs, typename Rhs>
-  auto inner_join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
-                                                                 pre_join_t<inner_join_t, Lhs, Rhs>,
-                                                                 bad_statement>::type
+  auto inner_join(Lhs lhs, Rhs rhs) -> typename std::
+      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<inner_join_t, Lhs, Rhs>, bad_statement>::type
   {
-    check_pre_join_t<Lhs, Rhs>::_();
+    check_pre_join_t<Lhs, Rhs>{};
 
     return {lhs, rhs};
   }
 
   template <typename Lhs, typename Rhs>
-  auto left_outer_join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
-                                                                      pre_join_t<left_outer_join_t, Lhs, Rhs>,
-                                                                      bad_statement>::type
+  auto left_outer_join(Lhs lhs, Rhs rhs) -> typename std::
+      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<left_outer_join_t, Lhs, Rhs>, bad_statement>::type
   {
-    check_pre_join_t<Lhs, Rhs>::_();
+    check_pre_join_t<Lhs, Rhs>{};
 
     return {lhs, rhs};
   }
 
   template <typename Lhs, typename Rhs>
-  auto right_outer_join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
-                                                                       pre_join_t<right_outer_join_t, Lhs, Rhs>,
-                                                                       bad_statement>::type
+  auto right_outer_join(Lhs lhs, Rhs rhs) -> typename std::
+      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<right_outer_join_t, Lhs, Rhs>, bad_statement>::type
   {
-    check_pre_join_t<Lhs, Rhs>::_();
+    check_pre_join_t<Lhs, Rhs>{};
 
     return {lhs, rhs};
   }
 
   template <typename Lhs, typename Rhs>
-  auto outer_join(Lhs lhs, Rhs rhs) -> typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
-                                                                 pre_join_t<outer_join_t, Lhs, Rhs>,
-                                                                 bad_statement>::type
+  auto outer_join(Lhs lhs, Rhs rhs) -> typename std::
+      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<outer_join_t, Lhs, Rhs>, bad_statement>::type
   {
-    check_pre_join_t<Lhs, Rhs>::_();
+    check_pre_join_t<Lhs, Rhs>{};
 
     return {lhs, rhs};
   }
@@ -201,7 +195,7 @@ namespace sqlpp
                                 join_t<pre_join_t<cross_join_t, Lhs, Rhs>, on_t<unconditional_t>>,
                                 bad_statement>::type
   {
-    check_pre_join_t<Lhs, Rhs>::_();
+    check_pre_join_t<Lhs, Rhs>{};
 
     return {pre_join_t<cross_join_t, Lhs, Rhs>{lhs, rhs}, {}};
   }
diff --git a/include/sqlpp11/rhs_wrap.h b/include/sqlpp11/rhs_wrap.h
index 15573b4b..4e136afe 100644
--- a/include/sqlpp11/rhs_wrap.h
+++ b/include/sqlpp11/rhs_wrap.h
@@ -27,9 +27,9 @@
 #ifndef SQLPP_RHS_WRAP_H
 #define SQLPP_RHS_WRAP_H
 
-#include <sqlpp11/tvin.h>
 #include <sqlpp11/default_value.h>
 #include <sqlpp11/null.h>
+#include <sqlpp11/tvin.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/select_column_list.h b/include/sqlpp11/select_column_list.h
index 19f79eac..e6c3c3d2 100644
--- a/include/sqlpp11/select_column_list.h
+++ b/include/sqlpp11/select_column_list.h
@@ -27,19 +27,19 @@
 #ifndef SQLPP_SELECT_COLUMN_LIST_H
 #define SQLPP_SELECT_COLUMN_LIST_H
 
-#include <tuple>
-#include <sqlpp11/result_row.h>
-#include <sqlpp11/dynamic_select_column_list.h>
-#include <sqlpp11/table.h>
 #include <sqlpp11/data_types/no_value.h>
-#include <sqlpp11/field_spec.h>
-#include <sqlpp11/expression_fwd.h>
-#include <sqlpp11/select_pseudo_table.h>
-#include <sqlpp11/named_interpretable.h>
-#include <sqlpp11/interpret_tuple.h>
-#include <sqlpp11/policy_update.h>
-#include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/detail/copy_tuple_args.h>
+#include <sqlpp11/detail/type_set.h>
+#include <sqlpp11/dynamic_select_column_list.h>
+#include <sqlpp11/expression_fwd.h>
+#include <sqlpp11/field_spec.h>
+#include <sqlpp11/interpret_tuple.h>
+#include <sqlpp11/named_interpretable.h>
+#include <sqlpp11/policy_update.h>
+#include <sqlpp11/result_row.h>
+#include <sqlpp11/select_pseudo_table.h>
+#include <sqlpp11/table.h>
+#include <tuple>
 
 namespace sqlpp
 {
@@ -135,7 +135,7 @@ namespace sqlpp
         static_assert(not detail::is_element_of<typename named_expression::_alias_t, column_names>::value,
                       "a column of this name is present in the select already");
         using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, named_expression>;
-        _serialize_check::_();
+        _serialize_check{};
 
         using ok =
             logic::all_t<_is_dynamic::value, is_selectable_t<named_expression>::value, _serialize_check::type::value>;
@@ -165,8 +165,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : selected_columns{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : selected_columns{std::forward<Args>(args)...}
       {
       }
 
@@ -249,7 +248,7 @@ namespace sqlpp
       template <typename AliasProvider>
       _alias_t<AliasProvider> as(const AliasProvider& aliasProvider) const
       {
-        consistency_check_t<_statement_t>::_();
+        consistency_check_t<_statement_t>{};
         static_assert(_statement_t::_can_be_used_as_table(),
                       "statement cannot be used as table, e.g. due to missing tables");
         static_assert(logic::none_t<is_multi_column_t<Columns>::value...>::value,
@@ -302,6 +301,17 @@ namespace sqlpp
         copy_tuple_args_t<select_column_list_t, Database, decltype(column_tuple_merge(std::declval<Columns>()...))>;
   }
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_selected_colums_are_selectable_t, "selected columns must be selectable");
+  template <typename... T>
+  struct check_selected_columns
+  {
+    using type = static_combined_check_t<
+        static_check_t<logic::all_t<(is_selectable_t<T>::value or is_multi_column_t<T>::value)...>::value,
+                       assert_selected_colums_are_selectable_t>>;
+  };
+  template <typename... T>
+  using check_selected_columns_t = typename check_selected_columns<T...>::type;
+
   struct no_select_column_list_t
   {
     using _traits = make_traits<no_value_t, tag::is_noop, tag::is_missing>;
@@ -335,8 +345,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_selected_columns{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_selected_columns{std::forward<Args>(args)...}
       {
       }
 
@@ -358,16 +367,8 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
-      //	  template <typename... T>
-      //	  using _check = logic::all_t<(is_selectable_t<T>::value or is_multi_column_t<T>::value)...>;
       template <typename... T>
-      struct _check : logic::all_t<(is_selectable_t<T>::value or is_multi_column_t<T>::value)...>
-      {
-      };
-
-      template <typename... T>
-      static constexpr auto _check_tuple(std::tuple<T...>) -> _check<T...>
+      static constexpr auto _check_tuple(std::tuple<T...>) -> check_selected_columns_t<T...>
       {
         return {};
       }
@@ -375,11 +376,11 @@ namespace sqlpp
       template <typename... T>
       static constexpr auto _check_args(T... args) -> decltype(_check_tuple(detail::column_tuple_merge(args...)))
       {
-        return _check_tuple(detail::column_tuple_merge(args...));
+        return {};
       }
 
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_select_column_list_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_select_column_list_t, T>;
 
       using _consistency_check = consistent_t;
 
@@ -391,7 +392,7 @@ namespace sqlpp
         static_assert(decltype(_check_args(args...))::value,
                       "at least one argument is not a selectable expression in columns()");
 
-        return _columns_impl<void>(_check_args(args...), detail::column_tuple_merge(args...));
+        return _columns_impl<void>(decltype(_check_args(args...)){}, detail::column_tuple_merge(args...));
       }
 
       template <typename... Args>
@@ -403,16 +404,16 @@ namespace sqlpp
         static_assert(decltype(_check_args(args...))::value,
                       "at least one argument is not a selectable expression in columns()");
 
-        return _columns_impl<_database_t>(_check_args(args...), detail::column_tuple_merge(args...));
+        return _columns_impl<_database_t>(decltype(_check_args(args...)){}, detail::column_tuple_merge(args...));
       }
 
     private:
-      template <typename Database, typename... Args>
-      auto _columns_impl(const std::false_type&, std::tuple<Args...> args) const -> bad_statement;
+      template <typename Database, typename Check, typename... Args>
+      auto _columns_impl(Check, std::tuple<Args...> args) const -> Check;
 
       template <typename Database, typename... Args>
-      auto _columns_impl(const std::true_type&, std::tuple<Args...> args) const
-          -> _new_statement_t<_check<Args...>, select_column_list_t<Database, Args...>>
+      auto _columns_impl(consistent_t, 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");
         static_assert(not detail::has_duplicates<typename Args::_alias_t...>::value,
diff --git a/include/sqlpp11/select_flag_list.h b/include/sqlpp11/select_flag_list.h
index 250c5e4d..4c87168c 100644
--- a/include/sqlpp11/select_flag_list.h
+++ b/include/sqlpp11/select_flag_list.h
@@ -27,13 +27,13 @@
 #ifndef SQLPP_SELECT_FLAG_LIST_H
 #define SQLPP_SELECT_FLAG_LIST_H
 
-#include <tuple>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/no_data.h>
-#include <sqlpp11/select_flags.h>
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/interpret_tuple.h>
+#include <sqlpp11/no_data.h>
 #include <sqlpp11/policy_update.h>
+#include <sqlpp11/select_flags.h>
+#include <sqlpp11/type_traits.h>
+#include <tuple>
 
 namespace sqlpp
 {
@@ -85,7 +85,7 @@ namespace sqlpp
         static_assert(Policies::template _no_unknown_tables<Flag>::value,
                       "flag uses tables unknown to this statement in select_flags::add()");
         using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Flag>;
-        _serialize_check::_();
+        _serialize_check{};
 
         using ok = logic::all_t<_is_dynamic::value, is_select_flag_t<Flag>::value, _serialize_check::type::value>;
 
@@ -114,8 +114,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : select_flags{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : select_flags{std::forward<Args>(args)...}
       {
       }
 
@@ -139,6 +138,16 @@ namespace sqlpp
     };
   };
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_select_flags_are_flags_t, "arguments for flags() must be known select flags");
+  template <typename... Flags>
+  struct check_select_flags
+  {
+    using type = static_combined_check_t<
+        static_check_t<logic::all_t<is_select_flag_t<Flags>::value...>::value, assert_select_flags_are_flags_t>>;
+  };
+  template <typename... Flags>
+  using check_select_flags_t = typename check_select_flags<Flags...>::type;
+
   struct no_select_flag_list_t
   {
     using _traits = make_traits<no_value_t, tag::is_noop>;
@@ -168,8 +177,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_select_flags{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_select_flags{std::forward<Args>(args)...}
       {
       }
 
@@ -191,45 +199,35 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
-      //	  template <typename... T>
-      //	  using _check = logic::all_t<is_select_flag_t<T>::value...>;
-      template <typename... T>
-      struct _check : logic::all_t<detail::is_select_flag_impl<T>::type::value...>
-      {
-      };
-
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_select_flag_list_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_select_flag_list_t, T>;
 
       using _consistency_check = consistent_t;
 
       template <typename... Flags>
-      auto flags(Flags... flgs) const -> _new_statement_t<_check<Flags...>, select_flag_list_t<void, Flags...>>
+      auto flags(Flags... flgs) const
+          -> _new_statement_t<check_select_flags_t<Flags...>, select_flag_list_t<void, Flags...>>
       {
-        static_assert(_check<Flags...>::value, "at least one argument is not a select flag in select flag list");
-
-        return _flags_impl<void>(_check<Flags...>{}, flgs...);
+        return _flags_impl<void>(check_select_flags_t<Flags...>{}, flgs...);
       }
 
       template <typename... Flags>
       auto dynamic_flags(Flags... flgs) const
-          -> _new_statement_t<_check<Flags...>, select_flag_list_t<_database_t, Flags...>>
+          -> _new_statement_t<check_select_flags_t<Flags...>, select_flag_list_t<_database_t, Flags...>>
       {
         static_assert(not std::is_same<_database_t, void>::value,
                       "dynamic_flags must not be called in a static statement");
-        static_assert(_check<Flags...>::value, "at least one argument is not a select flag in select flag list");
 
-        return _flags_impl<_database_t>(_check<Flags...>{}, flgs...);
+        return _flags_impl<_database_t>(check_select_flags_t<Flags...>{}, flgs...);
       }
 
     private:
-      template <typename Database, typename... Flags>
-      auto _flags_impl(const std::false_type&, Flags... flgs) const -> bad_statement;
+      template <typename Database, typename Check, typename... Flags>
+      auto _flags_impl(Check, Flags... flgs) const -> Check;
 
       template <typename Database, typename... Flags>
-      auto _flags_impl(const std::true_type&, Flags... flgs) const
-          -> _new_statement_t<std::true_type, select_flag_list_t<Database, Flags...>>
+      auto _flags_impl(consistent_t, Flags... flgs) const
+          -> _new_statement_t<consistent_t, select_flag_list_t<Database, Flags...>>
       {
         static_assert(not detail::has_duplicates<Flags...>::value,
                       "at least one duplicate argument detected in select flag list");
diff --git a/include/sqlpp11/serializer.h b/include/sqlpp11/serializer.h
index 14f9a884..301d95af 100644
--- a/include/sqlpp11/serializer.h
+++ b/include/sqlpp11/serializer.h
@@ -27,8 +27,8 @@
 #ifndef SQLPP_SERIALIZER_H
 #define SQLPP_SERIALIZER_H
 
-#include <sqlpp11/wrong.h>
 #include <sqlpp11/portable_static_assert.h>
+#include <sqlpp11/wrong.h>
 
 namespace sqlpp
 {
@@ -41,7 +41,7 @@ namespace sqlpp
 
     static void _(const T&, Context&)
     {
-      _serialize_check::_();
+      _serialize_check{};
     }
   };
 }
diff --git a/include/sqlpp11/statement.h b/include/sqlpp11/statement.h
index 286e6cec..34af1dcc 100644
--- a/include/sqlpp11/statement.h
+++ b/include/sqlpp11/statement.h
@@ -27,12 +27,12 @@
 #ifndef SQLPP_STATEMENT_H
 #define SQLPP_STATEMENT_H
 
-#include <sqlpp11/result.h>
-#include <sqlpp11/parameter_list.h>
-#include <sqlpp11/prepared_select.h>
-#include <sqlpp11/serialize.h>
 #include <sqlpp11/noop.h>
+#include <sqlpp11/parameter_list.h>
 #include <sqlpp11/policy_update.h>
+#include <sqlpp11/prepared_select.h>
+#include <sqlpp11/result.h>
+#include <sqlpp11/serialize.h>
 #include <sqlpp11/serializer.h>
 
 #include <sqlpp11/detail/get_first.h>
@@ -142,9 +142,8 @@ namespace sqlpp
           typename std::conditional<_required_ctes::size::value == 0, consistent_t, assert_no_unknown_ctes_t>::type;
       using _table_check =
           typename std::conditional<_required_tables::size::value == 0, consistent_t, assert_no_unknown_tables_t>::type;
-      using _parameter_check = typename std::conditional<detail::type_vector_size<_parameters>::value == 0,
-                                                         consistent_t,
-                                                         assert_no_parameters_t>::type;
+      using _parameter_check = typename std::
+          conditional<detail::type_vector_size<_parameters>::value == 0, consistent_t, assert_no_parameters_t>::type;
     };
   }
 
@@ -235,14 +234,14 @@ namespace sqlpp
     template <typename Database>
     auto _run(Database& db) const -> decltype(std::declval<_result_methods_t<statement_t>>()._run(db))
     {
-      _run_check::_();
+      _run_check{};  // FIXME: Dispatch?
       return _result_methods_t<statement_t>::_run(db);
     }
 
     template <typename Database>
     auto _prepare(Database& db) const -> decltype(std::declval<_result_methods_t<statement_t>>()._prepare(db))
     {
-      _prepare_check::_();
+      _prepare_check{};  // FIXME: Dispatch?
       return _result_methods_t<statement_t>::_prepare(db);
     }
   };
@@ -294,8 +293,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : statement_name{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : statement_name{std::forward<Args>(args)...}
       {
       }
 
diff --git a/include/sqlpp11/tvin.h b/include/sqlpp11/tvin.h
index 40e01e1c..efe0f2b1 100644
--- a/include/sqlpp11/tvin.h
+++ b/include/sqlpp11/tvin.h
@@ -29,9 +29,9 @@
 
 // TVIN: Trivial value is NULL
 
-#include <sqlpp11/type_traits.h>
 #include <sqlpp11/serialize.h>
 #include <sqlpp11/serializer.h>
+#include <sqlpp11/type_traits.h>
 #include <sqlpp11/wrap_operand.h>
 
 namespace sqlpp
@@ -67,7 +67,7 @@ namespace sqlpp
 
     static Context& _(const T&, Context&)
     {
-      _serialize_check::_();
+      _serialize_check{};
     }
   };
 
diff --git a/include/sqlpp11/update_list.h b/include/sqlpp11/update_list.h
index c7dc360c..40610f12 100644
--- a/include/sqlpp11/update_list.h
+++ b/include/sqlpp11/update_list.h
@@ -27,10 +27,10 @@
 #ifndef SQLPP_UPDATE_LIST_H
 #define SQLPP_UPDATE_LIST_H
 
-#include <sqlpp11/type_traits.h>
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/interpretable_list.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -89,7 +89,7 @@ namespace sqlpp
         static_assert(Policies::template _no_unknown_tables<Assignment>::value,
                       "assignment uses tables unknown to this statement in add()");
         using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Assignment>;
-        _serialize_check::_();
+        _serialize_check{};
 
         using ok = logic::all_t<_is_dynamic::value, is_assignment_t<Assignment>::value, _serialize_check::type::value>;
 
@@ -118,8 +118,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : assignments{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : assignments{std::forward<Args>(args)...}
       {
       }
 
@@ -228,8 +227,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_assignments{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_assignments{std::forward<Args>(args)...}
       {
       }
 
diff --git a/include/sqlpp11/using.h b/include/sqlpp11/using.h
index 4f9e7dbe..23090f57 100644
--- a/include/sqlpp11/using.h
+++ b/include/sqlpp11/using.h
@@ -27,11 +27,11 @@
 #ifndef SQLPP_USING_H
 #define SQLPP_USING_H
 
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/interpretable_list.h>
-#include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/detail/type_set.h>
+#include <sqlpp11/interpret_tuple.h>
+#include <sqlpp11/interpretable_list.h>
 #include <sqlpp11/policy_update.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -81,7 +81,7 @@ namespace sqlpp
         static_assert(_is_dynamic::value, "add must not be called for static using()");
         static_assert(is_table_t<Table>::value, "invalid table argument in add()");
         using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Table>;
-        _serialize_check::_();
+        _serialize_check{};
 
         using ok = logic::all_t<_is_dynamic::value, is_table_t<Table>::value, _serialize_check::type::value>;
 
@@ -110,8 +110,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : using_{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : using_{std::forward<Args>(args)...}
       {
       }
 
@@ -166,8 +165,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_using{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_using{std::forward<Args>(args)...}
       {
       }
 
diff --git a/include/sqlpp11/where.h b/include/sqlpp11/where.h
index 4d41f2b8..93b7e45a 100644
--- a/include/sqlpp11/where.h
+++ b/include/sqlpp11/where.h
@@ -94,7 +94,7 @@ namespace sqlpp
         static_assert(not contains_aggregate_function_t<Expr>::value,
                       "where expression must not contain aggregate functions");
         using _serialize_check = sqlpp::serialize_check_t<typename Database::_serializer_context_t, Expr>;
-        _serialize_check::_();
+        _serialize_check{};
 
         using ok = logic::all_t<_is_dynamic::value, is_expression_t<Expr>::value, _serialize_check::type::value>;
 
@@ -307,14 +307,14 @@ namespace sqlpp
       using _database_t = typename Policies::_database_t;
 
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_where_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_where_t, T>;
 
       using _consistency_check =
           typename std::conditional<WhereRequired and (Policies::_all_provided_tables::size::value > 0),
                                     assert_where_t,
                                     consistent_t>::type;
 
-      auto unconditionally() const -> _new_statement_t<std::true_type, where_t<void, unconditional_t>>
+      auto unconditionally() const -> _new_statement_t<consistent_t, where_t<void, unconditional_t>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this), where_data_t<void, unconditional_t>{}};
       }
@@ -324,8 +324,6 @@ namespace sqlpp
           -> _new_statement_t<check_where_static_t<Expression>, where_t<void, Expression>>
       {
         using Check = check_where_static_t<Expression>;
-        Check{}._();
-
         return _where_impl<void>(Check{}, expression);
       }
 
@@ -334,8 +332,6 @@ namespace sqlpp
           -> _new_statement_t<check_where_dynamic_t<_database_t, Expression>, where_t<_database_t, Expression>>
       {
         using Check = check_where_dynamic_t<_database_t, Expression>;
-        Check{}._();
-
         return _where_impl<_database_t>(Check{}, expression);
       }
 
@@ -346,12 +342,12 @@ namespace sqlpp
       }
 
     private:
-      template <typename Database, typename Expression>
-      auto _where_impl(const std::false_type&, Expression expression) const -> bad_statement;
+      template <typename Database, typename Check, typename Expression>
+      auto _where_impl(Check, Expression expression) const -> Check;
 
       template <typename Database, typename Expression>
-      auto _where_impl(const std::true_type&, Expression expression) const
-          -> _new_statement_t<std::true_type, where_t<Database, Expression>>
+      auto _where_impl(consistent_t, Expression expression) const
+          -> _new_statement_t<consistent_t, where_t<Database, Expression>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
                 where_data_t<Database, Expression>{expression}};
diff --git a/include/sqlpp11/with.h b/include/sqlpp11/with.h
index 4f7e3042..a9880af3 100644
--- a/include/sqlpp11/with.h
+++ b/include/sqlpp11/with.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015, Roland Bock
+ * Copyright (c) 2013-2016, Roland Bock
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -29,15 +29,15 @@
 
 #include <sqlpp11/assignment.h>
 #include <sqlpp11/column_fwd.h>
-#include <sqlpp11/statement_fwd.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/no_data.h>
-#include <sqlpp11/policy_update.h>
-#include <sqlpp11/parameter_list.h>
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/interpretable_list.h>
 #include <sqlpp11/logic.h>
+#include <sqlpp11/no_data.h>
+#include <sqlpp11/parameter_list.h>
+#include <sqlpp11/policy_update.h>
+#include <sqlpp11/statement_fwd.h>
+#include <sqlpp11/type_traits.h>
 
 #include <sqlpp11/cte.h>
 
@@ -96,8 +96,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : with{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : with{std::forward<Args>(args)...}
       {
       }
 
@@ -151,8 +150,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_with{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_with{std::forward<Args>(args)...}
       {
       }
 
@@ -183,7 +181,7 @@ namespace sqlpp
 
     template <typename Statement>
     auto operator()(Statement statement)
-        -> new_statement_t<true, typename Statement::_policies_t, no_with_t, with_t<Database, Expressions...>>
+        -> new_statement_t<consistent_t, typename Statement::_policies_t, no_with_t, with_t<Database, Expressions...>>
     {
       // FIXME need checks here
       //       check that no cte refers to any of the ctes to the right
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index df9335c6..57887c34 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -30,21 +30,21 @@ target_compile_options(sqlpp11_testing INTERFACE -Wall -Wextra -pedantic)
 endif ()
 
 set(test_names
-  BooleanExpression
-  CustomQuery
-  DateTime
-  Interpret
-  Insert
-  Remove
-  Update
+  #BooleanExpression
+  #CustomQuery
+  #DateTime
+  #Interpret
+  #Insert
+  #Remove
+  #Update
   Select
-  SelectType
-  Function
-  Prepared
-  Minimalistic
-  Result
-  Union
-  With
+  #SelectType
+  #Function
+  #Prepared
+  #Minimalistic
+  #Result
+  #Union
+  #With
   )
 
 create_test_sourcelist(test_sources test_main.cpp ${test_names})
diff --git a/tests/MockDb.h b/tests/MockDb.h
index de055377..6e9dece4 100644
--- a/tests/MockDb.h
+++ b/tests/MockDb.h
@@ -26,13 +26,13 @@
 #ifndef SQLPP_MOCK_DB_H
 #define SQLPP_MOCK_DB_H
 
-#include <sstream>
 #include <iostream>
-#include <sqlpp11/schema.h>
+#include <sqlpp11/connection.h>
 #include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/schema.h>
 #include <sqlpp11/serialize.h>
 #include <sqlpp11/serializer_context.h>
-#include <sqlpp11/connection.h>
+#include <sstream>
 
 template <bool enforceNullResultTreatment>
 struct MockDbT : public sqlpp::connection
@@ -111,18 +111,17 @@ struct MockDbT : public sqlpp::connection
 
   // Directly executed statements start here
   template <typename T>
-  auto _run(const T& t, const std::true_type&) -> decltype(t._run(*this))
+  auto _run(const T& t, ::sqlpp::consistent_t) -> decltype(t._run(*this))
   {
     return t._run(*this);
   }
 
-  template <typename T>
-  auto _run(const T& t, const std::false_type&) -> void;
+  template <typename Check, typename T>
+  auto _run(const T& t, Check) -> Check;
 
   template <typename T>
   auto operator()(const T& t) -> decltype(this->_run(t, sqlpp::run_check_t<_serializer_context_t, T>{}))
   {
-    sqlpp::run_check_t<_serializer_context_t, T>::_();
     return _run(t, sqlpp::run_check_t<_serializer_context_t, T>{});
   }
 
@@ -182,18 +181,17 @@ struct MockDbT : public sqlpp::connection
   using _prepared_statement_t = std::nullptr_t;
 
   template <typename T>
-  auto _prepare(const T& t, const std::true_type&) -> decltype(t._prepare(*this))
+  auto _prepare(const T& t, ::sqlpp::consistent_t) -> decltype(t._prepare(*this))
   {
     return t._prepare(*this);
   }
 
-  template <typename T>
-  auto _prepare(const T& t, const std::false_type&) -> void;
+  template <typename Check, typename T>
+  auto _prepare(const T& t, Check) -> Check;
 
   template <typename T>
   auto prepare(const T& t) -> decltype(this->_prepare(t, sqlpp::prepare_check_t<_serializer_context_t, T>{}))
   {
-    sqlpp::prepare_check_t<_serializer_context_t, T>::_();
     return _prepare(t, sqlpp::prepare_check_t<_serializer_context_t, T>{});
   }
 
diff --git a/tests/Select.cpp b/tests/Select.cpp
index f8ccd287..c60fb4e4 100644
--- a/tests/Select.cpp
+++ b/tests/Select.cpp
@@ -122,8 +122,8 @@ int Select(int, char* [])
                   .group_by(t.alpha)
                   .order_by(t.gamma.asc())
                   .having(t.gamma)
-                  .limit(7)
-                  .offset(19);
+                  .offset(19)
+                  .limit(7);
   printer.reset();
   std::cerr << serialize(stat, printer).str() << std::endl;
 

From 36afa04bcd9dbe17cf737fbd48314e36d4e94460 Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Thu, 1 Sep 2016 12:51:04 +0200
Subject: [PATCH 02/11] Adjusted insert to use wrapped asserts as failure
 return

---
 include/sqlpp11/insert_value_list.h | 49 ++++++++++++++---------------
 include/sqlpp11/into.h              | 37 ++++++++++++----------
 tests/CMakeLists.txt                |  4 +--
 tests/Insert.cpp                    |  6 ++--
 4 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/include/sqlpp11/insert_value_list.h b/include/sqlpp11/insert_value_list.h
index 18bfde95..5e16bfe5 100644
--- a/include/sqlpp11/insert_value_list.h
+++ b/include/sqlpp11/insert_value_list.h
@@ -426,6 +426,16 @@ namespace sqlpp
 
   SQLPP_PORTABLE_STATIC_ASSERT(assert_insert_values_t, "insert values required, e.g. set(...) or default_values()");
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_insert_columns_are_columns, "arguments for columns() must be table columns");
+  template <typename... Columns>
+  struct check_insert_columns
+  {
+    using type = static_combined_check_t<
+        static_check_t<logic::all_t<is_column_t<Columns>::value...>::value, assert_insert_columns_are_columns>>;
+  };
+  template <typename... Columns>
+  using check_insert_columns_t = typename check_insert_columns<Columns...>::type;
+
   // NO INSERT COLUMNS/VALUES YET
   struct no_insert_value_list_t
   {
@@ -478,32 +488,23 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
-      //	  template <typename... T>
-      //	  using _column_check = logic::all_t<is_column_t<T>::value...>;
-      template <typename... T>
-      struct _column_check : logic::all_t<is_column_t<T>::value...>
-      {
-      };
-
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_insert_value_list_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_insert_value_list_t, T>;
 
       using _consistency_check = assert_insert_values_t;
 
-      auto default_values() const -> _new_statement_t<std::true_type, insert_default_values_t>
+      auto default_values() const -> _new_statement_t<consistent_t, insert_default_values_t>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this), insert_default_values_data_t{}};
       }
 
       template <typename... Columns>
-      auto columns(Columns... cols) const -> _new_statement_t<_column_check<Columns...>, column_list_t<Columns...>>
+      auto columns(Columns... cols) const
+          -> _new_statement_t<check_insert_columns_t<Columns...>, column_list_t<Columns...>>
       {
-        static_assert(logic::all_t<is_column_t<Columns>::value...>::value,
-                      "at least one argument is not a column in columns()");
         static_assert(sizeof...(Columns), "at least one column required in columns()");
 
-        return _columns_impl(_column_check<Columns...>{}, cols...);
+        return _columns_impl(check_insert_columns_t<Columns...>{}, cols...);
       }
 
       template <typename... Assignments>
@@ -511,8 +512,6 @@ namespace sqlpp
           -> _new_statement_t<check_insert_static_set_t<Assignments...>, insert_list_t<void, Assignments...>>
       {
         using Check = check_insert_static_set_t<Assignments...>;
-        Check{}._();
-
         return _set_impl<void>(Check{}, assignments...);
       }
 
@@ -522,18 +521,16 @@ namespace sqlpp
                               insert_list_t<_database_t, Assignments...>>
       {
         using Check = check_insert_dynamic_set_t<_database_t, Assignments...>;
-        Check{}._();
-
         return _set_impl<_database_t>(Check{}, assignments...);
       }
 
     private:
-      template <typename... Columns>
-      auto _columns_impl(const std::false_type&, Columns... cols) const -> bad_statement;
+      template <typename Check, typename... Columns>
+      auto _columns_impl(Check, Columns... cols) const -> Check;
 
       template <typename... Columns>
-      auto _columns_impl(const std::true_type&, Columns... cols) const
-          -> _new_statement_t<std::true_type, column_list_t<Columns...>>
+      auto _columns_impl(consistent_t, Columns... cols) const
+          -> _new_statement_t<consistent_t, column_list_t<Columns...>>
       {
         static_assert(not detail::has_duplicates<Columns...>::value,
                       "at least one duplicate argument detected in columns()");
@@ -548,12 +545,12 @@ namespace sqlpp
         return {static_cast<const derived_statement_t<Policies>&>(*this), column_list_data_t<Columns...>{cols...}};
       }
 
-      template <typename Database, typename... Assignments>
-      auto _set_impl(std::false_type, Assignments... assignments) const -> bad_statement;
+      template <typename Database, typename Check, typename... Assignments>
+      auto _set_impl(Check, Assignments... assignments) const -> Check;
 
       template <typename Database, typename... Assignments>
-      auto _set_impl(std::true_type, Assignments... assignments) const
-          -> _new_statement_t<std::true_type, insert_list_t<Database, Assignments...>>
+      auto _set_impl(consistent_t, Assignments... assignments) const
+          -> _new_statement_t<consistent_t, insert_list_t<Database, Assignments...>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
                 insert_list_data_t<Database, Assignments...>{assignments...}};
diff --git a/include/sqlpp11/into.h b/include/sqlpp11/into.h
index 308dec6b..e0489443 100644
--- a/include/sqlpp11/into.h
+++ b/include/sqlpp11/into.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015, Roland Bock
+ * Copyright (c) 2013-2016, Roland Bock
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -27,13 +27,13 @@
 #ifndef SQLPP_INTO_H
 #define SQLPP_INTO_H
 
-#include <sqlpp11/statement_fwd.h>
-#include <sqlpp11/type_traits.h>
 #include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/no_data.h>
 #include <sqlpp11/prepared_insert.h>
 #include <sqlpp11/serializer.h>
-#include <sqlpp11/detail/type_set.h>
+#include <sqlpp11/statement_fwd.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -88,8 +88,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2091069
       template <typename... Args>
-      _base_t(Args&&... args)
-          : into{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : into{std::forward<Args>(args)...}
       {
       }
 
@@ -115,6 +114,15 @@ namespace sqlpp
 
   SQLPP_PORTABLE_STATIC_ASSERT(assert_into_t, "into() required");
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_into_arg_is_table, "argument for into() must be a table");
+  template <typename T>
+  struct check_into
+  {
+    using type = static_combined_check_t<static_check_t<is_raw_table_t<T>::value, assert_into_arg_is_table>>;
+  };
+  template <typename T>
+  using check_into_t = typename check_into<wrap_operand_t<T>>::type;
+
   // NO INTO YET
   struct no_into_t
   {
@@ -155,28 +163,23 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      template <typename T>
-      using _check = logic::all_t<is_raw_table_t<T>::value>;
-
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_into_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_into_t, T>;
 
       using _consistency_check = assert_into_t;
 
       template <typename Table>
-      auto into(Table table) const -> _new_statement_t<_check<Table>, into_t<void, Table>>
+      auto into(Table table) const -> _new_statement_t<check_into_t<Table>, into_t<void, Table>>
       {
-        static_assert(_check<Table>::value, "argument is not a raw table in into()");
-        return _into_impl<void>(_check<Table>{}, table);
+        return _into_impl<void>(check_into_t<Table>{}, table);
       }
 
     private:
-      template <typename Database, typename Table>
-      auto _into_impl(const std::false_type&, Table table) const -> bad_statement;
+      template <typename Database, typename Check, typename Table>
+      auto _into_impl(Check, Table table) const -> Check;
 
       template <typename Database, typename Table>
-      auto _into_impl(const std::true_type&, Table table) const
-          -> _new_statement_t<std::true_type, into_t<Database, Table>>
+      auto _into_impl(consistent_t, 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()");
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 57887c34..032bf09a 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -34,10 +34,10 @@ set(test_names
   #CustomQuery
   #DateTime
   #Interpret
-  #Insert
+  Insert
   #Remove
   #Update
-  Select
+  #Select
   #SelectType
   #Function
   #Prepared
diff --git a/tests/Insert.cpp b/tests/Insert.cpp
index 0635f564..0c6e61b7 100644
--- a/tests/Insert.cpp
+++ b/tests/Insert.cpp
@@ -23,12 +23,12 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "Sample.h"
 #include "MockDb.h"
+#include "Sample.h"
 #include "is_regular.h"
-#include <sqlpp11/insert.h>
-#include <sqlpp11/functions.h>
 #include <iostream>
+#include <sqlpp11/functions.h>
+#include <sqlpp11/insert.h>
 
 int Insert(int, char* [])
 {

From 637e0ad4d97e07db5c76798128ba8707b517120c Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Thu, 1 Sep 2016 18:22:19 +0200
Subject: [PATCH 03/11] Better failure return types for update and remove

---
 include/sqlpp11/select_pseudo_table.h |  3 +-
 include/sqlpp11/single_table.h        | 41 ++++++++++++---------
 include/sqlpp11/update_list.h         | 14 +++----
 include/sqlpp11/using.h               | 53 ++++++++++++++-------------
 tests/CMakeLists.txt                  |  4 +-
 5 files changed, 59 insertions(+), 56 deletions(-)

diff --git a/include/sqlpp11/select_pseudo_table.h b/include/sqlpp11/select_pseudo_table.h
index 196c5e10..679019e2 100644
--- a/include/sqlpp11/select_pseudo_table.h
+++ b/include/sqlpp11/select_pseudo_table.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015, Roland Bock
+ * Copyright (c) 2013-2016, Roland Bock
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -28,6 +28,7 @@
 #define SQLPP_SELECT_PSEUDO_TABLE_H
 
 #include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/table.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/single_table.h b/include/sqlpp11/single_table.h
index 1823346d..ee16289e 100644
--- a/include/sqlpp11/single_table.h
+++ b/include/sqlpp11/single_table.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015, Roland Bock
+ * Copyright (c) 2013-2016, Roland Bock
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -27,12 +27,12 @@
 #ifndef SQLPP_SINGLE_TABLE_H
 #define SQLPP_SINGLE_TABLE_H
 
-#include <sqlpp11/type_traits.h>
 #include <sqlpp11/data_types/no_value.h>
-#include <sqlpp11/no_data.h>
-#include <sqlpp11/serializer.h>
-#include <sqlpp11/prepared_insert.h>
 #include <sqlpp11/detail/type_set.h>
+#include <sqlpp11/no_data.h>
+#include <sqlpp11/prepared_insert.h>
+#include <sqlpp11/serializer.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -90,8 +90,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : from{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : from{std::forward<Args>(args)...}
       {
       }
 
@@ -115,7 +114,16 @@ namespace sqlpp
     };
   };
 
-  // NO INTO YET
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_update_table_arg_is_table_t, "argument for update() must be a table");
+  template <typename Table>
+  struct check_update_table
+  {
+    using type = static_combined_check_t<static_check_t<is_table_t<Table>::value, assert_update_table_arg_is_table_t>>;
+  };
+  template <typename Table>
+  using check_update_table_t = typename check_update_table<Table>::type;
+
+  // NO TABLE YET
   struct no_single_table_t
   {
     using _traits = make_traits<no_value_t, tag::is_noop>;
@@ -154,28 +162,25 @@ namespace sqlpp
       }
 
       using _database_t = typename Policies::_database_t;
-      template <typename T>
-      using _check = logic::all_t<is_table_t<T>::value>;
 
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_single_table_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_single_table_t, T>;
 
       using _consistency_check = consistent_t;
 
       template <typename Table>
-      auto single_table(Table table) const -> _new_statement_t<_check<Table>, single_table_t<void, Table>>
+      auto single_table(Table table) const -> _new_statement_t<check_update_table_t<Table>, single_table_t<void, Table>>
       {
-        static_assert(_check<Table>::value, "argument is not a table in single_table()");
-        return _single_table_impl<void>(_check<Table>{}, table);
+        return _single_table_impl<void>(check_update_table_t<Table>{}, table);
       }
 
     private:
-      template <typename Database, typename Table>
-      auto _single_table_impl(const std::false_type&, Table table) const -> bad_statement;
+      template <typename Database, typename Check, typename Table>
+      auto _single_table_impl(Check, Table table) const -> Check;
 
       template <typename Database, typename Table>
-      auto _single_table_impl(const std::true_type&, Table table) const
-          -> _new_statement_t<std::true_type, single_table_t<Database, Table>>
+      auto _single_table_impl(consistent_t, 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,
                       "argument depends on another table in single_table()");
diff --git a/include/sqlpp11/update_list.h b/include/sqlpp11/update_list.h
index 40610f12..63e19af9 100644
--- a/include/sqlpp11/update_list.h
+++ b/include/sqlpp11/update_list.h
@@ -250,7 +250,7 @@ namespace sqlpp
       using _database_t = typename Policies::_database_t;
 
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_update_list_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_update_list_t, T>;
 
       using _consistency_check = assert_update_assignments_t;
 
@@ -259,8 +259,6 @@ namespace sqlpp
           -> _new_statement_t<check_update_static_set_t<Assignments...>, update_list_t<void, Assignments...>>
       {
         using Check = check_update_static_set_t<Assignments...>;
-        Check{}._();
-
         return _set_impl<void>(Check{}, assignments...);
       }
 
@@ -270,18 +268,16 @@ namespace sqlpp
                               update_list_t<_database_t, Assignments...>>
       {
         using Check = check_update_dynamic_set_t<_database_t, Assignments...>;
-        Check{}._();
-
         return _set_impl<_database_t>(Check{}, assignments...);
       }
 
     private:
-      template <typename Database, typename... Assignments>
-      auto _set_impl(const std::false_type&, Assignments... assignments) const -> bad_statement;
+      template <typename Database, typename Check, typename... Assignments>
+      auto _set_impl(Check, Assignments... assignments) const -> Check;
 
       template <typename Database, typename... Assignments>
-      auto _set_impl(const std::true_type&, Assignments... assignments) const
-          -> _new_statement_t<std::true_type, update_list_t<Database, Assignments...>>
+      auto _set_impl(consistent_t, Assignments... assignments) const
+          -> _new_statement_t<consistent_t, update_list_t<Database, Assignments...>>
       {
         return {static_cast<const derived_statement_t<Policies>&>(*this),
                 update_list_data_t<Database, Assignments...>{assignments...}};
diff --git a/include/sqlpp11/using.h b/include/sqlpp11/using.h
index 23090f57..e09c5f4b 100644
--- a/include/sqlpp11/using.h
+++ b/include/sqlpp11/using.h
@@ -135,6 +135,16 @@ namespace sqlpp
     };
   };
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_using_args_are_tables_t, "arguments for using() must be tables");
+  template <typename... Tables>
+  struct check_using
+  {
+    using type = static_combined_check_t<
+        static_check_t<logic::all_t<is_table_t<Tables>::value...>::value, assert_using_args_are_tables_t>>;
+  };
+  template <typename... Tables>
+  using check_using_t = typename check_using<Tables...>::type;
+
   // NO USING YET
   struct no_using_t
   {
@@ -187,52 +197,43 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
-      //	  template <typename... T>
-      //	  using _check = logic::all_t<is_table_t<T>::value...>;
-      template <typename... T>
-      struct _check : logic::all_t<is_table_t<T>::value...>
-      {
-      };
-
       template <typename Check, typename T>
-      using _new_statement_t = new_statement_t<Check::value, Policies, no_using_t, T>;
+      using _new_statement_t = new_statement_t<Check, Policies, no_using_t, T>;
 
       using _consistency_check = consistent_t;
 
-      template <typename... Args>
-      auto using_(Args... args) const -> _new_statement_t<_check<Args...>, using_t<void, Args...>>
+      template <typename... Tables>
+      auto using_(Tables... tables) const -> _new_statement_t<check_using_t<Tables...>, using_t<void, Tables...>>
       {
-        static_assert(not detail::has_duplicates<Args...>::value,
+        static_assert(not detail::has_duplicates<Tables...>::value,
                       "at least one duplicate argument detected in using()");
-        static_assert(sizeof...(Args), "at least one table required in using()");
-        static_assert(_check<Args...>::value, "at least one argument is not an table in using()");
+        static_assert(sizeof...(Tables), "at least one table required in using()");
 
-        return {_using_impl<void>(_check<Args...>{}, args...)};
+        return {_using_impl<void>(check_using_t<Tables...>{}, tables...)};
       }
 
-      template <typename... Args>
-      auto dynamic_using(Args... args) const -> _new_statement_t<_check<Args...>, using_t<_database_t, Args...>>
+      template <typename... Tables>
+      auto dynamic_using(Tables... tables) const
+          -> _new_statement_t<check_using_t<Tables...>, using_t<_database_t, Tables...>>
       {
         static_assert(not std::is_same<_database_t, void>::value,
                       "dynamic_using must not be called in a static statement");
-        static_assert(_check<Args...>::value, "at least one argument is not an table in using()");
 
-        return {_using_impl<_database_t>(_check<Args...>{}, args...)};
+        return {_using_impl<_database_t>(check_using_t<Tables...>{}, tables...)};
       }
 
     private:
-      template <typename Database, typename... Args>
-      auto _using_impl(const std::false_type&, Args... args) const -> bad_statement;
+      template <typename Database, typename Check, typename... Tables>
+      auto _using_impl(Check, Tables... tables) const -> Check;
 
-      template <typename Database, typename... Args>
-      auto _using_impl(const std::true_type&, Args... args) const
-          -> _new_statement_t<std::true_type, using_t<_database_t, Args...>>
+      template <typename Database, typename... Tables>
+      auto _using_impl(consistent_t, Tables... tables) const
+          -> _new_statement_t<consistent_t, using_t<_database_t, Tables...>>
       {
-        static_assert(not detail::has_duplicates<Args...>::value,
+        static_assert(not detail::has_duplicates<Tables...>::value,
                       "at least one duplicate argument detected in using()");
 
-        return {static_cast<const derived_statement_t<Policies>&>(*this), using_data_t<Database, Args...>{args...}};
+        return {static_cast<const derived_statement_t<Policies>&>(*this), using_data_t<Database, Tables...>{tables...}};
       }
     };
   };
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 032bf09a..39fbad16 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -34,9 +34,9 @@ set(test_names
   #CustomQuery
   #DateTime
   #Interpret
-  Insert
+  #Insert
   #Remove
-  #Update
+  Update
   #Select
   #SelectType
   #Function

From 1a0f0ea0abdfe4a2197787ab5f6a404e99f9f1bd Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Thu, 1 Sep 2016 21:38:36 +0200
Subject: [PATCH 04/11] Everything compiles again.

---
 include/sqlpp11/policy_update.h        |   1 -
 include/sqlpp11/pre_join.h             |  68 +++++++-------
 include/sqlpp11/union.h                |  49 +++++-----
 test_static_asserts/aggregates.cpp     | 121 ++++++++++++-------------
 test_static_asserts/case.cpp           |  10 +-
 test_static_asserts/from.cpp           |  11 +--
 test_static_asserts/having.cpp         |  10 +-
 test_static_asserts/insert.cpp         |  12 +--
 test_static_asserts/join.cpp           |  36 +++-----
 test_static_asserts/unwrapped_bool.cpp |   7 +-
 test_static_asserts/update_list.cpp    |  10 +-
 test_static_asserts/where.cpp          |  10 +-
 tests/CMakeLists.txt                   |   4 +-
 13 files changed, 162 insertions(+), 187 deletions(-)

diff --git a/include/sqlpp11/policy_update.h b/include/sqlpp11/policy_update.h
index b1cafabc..70070e13 100644
--- a/include/sqlpp11/policy_update.h
+++ b/include/sqlpp11/policy_update.h
@@ -27,7 +27,6 @@
 #ifndef SQLPP_POLICY_UPDATE_H
 #define SQLPP_POLICY_UPDATE_H
 
-#include <sqlpp11/bad_statement.h>
 #include <sqlpp11/wrong.h>
 
 namespace sqlpp
diff --git a/include/sqlpp11/pre_join.h b/include/sqlpp11/pre_join.h
index d0c68070..86b84c92 100644
--- a/include/sqlpp11/pre_join.h
+++ b/include/sqlpp11/pre_join.h
@@ -27,7 +27,6 @@
 #ifndef SQLPP_PRE_JOIN_H
 #define SQLPP_PRE_JOIN_H
 
-#include <sqlpp11/bad_statement.h>
 #include <sqlpp11/join_types.h>
 #include <sqlpp11/noop.h>
 #include <sqlpp11/on.h>
@@ -144,18 +143,38 @@ namespace sqlpp
     }
   };
 
-  template <typename Lhs, typename Rhs>
-  auto join(Lhs lhs, Rhs rhs) -> typename std::
-      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<inner_join_t, Lhs, Rhs>, bad_statement>::type
+  namespace detail
   {
-    check_pre_join_t<Lhs, Rhs>{};  // FIXME: Failure return type?
+    template <typename JoinType, typename Check, typename Lhs, typename Rhs>
+    auto join_impl(Check, Lhs lhs, Rhs rhs) -> Check;
 
+    template <typename JoinType, typename Lhs, typename Rhs>
+    auto join_impl(consistent_t, Lhs lhs, Rhs rhs) -> pre_join_t<JoinType, Lhs, Rhs>;
+
+    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));
+  }
+
+  template <typename Lhs, typename Rhs>
+  auto join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<inner_join_t>(lhs, rhs))
+  {
     return {lhs, rhs};
   }
 
   template <typename Lhs, typename Rhs>
-  auto inner_join(Lhs lhs, Rhs rhs) -> typename std::
-      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<inner_join_t, Lhs, Rhs>, bad_statement>::type
+  auto inner_join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<inner_join_t>(lhs, rhs))
+  {
+    return {lhs, rhs};
+  }
+
+  template <typename Lhs, typename Rhs>
+  auto left_outer_join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<left_outer_join_t>(lhs, rhs))
+  {
+    return {lhs, rhs};
+  }
+
+  template <typename Lhs, typename Rhs>
+  auto right_outer_join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<right_outer_join_t>(lhs, rhs))
   {
     check_pre_join_t<Lhs, Rhs>{};
 
@@ -163,40 +182,27 @@ namespace sqlpp
   }
 
   template <typename Lhs, typename Rhs>
-  auto left_outer_join(Lhs lhs, Rhs rhs) -> typename std::
-      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<left_outer_join_t, Lhs, Rhs>, bad_statement>::type
+  auto outer_join(Lhs lhs, Rhs rhs) -> decltype(detail::join_impl<outer_join_t>(lhs, rhs))
   {
-    check_pre_join_t<Lhs, Rhs>{};
-
     return {lhs, rhs};
   }
 
-  template <typename Lhs, typename Rhs>
-  auto right_outer_join(Lhs lhs, Rhs rhs) -> typename std::
-      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<right_outer_join_t, Lhs, Rhs>, bad_statement>::type
+  namespace detail
   {
-    check_pre_join_t<Lhs, Rhs>{};
+    template <typename Check, typename Lhs, typename Rhs>
+    auto cross_join_impl(Check, Lhs lhs, Rhs rhs) -> Check;
 
-    return {lhs, rhs};
+    template <typename Lhs, typename Rhs>
+    auto cross_join_impl(consistent_t, Lhs lhs, Rhs rhs)
+        -> join_t<pre_join_t<cross_join_t, Lhs, Rhs>, on_t<unconditional_t>>;
+
+    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));
   }
 
   template <typename Lhs, typename Rhs>
-  auto outer_join(Lhs lhs, Rhs rhs) -> typename std::
-      conditional<check_pre_join_t<Lhs, Rhs>::value, pre_join_t<outer_join_t, Lhs, Rhs>, bad_statement>::type
+  auto cross_join(Lhs lhs, Rhs rhs) -> decltype(detail::cross_join_impl(lhs, rhs))
   {
-    check_pre_join_t<Lhs, Rhs>{};
-
-    return {lhs, rhs};
-  }
-
-  template <typename Lhs, typename Rhs>
-  auto cross_join(Lhs lhs, Rhs rhs) ->
-      typename std::conditional<check_pre_join_t<Lhs, Rhs>::value,
-                                join_t<pre_join_t<cross_join_t, Lhs, Rhs>, on_t<unconditional_t>>,
-                                bad_statement>::type
-  {
-    check_pre_join_t<Lhs, Rhs>{};
-
     return {pre_join_t<cross_join_t, Lhs, Rhs>{lhs, rhs}, {}};
   }
 }
diff --git a/include/sqlpp11/union.h b/include/sqlpp11/union.h
index 49dd128e..80070abd 100644
--- a/include/sqlpp11/union.h
+++ b/include/sqlpp11/union.h
@@ -27,16 +27,16 @@
 #ifndef SQLPP_UNION_H
 #define SQLPP_UNION_H
 
-#include <sqlpp11/union_data.h>
-#include <sqlpp11/union_flags.h>
-#include <sqlpp11/statement_fwd.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/parameter_list.h>
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/interpretable_list.h>
-#include <sqlpp11/result_row.h>
 #include <sqlpp11/logic.h>
+#include <sqlpp11/parameter_list.h>
+#include <sqlpp11/result_row.h>
+#include <sqlpp11/statement_fwd.h>
+#include <sqlpp11/type_traits.h>
+#include <sqlpp11/union_data.h>
+#include <sqlpp11/union_flags.h>
 
 namespace sqlpp
 {
@@ -45,19 +45,19 @@ namespace sqlpp
   using blank_union_t = statement_t<void, no_union_t>;
   // There is no order by or limit or offset in union, use it as a pseudo table to do that.
 
-  template <bool, typename Union>
+  template <typename Check, typename Union>
   struct union_statement_impl
+  {
+    using type = Check;
+  };
+
+  template <typename Union>
+  struct union_statement_impl<consistent_t, Union>
   {
     using type = statement_t<void, Union, no_union_t>;
   };
 
-  template <typename Union>
-  struct union_statement_impl<false, Union>
-  {
-    using type = bad_statement;
-  };
-
-  template <bool Check, typename Union>
+  template <typename Check, typename Union>
   using union_statement_t = typename union_statement_impl<Check, Union>::type;
 
   // UNION(EXPR)
@@ -95,8 +95,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : union_{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : union_{std::forward<Args>(args)...}
       {
       }
 
@@ -166,8 +165,7 @@ namespace sqlpp
 
       // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
       template <typename... Args>
-      _base_t(Args&&... args)
-          : no_union{std::forward<Args>(args)...}
+      _base_t(Args&&... args) : no_union{std::forward<Args>(args)...}
       {
       }
 
@@ -196,7 +194,7 @@ namespace sqlpp
       using _check = typename logic::all<is_statement_t<T>::value...>::type;
 
       template <typename Check, typename T>
-      using _new_statement_t = union_statement_t<Check::value, T>;
+      using _new_statement_t = union_statement_t<Check, T>;
 
       using _consistency_check = consistent_t;
 
@@ -237,16 +235,15 @@ namespace sqlpp
       }
 
     private:
-      template <typename Database, typename Flag, typename Rhs>
-      auto _union_impl(const std::false_type&, Rhs rhs) const -> bad_statement;
+      template <typename Database, typename Check, typename Flag, typename Rhs>
+      auto _union_impl(Check, Rhs rhs) const -> Check;
 
       template <typename Database, typename Flag, typename Rhs>
-      auto _union_impl(const std::true_type&, Rhs rhs) const
-          -> _new_statement_t<std::true_type, union_t<Database, Flag, derived_statement_t<Policies>, Rhs>>
+      auto _union_impl(consistent_t, 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>{
-                    static_cast<const derived_statement_t<Policies>&>(*this), rhs}};
+        return {blank_union_t{}, union_data_t<Database, Flag, derived_statement_t<Policies>, Rhs>{
+                                     static_cast<const derived_statement_t<Policies>&>(*this), rhs}};
       }
     };
   };
diff --git a/test_static_asserts/aggregates.cpp b/test_static_asserts/aggregates.cpp
index ba458fe6..5566c00d 100644
--- a/test_static_asserts/aggregates.cpp
+++ b/test_static_asserts/aggregates.cpp
@@ -23,104 +23,95 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <iostream>
-#include "Sample.h"
 #include "MockDb.h"
+#include "Sample.h"
+#include <iostream>
 #include <sqlpp11/alias_provider.h>
-#include <sqlpp11/select.h>
-#include <sqlpp11/functions.h>
 #include <sqlpp11/connection.h>
-
-namespace sqlpp
-{
-  namespace test
-  {
-    template <typename T>
-    void print_type_on_error(std::true_type, const T&)
-    {
-    }
-
-    template <typename T>
-    void print_type_on_error(std::false_type, const T& t)
-    {
-      t._print_me_;
-    }
-
-    template <typename Assert, typename Expression>
-    void run_check(const Expression&)
-    {
-      using Context = MockDb::_serializer_context_t;
-      using CheckResult = std::is_same<sqlpp::run_check_t<Context, Expression>, Assert>;
-      static_assert(CheckResult::value, "Unexpected run_check result");
-      print_type_on_error(CheckResult{}, sqlpp::run_check_t<Context, Expression>{});
-    }
-
-    template <typename Expression>
-    void run_check(const Expression&)
-    {
-      using Context = MockDb::_serializer_context_t;
-      using CheckResult = std::is_same<sqlpp::run_check_t<Context, Expression>, consistent_t>;
-      static_assert(CheckResult::value, "Unexpected run_check result");
-      print_type_on_error(CheckResult{}, sqlpp::run_check_t<Context, Expression>{});
-    }
-  }
-}
+#include <sqlpp11/functions.h>
+#include <sqlpp11/select.h>
 
 namespace
 {
+  template <typename T>
+  void print_type_on_error(std::true_type)
+  {
+  }
+
+  template <typename T>
+  void print_type_on_error(std::false_type)
+  {
+    T::_print_me_;
+  }
+
+  template <typename Assert, typename Expression>
+  void static_run_check(const Expression&)
+  {
+    using Context = MockDb::_serializer_context_t;
+    using CheckResult = sqlpp::run_check_t<Context, Expression>;
+    using ExpectedCheckResult = std::is_same<CheckResult, Assert>;
+    print_type_on_error<CheckResult>(ExpectedCheckResult{});
+    static_assert(ExpectedCheckResult::value, "Unexpected check result");
+  }
+
   SQLPP_ALIAS_PROVIDER(whatever)
-  using sqlpp::test::run_check;
   static constexpr auto t = test::TabBar{};
 
   // If there is no group_by, we can select whatever we want
   void no_group_by()
   {
-    run_check(select(all_of(t)).from(t).unconditionally());
-    run_check(select(t.alpha).from(t).unconditionally());
-    run_check(select(count(t.alpha)).from(t).unconditionally());
+    static_run_check<sqlpp::consistent_t>(select(all_of(t)).from(t).unconditionally());
+    static_run_check<sqlpp::consistent_t>(select(t.alpha).from(t).unconditionally());
+    static_run_check<sqlpp::consistent_t>(select(count(t.alpha)).from(t).unconditionally());
   }
 
   // If there is a dynamic group_by, we can still select whatever we want
   // because there is no way of knowing which expressions might have been added dynamically
   void dynamic_group_by()
   {
-    run_check(select(all_of(t)).from(t).unconditionally());
-    run_check(select(t.alpha).from(t).unconditionally());
-    run_check(select(count(t.alpha)).from(t).unconditionally());
+    static_run_check<sqlpp::consistent_t>(select(all_of(t)).from(t).unconditionally());
+    static_run_check<sqlpp::consistent_t>(select(t.alpha).from(t).unconditionally());
+    static_run_check<sqlpp::consistent_t>(select(count(t.alpha)).from(t).unconditionally());
   }
 
   // If there is a static group_by, selected columns must be made of group_by expressions, or aggregate expression (e.g.
   // count(t.id)) or values to be valid
   void static_group_by_ok()
   {
-    run_check(select(t.alpha).from(t).unconditionally().group_by(t.alpha));
-    run_check(select((t.alpha + 42).as(whatever)).from(t).unconditionally().group_by(t.alpha));
-    run_check(select((t.alpha + 42).as(whatever)).from(t).unconditionally().group_by(t.alpha, t.alpha + t.delta * 17));
-    run_check(select((t.alpha + t.delta * 17).as(whatever))
-                  .from(t)
-                  .unconditionally()
-                  .group_by(t.alpha, t.alpha + t.delta * 17));
-    run_check(select((t.beta + "fortytwo").as(whatever)).from(t).unconditionally().group_by(t.beta));
+    static_run_check<sqlpp::consistent_t>(select(t.alpha).from(t).unconditionally().group_by(t.alpha));
+    static_run_check<sqlpp::consistent_t>(
+        select((t.alpha + 42).as(whatever)).from(t).unconditionally().group_by(t.alpha));
+    static_run_check<sqlpp::consistent_t>(
+        select((t.alpha + 42).as(whatever)).from(t).unconditionally().group_by(t.alpha, t.alpha + t.delta * 17));
+    static_run_check<sqlpp::consistent_t>(select((t.alpha + t.delta * 17).as(whatever))
+                                              .from(t)
+                                              .unconditionally()
+                                              .group_by(t.alpha, t.alpha + t.delta * 17));
+    static_run_check<sqlpp::consistent_t>(
+        select((t.beta + "fortytwo").as(whatever)).from(t).unconditionally().group_by(t.beta));
 
-    run_check(select(avg(t.alpha)).from(t).unconditionally().group_by(t.beta));
-    run_check(select(count(t.alpha)).from(t).unconditionally().group_by(t.beta));
-    run_check(select(max(t.alpha)).from(t).unconditionally().group_by(t.beta));
-    run_check(select(min(t.alpha)).from(t).unconditionally().group_by(t.beta));
-    run_check(select(sum(t.alpha)).from(t).unconditionally().group_by(t.beta));
+    static_run_check<sqlpp::consistent_t>(select(avg(t.alpha)).from(t).unconditionally().group_by(t.beta));
+    static_run_check<sqlpp::consistent_t>(select(count(t.alpha)).from(t).unconditionally().group_by(t.beta));
+    static_run_check<sqlpp::consistent_t>(select(max(t.alpha)).from(t).unconditionally().group_by(t.beta));
+    static_run_check<sqlpp::consistent_t>(select(min(t.alpha)).from(t).unconditionally().group_by(t.beta));
+    static_run_check<sqlpp::consistent_t>(select(sum(t.alpha)).from(t).unconditionally().group_by(t.beta));
 
-    run_check(select((t.alpha + count(t.delta)).as(whatever)).from(t).unconditionally().group_by(t.alpha));
+    static_run_check<sqlpp::consistent_t>(
+        select((t.alpha + count(t.delta)).as(whatever)).from(t).unconditionally().group_by(t.alpha));
 
-    run_check(select(sqlpp::value(1).as(whatever)).from(t).unconditionally().group_by(t.alpha));
-    run_check(select(sqlpp::value("whatever").as(whatever)).from(t).unconditionally().group_by(t.alpha));
+    static_run_check<sqlpp::consistent_t>(
+        select(sqlpp::value(1).as(whatever)).from(t).unconditionally().group_by(t.alpha));
+    static_run_check<sqlpp::consistent_t>(
+        select(sqlpp::value("whatever").as(whatever)).from(t).unconditionally().group_by(t.alpha));
   }
 
   // Failures with static group_by and selected non-aggregates or incorrect aggregates
   void static_group_by_nok()
   {
-    run_check<sqlpp::assert_no_unknown_aggregates_t>(select(t.beta).from(t).unconditionally().group_by(t.alpha));
-    run_check<sqlpp::assert_no_unknown_aggregates_t>(
+    static_run_check<sqlpp::assert_no_unknown_aggregates_t>(select(t.beta).from(t).unconditionally().group_by(t.alpha));
+    static_run_check<sqlpp::assert_no_unknown_aggregates_t>(
         select((t.alpha + t.delta).as(whatever)).from(t).unconditionally().group_by(t.alpha));
-    run_check<sqlpp::assert_no_unknown_aggregates_t>(
+    static_run_check<sqlpp::assert_no_unknown_aggregates_t>(
         select((t.alpha + t.delta).as(whatever)).from(t).unconditionally().group_by(t.alpha, t.alpha + t.delta * 17));
   }
 }
diff --git a/test_static_asserts/case.cpp b/test_static_asserts/case.cpp
index 44506abb..d3d0eb6b 100644
--- a/test_static_asserts/case.cpp
+++ b/test_static_asserts/case.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015-2015, Roland Bock
+ * Copyright (c) 2015-2016, Roland Bock
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -23,9 +23,9 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <iostream>
 #include "MockDb.h"
 #include "Sample.h"
+#include <iostream>
 #include <sqlpp11/sqlpp11.h>
 
 namespace
@@ -52,7 +52,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(sqlpp::case_when(when));
-    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, void>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -66,7 +66,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(sqlpp::case_when(when).then(then));
-    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, void>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -80,7 +80,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(sqlpp::case_when(when).then(then).else_(else_));
-    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, void>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
diff --git a/test_static_asserts/from.cpp b/test_static_asserts/from.cpp
index 53fc9231..c4acab06 100644
--- a/test_static_asserts/from.cpp
+++ b/test_static_asserts/from.cpp
@@ -23,9 +23,9 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <iostream>
 #include "MockDb.h"
 #include "Sample.h"
+#include <iostream>
 #include <sqlpp11/sqlpp11.h>
 
 namespace
@@ -53,8 +53,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(select(t.alpha).from(expression));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -69,8 +68,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(dynamic_select(db, t.alpha).dynamic_from(expression));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -120,8 +118,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(from.add(expression));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
diff --git a/test_static_asserts/having.cpp b/test_static_asserts/having.cpp
index b4998275..d7d9bc1b 100644
--- a/test_static_asserts/having.cpp
+++ b/test_static_asserts/having.cpp
@@ -23,9 +23,9 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <iostream>
 #include "MockDb.h"
 #include "Sample.h"
+#include <iostream>
 #include <sqlpp11/sqlpp11.h>
 
 namespace
@@ -53,8 +53,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(select(all_of(t)).from(t).unconditionally().group_by(t.alpha).having(expression));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -70,8 +69,7 @@ namespace
 
     using ReturnType =
         decltype(dynamic_select(db, all_of(t)).from(t).unconditionally().group_by(t.alpha).dynamic_having(expression));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -140,7 +138,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(select(all_of(t)).from(t).dynamic_having());
-    using ExpectedReturnType = std::is_same<ReturnType, sqlpp::bad_statement>;
+    using ExpectedReturnType = std::is_same<ReturnType, sqlpp::assert_where_dynamic_statement_dynamic_t>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
diff --git a/test_static_asserts/insert.cpp b/test_static_asserts/insert.cpp
index 9a37014b..6df6d5c8 100644
--- a/test_static_asserts/insert.cpp
+++ b/test_static_asserts/insert.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015-2015, Roland Bock
+ * Copyright (c) 2015-2016, Roland Bock
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -23,9 +23,9 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <iostream>
 #include "MockDb.h"
 #include "Sample.h"
+#include <iostream>
 #include <sqlpp11/sqlpp11.h>
 
 namespace
@@ -53,8 +53,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(insert_into(t).set(assignments...));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -69,8 +68,7 @@ namespace
     print_type_on_error<CheckResult>(ExpectedCheckResult{});
 
     using ReturnType = decltype(dynamic_insert_into(db, t).dynamic_set(assignments...));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     static_assert(ExpectedReturnType::value, "Unexpected return type");
     print_type_on_error<ReturnType>(ExpectedReturnType{});
   }
@@ -162,7 +160,7 @@ namespace
     print_type_on_error<CheckResult>(ExpectedCheckResult{});
 
     using ReturnType = decltype(insert_into(t).dynamic_set());
-    using ExpectedReturnType = std::is_same<ReturnType, sqlpp::bad_statement>;
+    using ExpectedReturnType = std::is_same<ReturnType, sqlpp::assert_insert_dynamic_set_statement_dynamic_t>;
     static_assert(ExpectedReturnType::value, "Unexpected return type");
     print_type_on_error<ReturnType>(ExpectedReturnType{});
   }
diff --git a/test_static_asserts/join.cpp b/test_static_asserts/join.cpp
index e25fef2d..2c4117ea 100644
--- a/test_static_asserts/join.cpp
+++ b/test_static_asserts/join.cpp
@@ -23,9 +23,9 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <iostream>
 #include "MockDb.h"
 #include "Sample.h"
+#include <iostream>
 #include <sqlpp11/sqlpp11.h>
 
 namespace
@@ -62,12 +62,9 @@ namespace
         (Assert::value and sqlpp::is_pre_join_t<JoinType>::value and sqlpp::is_pre_join_t<InnerJoinType>::value and
          sqlpp::is_pre_join_t<LeftOuterJoinType>::value and sqlpp::is_pre_join_t<RightOuterJoinType>::value and
          sqlpp::is_pre_join_t<OuterJoinType>::value and sqlpp::is_join_t<CrossJoinType>::value) xor
-        (std::is_same<JoinType, sqlpp::bad_statement>::value and
-         std::is_same<InnerJoinType, sqlpp::bad_statement>::value and
-         std::is_same<LeftOuterJoinType, sqlpp::bad_statement>::value and
-         std::is_same<RightOuterJoinType, sqlpp::bad_statement>::value and
-         std::is_same<OuterJoinType, sqlpp::bad_statement>::value and
-         std::is_same<CrossJoinType, sqlpp::bad_statement>::value)>;
+        (std::is_same<JoinType, Assert>::value and std::is_same<InnerJoinType, Assert>::value and
+         std::is_same<LeftOuterJoinType, Assert>::value and std::is_same<RightOuterJoinType, Assert>::value and
+         std::is_same<OuterJoinType, Assert>::value and std::is_same<CrossJoinType, Assert>::value)>;
     print_type_on_error<JoinType>(ExpectedReturnType{});
     print_type_on_error<InnerJoinType>(ExpectedReturnType{});
     print_type_on_error<LeftOuterJoinType>(ExpectedReturnType{});
@@ -87,7 +84,7 @@ namespace
 
     using ResultType = decltype(lhs.on(rhs));
     using ExpectedReturnType = sqlpp::logic::all_t<(Assert::value and sqlpp::is_join_t<ResultType>::value) xor
-                                                   std::is_same<ResultType, sqlpp::bad_statement>::value>;
+                                                   std::is_same<ResultType, Assert>::value>;
     print_type_on_error<ResultType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -190,18 +187,15 @@ namespace
     using RightOuterJoinType = decltype(sqlpp::dynamic_right_outer_join(table));
     using OuterJoinType = decltype(sqlpp::dynamic_outer_join(table));
     using CrossJoinType = decltype(sqlpp::dynamic_cross_join(table));
-    using ExpectedReturnType = sqlpp::logic::all_t<(Assert::value and sqlpp::is_dynamic_pre_join_t<JoinType>::value and
-                                                    sqlpp::is_dynamic_pre_join_t<InnerJoinType>::value and
-                                                    sqlpp::is_dynamic_pre_join_t<LeftOuterJoinType>::value and
-                                                    sqlpp::is_dynamic_pre_join_t<RightOuterJoinType>::value and
-                                                    sqlpp::is_dynamic_pre_join_t<OuterJoinType>::value and
-                                                    sqlpp::is_dynamic_join_t<CrossJoinType>::value) xor
-                                                   (std::is_same<JoinType, sqlpp::bad_statement>::value and
-                                                    std::is_same<InnerJoinType, sqlpp::bad_statement>::value and
-                                                    std::is_same<LeftOuterJoinType, sqlpp::bad_statement>::value and
-                                                    std::is_same<RightOuterJoinType, sqlpp::bad_statement>::value and
-                                                    std::is_same<OuterJoinType, sqlpp::bad_statement>::value and
-                                                    std::is_same<CrossJoinType, sqlpp::bad_statement>::value)>;
+    using ExpectedReturnType = sqlpp::logic::all_t<
+        (Assert::value and sqlpp::is_dynamic_pre_join_t<JoinType>::value and
+         sqlpp::is_dynamic_pre_join_t<InnerJoinType>::value and
+         sqlpp::is_dynamic_pre_join_t<LeftOuterJoinType>::value and
+         sqlpp::is_dynamic_pre_join_t<RightOuterJoinType>::value and
+         sqlpp::is_dynamic_pre_join_t<OuterJoinType>::value and sqlpp::is_dynamic_join_t<CrossJoinType>::value) xor
+        (std::is_same<JoinType, Assert>::value and std::is_same<InnerJoinType, Assert>::value and
+         std::is_same<LeftOuterJoinType, Assert>::value and std::is_same<RightOuterJoinType, Assert>::value and
+         std::is_same<OuterJoinType, Assert>::value and std::is_same<CrossJoinType, Assert>::value)>;
     print_type_on_error<JoinType>(ExpectedReturnType{});
     print_type_on_error<InnerJoinType>(ExpectedReturnType{});
     print_type_on_error<LeftOuterJoinType>(ExpectedReturnType{});
@@ -221,7 +215,7 @@ namespace
 
     using ResultType = decltype(lhs.on(rhs));
     using ExpectedReturnType = sqlpp::logic::all_t<(Assert::value and sqlpp::is_dynamic_join_t<ResultType>::value) xor
-                                                   std::is_same<ResultType, sqlpp::bad_statement>::value>;
+                                                   std::is_same<ResultType, Assert>::value>;
     print_type_on_error<ResultType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
diff --git a/test_static_asserts/unwrapped_bool.cpp b/test_static_asserts/unwrapped_bool.cpp
index 431a5ea8..fe190c75 100644
--- a/test_static_asserts/unwrapped_bool.cpp
+++ b/test_static_asserts/unwrapped_bool.cpp
@@ -23,9 +23,9 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <iostream>
 #include "MockDb.h"
 #include "Sample.h"
+#include <iostream>
 #include <sqlpp11/sqlpp11.h>
 
 namespace
@@ -82,8 +82,7 @@ namespace
   void where_check(const Condition& condition)
   {
     using ReturnType = decltype(sqlpp::where(condition));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -104,7 +103,7 @@ namespace
   void where()
   {
     where_check<sqlpp::consistent_t>(t.gamma);
-    where_check<sqlpp::bad_statement>(true);
+    where_check<sqlpp::assert_where_not_cpp_bool_t>(true);
   }
 }
 
diff --git a/test_static_asserts/update_list.cpp b/test_static_asserts/update_list.cpp
index 06838013..56cb666f 100644
--- a/test_static_asserts/update_list.cpp
+++ b/test_static_asserts/update_list.cpp
@@ -23,9 +23,9 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <iostream>
 #include "MockDb.h"
 #include "Sample.h"
+#include <iostream>
 #include <sqlpp11/sqlpp11.h>
 
 namespace
@@ -53,8 +53,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(update(t).set(expressions...));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -69,8 +68,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(dynamic_update(db, t).dynamic_set(expressions...));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -127,7 +125,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(update(t).dynamic_set());
-    using ExpectedReturnType = std::is_same<ReturnType, sqlpp::bad_statement>;
+    using ExpectedReturnType = std::is_same<ReturnType, sqlpp::assert_update_dynamic_set_statement_dynamic_t>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
diff --git a/test_static_asserts/where.cpp b/test_static_asserts/where.cpp
index d232adff..360a782c 100644
--- a/test_static_asserts/where.cpp
+++ b/test_static_asserts/where.cpp
@@ -23,9 +23,9 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <iostream>
 #include "MockDb.h"
 #include "Sample.h"
+#include <iostream>
 #include <sqlpp11/sqlpp11.h>
 
 namespace
@@ -52,8 +52,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(remove_from(t).where(expression));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -68,8 +67,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(dynamic_remove_from(db, t).dynamic_where(expression));
-    using ExpectedReturnType =
-        sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, sqlpp::bad_statement>::value>;
+    using ExpectedReturnType = sqlpp::logic::all_t<Assert::value xor std::is_same<ReturnType, Assert>::value>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
@@ -140,7 +138,7 @@ namespace
     static_assert(ExpectedCheckResult::value, "Unexpected check result");
 
     using ReturnType = decltype(remove_from(t).dynamic_where());
-    using ExpectedReturnType = std::is_same<ReturnType, sqlpp::bad_statement>;
+    using ExpectedReturnType = std::is_same<ReturnType, sqlpp::assert_where_dynamic_statement_dynamic_t>;
     print_type_on_error<ReturnType>(ExpectedReturnType{});
     static_assert(ExpectedReturnType::value, "Unexpected return type");
   }
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 39fbad16..de3f952b 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -36,14 +36,14 @@ set(test_names
   #Interpret
   #Insert
   #Remove
-  Update
+  #Update
   #Select
   #SelectType
   #Function
   #Prepared
   #Minimalistic
   #Result
-  #Union
+  Union
   #With
   )
 

From 5d09b736b678244c21322a1c51840b7442ad782d Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Thu, 1 Sep 2016 21:57:15 +0200
Subject: [PATCH 05/11] Better failure return values for union

There are still a lot of untestable static_assert, but one thing at a
time...
---
 include/sqlpp11/union.h | 29 +++++++++++++++++------------
 tests/CMakeLists.txt    | 30 +++++++++++++++---------------
 2 files changed, 32 insertions(+), 27 deletions(-)

diff --git a/include/sqlpp11/union.h b/include/sqlpp11/union.h
index 80070abd..2bac56c7 100644
--- a/include/sqlpp11/union.h
+++ b/include/sqlpp11/union.h
@@ -135,6 +135,16 @@ namespace sqlpp
     using _result_methods_t = typename Lhs::template _result_methods_t<Statement>;
   };
 
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_union_args_are_statements_t, "arguments for union() must be statements");
+  template <typename... T>
+  struct check_union
+  {
+    using type = static_combined_check_t<
+        static_check_t<logic::all_t<is_statement_t<T>::value...>::value, assert_union_args_are_statements_t>>;
+  };
+  template <typename... T>
+  using check_union_t = typename check_union<T...>::type;
+
   // NO UNION YET
   struct no_union_t
   {
@@ -187,12 +197,6 @@ namespace sqlpp
 
       using _database_t = typename Policies::_database_t;
 
-      // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
-      //	  template <typename... T>
-      //	  using _check = logic::all_t<is_statement_t<T>::value...>;
-      template <typename... T>
-      using _check = typename logic::all<is_statement_t<T>::value...>::type;
-
       template <typename Check, typename T>
       using _new_statement_t = union_statement_t<Check, T>;
 
@@ -200,7 +204,8 @@ namespace sqlpp
 
       template <typename Rhs>
       auto union_distinct(Rhs rhs) const
-          -> _new_statement_t<_check<Rhs>, union_t<void, union_distinct_t, derived_statement_t<Policies>, Rhs>>
+          -> _new_statement_t<check_union_t<derived_statement_t<Policies>, Rhs>,
+                              union_t<void, union_distinct_t, derived_statement_t<Policies>, Rhs>>
       {
         static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
         static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@@ -213,12 +218,12 @@ namespace sqlpp
                       "both arguments in a union have to have the same result columns (type and name)");
         static_assert(is_static_result_row_t<_result_row_t>::value, "unions must not have dynamically added columns");
 
-        return _union_impl<void, union_distinct_t>(_check<derived_statement_t<Policies>, Rhs>{}, rhs);
+        return _union_impl<void, union_distinct_t>(check_union_t<derived_statement_t<Policies>, Rhs>{}, rhs);
       }
 
       template <typename Rhs>
-      auto union_all(Rhs rhs) const
-          -> _new_statement_t<_check<Rhs>, union_t<void, union_all_t, derived_statement_t<Policies>, Rhs>>
+      auto union_all(Rhs rhs) const -> _new_statement_t<check_union_t<derived_statement_t<Policies>, Rhs>,
+                                                        union_t<void, union_all_t, derived_statement_t<Policies>, Rhs>>
       {
         static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
         static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@@ -231,11 +236,11 @@ namespace sqlpp
                       "both arguments in a union have to have the same result columns (type and name)");
         static_assert(is_static_result_row_t<_result_row_t>::value, "unions must not have dynamically added columns");
 
-        return _union_impl<void, union_all_t>(_check<derived_statement_t<Policies>, Rhs>{}, rhs);
+        return _union_impl<void, union_all_t>(check_union_t<derived_statement_t<Policies>, Rhs>{}, rhs);
       }
 
     private:
-      template <typename Database, typename Check, typename Flag, typename Rhs>
+      template <typename Database, typename Flag, typename Check, typename Rhs>
       auto _union_impl(Check, Rhs rhs) const -> Check;
 
       template <typename Database, typename Flag, typename Rhs>
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index de3f952b..359b38f3 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2013-2015, Roland Bock
+# Copyright (c) 2013-2016, Roland Bock
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
@@ -30,21 +30,21 @@ target_compile_options(sqlpp11_testing INTERFACE -Wall -Wextra -pedantic)
 endif ()
 
 set(test_names
-  #BooleanExpression
-  #CustomQuery
-  #DateTime
-  #Interpret
-  #Insert
-  #Remove
-  #Update
-  #Select
-  #SelectType
-  #Function
-  #Prepared
-  #Minimalistic
-  #Result
+  BooleanExpression
+  CustomQuery
+  DateTime
+  Interpret
+  Insert
+  Remove
+  Update
+  Select
+  SelectType
+  Function
+  Prepared
+  Minimalistic
+  Result
   Union
-  #With
+  With
   )
 
 create_test_sourcelist(test_sources test_main.cpp ${test_names})

From 39dec1ea39e5a7d1da0791f171b5f858d8c7aa2b Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Thu, 1 Sep 2016 22:15:52 +0200
Subject: [PATCH 06/11] Better failure return type for cte

---
 include/sqlpp11/cte.h | 71 ++++++++++++++++++++++++++-----------------
 1 file changed, 43 insertions(+), 28 deletions(-)

diff --git a/include/sqlpp11/cte.h b/include/sqlpp11/cte.h
index d5a93336..54a2d984 100644
--- a/include/sqlpp11/cte.h
+++ b/include/sqlpp11/cte.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015, Roland Bock
+ * Copyright (c) 2013-2016, Roland Bock
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -27,16 +27,16 @@
 #ifndef SQLPP_CTE_H
 #define SQLPP_CTE_H
 
-#include <sqlpp11/table_ref.h>
-#include <sqlpp11/select_flags.h>
-#include <sqlpp11/result_row.h>
-#include <sqlpp11/statement_fwd.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/parameter_list.h>
 #include <sqlpp11/expression.h>
 #include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/interpretable_list.h>
 #include <sqlpp11/logic.h>
+#include <sqlpp11/parameter_list.h>
+#include <sqlpp11/result_row.h>
+#include <sqlpp11/select_flags.h>
+#include <sqlpp11/statement_fwd.h>
+#include <sqlpp11/table_ref.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -133,6 +133,31 @@ namespace sqlpp
     using type = member_t<cte_column_spec_t<FieldSpec>, column_t<AliasProvider, cte_column_spec_t<FieldSpec>>>;
   };
 
+  template <typename Check, typename Union>
+  struct union_cte_impl
+  {
+    using type = Check;
+  };
+
+  template <typename Union>
+  struct union_cte_impl<consistent_t, Union>
+  {
+    using type = Union;
+  };
+
+  template <typename Check, typename Union>
+  using union_cte_impl_t = typename union_cte_impl<Check, Union>::type;
+
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_cte_union_args_are_statements_t, "argument for union() must be a statement");
+  template <typename... T>
+  struct check_cte_union
+  {
+    using type = static_combined_check_t<
+        static_check_t<logic::all_t<is_statement_t<T>::value...>::value, assert_cte_union_args_are_statements_t>>;
+  };
+  template <typename... T>
+  using check_cte_union_t = typename check_cte_union<T...>::type;
+
   template <typename AliasProvider, typename Statement, typename... FieldSpecs>
   struct cte_t : public cte_base<AliasProvider, FieldSpecs>::type...
   {
@@ -146,21 +171,12 @@ namespace sqlpp
 
     using _column_tuple_t = std::tuple<column_t<AliasProvider, cte_column_spec_t<FieldSpecs>>...>;
 
-    // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2086629
-    //	template <typename... T>
-    //	using _check = logic::all_t<is_statement_t<T>::value...>;
-    template <typename... T>
-    struct _check : logic::all_t<is_statement_t<T>::value...>
-    {
-    };
-
     using _result_row_t = result_row_t<void, FieldSpecs...>;
 
     template <typename Rhs>
-    auto union_distinct(Rhs rhs) const ->
-        typename std::conditional<_check<Rhs>::value,
-                                  cte_t<AliasProvider, cte_union_t<distinct_t, Statement, Rhs>, FieldSpecs...>,
-                                  bad_statement>::type
+    auto union_distinct(Rhs rhs) const
+        -> union_cte_impl_t<check_cte_union_t<Rhs>,
+                            cte_t<AliasProvider, cte_union_t<distinct_t, Statement, Rhs>, FieldSpecs...>>
     {
       static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
       static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@@ -169,14 +185,13 @@ namespace sqlpp
       static_assert(std::is_same<_result_row_t, get_result_row_t<Rhs>>::value,
                     "both select statements in a union have to have the same result columns (type and name)");
 
-      return _union_impl<void, distinct_t>(_check<Rhs>{}, rhs);
+      return _union_impl<void, distinct_t>(check_cte_union_t<Rhs>{}, rhs);
     }
 
     template <typename Rhs>
-    auto union_all(Rhs rhs) const ->
-        typename std::conditional<_check<Rhs>::value,
-                                  cte_t<AliasProvider, cte_union_t<all_t, Statement, Rhs>, FieldSpecs...>,
-                                  bad_statement>::type
+    auto union_all(Rhs rhs) const
+        -> union_cte_impl_t<check_cte_union_t<Rhs>,
+                            cte_t<AliasProvider, cte_union_t<all_t, Statement, Rhs>, FieldSpecs...>>
     {
       static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
       static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@@ -185,15 +200,15 @@ namespace sqlpp
       static_assert(std::is_same<_result_row_t, get_result_row_t<Rhs>>::value,
                     "both select statements in a union have to have the same result columns (type and name)");
 
-      return _union_impl<all_t>(_check<Rhs>{}, rhs);
+      return _union_impl<all_t>(check_cte_union_t<Rhs>{}, rhs);
     }
 
   private:
-    template <typename Flag, typename Rhs>
-    auto _union_impl(const std::false_type&, Rhs rhs) const -> bad_statement;
+    template <typename Flag, typename Check, typename Rhs>
+    auto _union_impl(Check, Rhs rhs) const -> Check;
 
     template <typename Flag, typename Rhs>
-    auto _union_impl(const std::true_type&, Rhs rhs) const
+    auto _union_impl(consistent_t, Rhs rhs) const
         -> cte_t<AliasProvider, cte_union_t<Flag, Statement, Rhs>, FieldSpecs...>
     {
       return cte_union_t<Flag, Statement, Rhs>{_statement, rhs};

From 407718a8a49330852ec423e8a8fd898dcc6affe3 Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Thu, 1 Sep 2016 22:31:53 +0200
Subject: [PATCH 07/11] Eliminated bad_statement

Using wrapped static asserts now as return types
---
 include/sqlpp11/bad_statement.h     | 43 -----------------------------
 include/sqlpp11/result_field_base.h |  8 ++++--
 2 files changed, 5 insertions(+), 46 deletions(-)
 delete mode 100644 include/sqlpp11/bad_statement.h

diff --git a/include/sqlpp11/bad_statement.h b/include/sqlpp11/bad_statement.h
deleted file mode 100644
index c8b78a5c..00000000
--- a/include/sqlpp11/bad_statement.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2013-2015, Roland Bock
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *   Redistributions of source code must retain the above copyright notice, this
- *   list of conditions and the following disclaimer.
- *
- *   Redistributions in binary form must reproduce the above copyright notice, this
- *   list of conditions and the following disclaimer in the documentation and/or
- *   other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SQLPP_BAD_STATEMENT_H
-#define SQLPP_BAD_STATEMENT_H
-
-namespace sqlpp
-{
-  struct bad_statement
-  {
-    static constexpr bool value = false;
-
-    template <typename... T>
-    bad_statement(T&&...)
-    {
-    }
-  };
-}
-
-#endif
diff --git a/include/sqlpp11/result_field_base.h b/include/sqlpp11/result_field_base.h
index 01f66758..3f6d3992 100644
--- a/include/sqlpp11/result_field_base.h
+++ b/include/sqlpp11/result_field_base.h
@@ -28,7 +28,6 @@
 #define SQLPP_RESULT_FIELD_BASE_H
 
 #include <sqlpp11/alias_operators.h>
-#include <sqlpp11/bad_statement.h>
 #include <sqlpp11/basic_expression_operators.h>
 #include <sqlpp11/exception.h>
 #include <sqlpp11/result_field.h>
@@ -37,6 +36,8 @@
 
 namespace sqlpp
 {
+  SQLPP_PORTABLE_STATIC_ASSERT(assert_result_field_value_is_safe_t, "result field value needs to be checked for NULL");
+
   template <typename Db, typename FieldSpec, typename StorageType = typename value_type_of<FieldSpec>::_cpp_value_type>
   struct result_field_base
   {
@@ -117,8 +118,9 @@ namespace sqlpp
       return _value;
     }
 
-    operator typename std::conditional<_null_is_trivial or (not _can_be_null::value), _cpp_value_type, bad_statement>::
-        type() const
+    operator typename std::conditional<_null_is_trivial or (not _can_be_null::value),
+                                       _cpp_value_type,
+                                       assert_result_field_value_is_safe_t>::type() const
     {
       return value();
     }

From d841a7d8a5c6f98fd081e896814786fb867deaa2 Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Fri, 2 Sep 2016 11:17:30 +0200
Subject: [PATCH 08/11] Fixed gcc ambiguity bug

See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77449
---
 include/sqlpp11/group_by.h               |  2 +-
 include/sqlpp11/inconsistent.h           | 48 ++++++++++++++++++++++++
 include/sqlpp11/insert_value_list.h      |  4 +-
 include/sqlpp11/order_by.h               |  2 +-
 include/sqlpp11/portable_static_assert.h |  1 +
 include/sqlpp11/select_flag_list.h       |  2 +-
 include/sqlpp11/update_list.h            |  2 +-
 include/sqlpp11/using.h                  |  2 +-
 8 files changed, 56 insertions(+), 7 deletions(-)
 create mode 100644 include/sqlpp11/inconsistent.h

diff --git a/include/sqlpp11/group_by.h b/include/sqlpp11/group_by.h
index 34210ec8..8d5a4696 100644
--- a/include/sqlpp11/group_by.h
+++ b/include/sqlpp11/group_by.h
@@ -235,7 +235,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Expressions>
-      auto _group_by_impl(Check, Expressions... expressions) const -> Check;
+      auto _group_by_impl(inconsistent<Check>, Expressions... expressions) const -> Check;
 
       template <typename Database, typename... Expressions>
       auto _group_by_impl(consistent_t, Expressions... expressions) const
diff --git a/include/sqlpp11/inconsistent.h b/include/sqlpp11/inconsistent.h
new file mode 100644
index 00000000..326be226
--- /dev/null
+++ b/include/sqlpp11/inconsistent.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2016-2016, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_INCONSISTENT_H
+#define SQLPP_INCONSISTENT_H
+
+namespace sqlpp
+{
+  template <typename Check>
+  struct inconsistent
+  {
+    inconsistent(Check)
+    {
+    }
+  };
+
+  // This specialization circumvents an ambiguity problem with gcc
+  // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77449
+  template <>
+  struct inconsistent<consistent_t>
+  {
+  };
+}
+
+#endif
diff --git a/include/sqlpp11/insert_value_list.h b/include/sqlpp11/insert_value_list.h
index 5e16bfe5..8eb718f6 100644
--- a/include/sqlpp11/insert_value_list.h
+++ b/include/sqlpp11/insert_value_list.h
@@ -526,7 +526,7 @@ namespace sqlpp
 
     private:
       template <typename Check, typename... Columns>
-      auto _columns_impl(Check, Columns... cols) const -> Check;
+      auto _columns_impl(inconsistent<Check>, Columns... cols) const -> Check;
 
       template <typename... Columns>
       auto _columns_impl(consistent_t, Columns... cols) const
@@ -546,7 +546,7 @@ namespace sqlpp
       }
 
       template <typename Database, typename Check, typename... Assignments>
-      auto _set_impl(Check, Assignments... assignments) const -> Check;
+      auto _set_impl(inconsistent<Check>, Assignments... assignments) const -> Check;
 
       template <typename Database, typename... Assignments>
       auto _set_impl(consistent_t, Assignments... assignments) const
diff --git a/include/sqlpp11/order_by.h b/include/sqlpp11/order_by.h
index 509d0950..d13eb7a9 100644
--- a/include/sqlpp11/order_by.h
+++ b/include/sqlpp11/order_by.h
@@ -233,7 +233,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Expressions>
-      auto _order_by_impl(Check, Expressions... expressions) const -> Check;
+      auto _order_by_impl(inconsistent<Check>, Expressions... expressions) const -> Check;
 
       template <typename Database, typename... Expressions>
       auto _order_by_impl(consistent_t, Expressions... expressions) const
diff --git a/include/sqlpp11/portable_static_assert.h b/include/sqlpp11/portable_static_assert.h
index dc3b94a2..b0a8036c 100644
--- a/include/sqlpp11/portable_static_assert.h
+++ b/include/sqlpp11/portable_static_assert.h
@@ -28,6 +28,7 @@
 #define SQLPP_PORTABLE_STATIC_ASSERT_H
 
 #include <sqlpp11/consistent.h>
+#include <sqlpp11/inconsistent.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/select_flag_list.h b/include/sqlpp11/select_flag_list.h
index 4c87168c..7f593055 100644
--- a/include/sqlpp11/select_flag_list.h
+++ b/include/sqlpp11/select_flag_list.h
@@ -223,7 +223,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Flags>
-      auto _flags_impl(Check, Flags... flgs) const -> Check;
+      auto _flags_impl(inconsistent<Check>, Flags... flgs) const -> Check;
 
       template <typename Database, typename... Flags>
       auto _flags_impl(consistent_t, Flags... flgs) const
diff --git a/include/sqlpp11/update_list.h b/include/sqlpp11/update_list.h
index 63e19af9..c79c17d0 100644
--- a/include/sqlpp11/update_list.h
+++ b/include/sqlpp11/update_list.h
@@ -273,7 +273,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Assignments>
-      auto _set_impl(Check, Assignments... assignments) const -> Check;
+      auto _set_impl(inconsistent<Check>, Assignments... assignments) const -> Check;
 
       template <typename Database, typename... Assignments>
       auto _set_impl(consistent_t, Assignments... assignments) const
diff --git a/include/sqlpp11/using.h b/include/sqlpp11/using.h
index e09c5f4b..84fede64 100644
--- a/include/sqlpp11/using.h
+++ b/include/sqlpp11/using.h
@@ -224,7 +224,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Tables>
-      auto _using_impl(Check, Tables... tables) const -> Check;
+      auto _using_impl(inconsistent<Check>, Tables... tables) const -> Check;
 
       template <typename Database, typename... Tables>
       auto _using_impl(consistent_t, Tables... tables) const

From 827c8dbf61780b0e25facbf697cbcbfecc74b7d1 Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Fri, 2 Sep 2016 22:35:12 +0200
Subject: [PATCH 09/11] The previous fix wasn't.

Found this via build-system tests of static asserts through MSVC.
---
 include/sqlpp11/case.h               |  6 +++---
 include/sqlpp11/cte.h                |  2 +-
 include/sqlpp11/from.h               |  4 ++--
 include/sqlpp11/group_by.h           |  2 +-
 include/sqlpp11/having.h             |  2 +-
 include/sqlpp11/inconsistent.h       | 21 +++++++++------------
 include/sqlpp11/insert_value_list.h  |  4 ++--
 include/sqlpp11/into.h               |  2 +-
 include/sqlpp11/limit.h              |  2 +-
 include/sqlpp11/offset.h             |  2 +-
 include/sqlpp11/order_by.h           |  2 +-
 include/sqlpp11/pre_join.h           |  6 +++---
 include/sqlpp11/select_column_list.h |  2 +-
 include/sqlpp11/select_flag_list.h   |  2 +-
 include/sqlpp11/single_table.h       |  2 +-
 include/sqlpp11/union.h              |  2 +-
 include/sqlpp11/update_list.h        |  2 +-
 include/sqlpp11/using.h              |  2 +-
 include/sqlpp11/where.h              |  2 +-
 test_serializer/CustomQuery.cpp      |  2 +-
 20 files changed, 34 insertions(+), 37 deletions(-)

diff --git a/include/sqlpp11/case.h b/include/sqlpp11/case.h
index b536d432..c59ff791 100644
--- a/include/sqlpp11/case.h
+++ b/include/sqlpp11/case.h
@@ -93,7 +93,7 @@ namespace sqlpp
     }
 
     template <typename Check, typename Else>
-    auto _else_impl(Check, Else else_) -> Check;
+    auto _else_impl(Check, Else else_) -> inconsistent<Check>;
 
   public:
     case_then_t(When when, Then then) : _when(when), _then(then)
@@ -127,7 +127,7 @@ namespace sqlpp
     }
 
     template <typename Check, typename Then>
-    auto _then_impl(Check, Then t) -> Check;
+    auto _then_impl(Check, Then t) -> inconsistent<Check>;
 
   public:
     case_when_t(When when) : _when(when)
@@ -178,7 +178,7 @@ namespace sqlpp
     }
 
     template <typename Check, typename When>
-    auto case_when_impl(Check, When when) -> Check;
+    auto case_when_impl(Check, When when) -> inconsistent<Check>;
   }
 
   template <typename When>
diff --git a/include/sqlpp11/cte.h b/include/sqlpp11/cte.h
index 54a2d984..cc7a8827 100644
--- a/include/sqlpp11/cte.h
+++ b/include/sqlpp11/cte.h
@@ -205,7 +205,7 @@ namespace sqlpp
 
   private:
     template <typename Flag, typename Check, typename Rhs>
-    auto _union_impl(Check, Rhs rhs) const -> Check;
+    auto _union_impl(Check, Rhs rhs) const -> inconsistent<Check>;
 
     template <typename Flag, typename Rhs>
     auto _union_impl(consistent_t, Rhs rhs) const
diff --git a/include/sqlpp11/from.h b/include/sqlpp11/from.h
index a226d81d..afdc810f 100644
--- a/include/sqlpp11/from.h
+++ b/include/sqlpp11/from.h
@@ -131,7 +131,7 @@ namespace sqlpp
       }
 
       template <typename Check, typename DynamicJoin>
-      auto _add_impl(DynamicJoin dynamicJoin, Check) -> Check;
+      auto _add_impl(DynamicJoin dynamicJoin, Check) -> inconsistent<Check>;
 
     public:
       _data_t _data;
@@ -276,7 +276,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename Table>
-      auto _from_impl(Check, Table table) const -> Check;
+      auto _from_impl(Check, Table table) const -> inconsistent<Check>;
 
       template <typename Database, typename Table>
       auto _from_impl(consistent_t, Table table) const
diff --git a/include/sqlpp11/group_by.h b/include/sqlpp11/group_by.h
index 8d5a4696..5a8c420b 100644
--- a/include/sqlpp11/group_by.h
+++ b/include/sqlpp11/group_by.h
@@ -235,7 +235,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Expressions>
-      auto _group_by_impl(inconsistent<Check>, Expressions... expressions) const -> Check;
+      auto _group_by_impl(Check, Expressions... expressions) const -> inconsistent<Check>;
 
       template <typename Database, typename... Expressions>
       auto _group_by_impl(consistent_t, Expressions... expressions) const
diff --git a/include/sqlpp11/having.h b/include/sqlpp11/having.h
index 08905356..f8e0cfb7 100644
--- a/include/sqlpp11/having.h
+++ b/include/sqlpp11/having.h
@@ -272,7 +272,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename Expression>
-      auto _having_impl(Check, Expression expression) const -> Check;
+      auto _having_impl(Check, Expression expression) const -> inconsistent<Check>;
 
       template <typename Database, typename Expression>
       auto _having_impl(consistent_t, Expression expression) const
diff --git a/include/sqlpp11/inconsistent.h b/include/sqlpp11/inconsistent.h
index 326be226..0a46c929 100644
--- a/include/sqlpp11/inconsistent.h
+++ b/include/sqlpp11/inconsistent.h
@@ -27,22 +27,19 @@
 #ifndef SQLPP_INCONSISTENT_H
 #define SQLPP_INCONSISTENT_H
 
+#include <utility>
+
 namespace sqlpp
 {
+#if defined(__clang__) || defined(_MSC_VER)
   template <typename Check>
-  struct inconsistent
-  {
-    inconsistent(Check)
-    {
-    }
-  };
-
-  // This specialization circumvents an ambiguity problem with gcc
+  using inconsistent = Check;
+#else
+  // This version circumvents an ambiguity problem with gcc
   // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77449
-  template <>
-  struct inconsistent<consistent_t>
-  {
-  };
+  template <typename Check>
+  using inconsistent = typename std::enable_if<not std::is_same<consistent_t, Check>::value, Check>::type;
+#endif
 }
 
 #endif
diff --git a/include/sqlpp11/insert_value_list.h b/include/sqlpp11/insert_value_list.h
index 8eb718f6..2eed4b1b 100644
--- a/include/sqlpp11/insert_value_list.h
+++ b/include/sqlpp11/insert_value_list.h
@@ -526,7 +526,7 @@ namespace sqlpp
 
     private:
       template <typename Check, typename... Columns>
-      auto _columns_impl(inconsistent<Check>, Columns... cols) const -> Check;
+      auto _columns_impl(Check, Columns... cols) const -> inconsistent<Check>;
 
       template <typename... Columns>
       auto _columns_impl(consistent_t, Columns... cols) const
@@ -546,7 +546,7 @@ namespace sqlpp
       }
 
       template <typename Database, typename Check, typename... Assignments>
-      auto _set_impl(inconsistent<Check>, Assignments... assignments) const -> Check;
+      auto _set_impl(Check, Assignments... assignments) const -> inconsistent<Check>;
 
       template <typename Database, typename... Assignments>
       auto _set_impl(consistent_t, Assignments... assignments) const
diff --git a/include/sqlpp11/into.h b/include/sqlpp11/into.h
index e0489443..4f6ea14b 100644
--- a/include/sqlpp11/into.h
+++ b/include/sqlpp11/into.h
@@ -176,7 +176,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename Table>
-      auto _into_impl(Check, Table table) const -> Check;
+      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>>
diff --git a/include/sqlpp11/limit.h b/include/sqlpp11/limit.h
index d2fcb4ae..294c2ed0 100644
--- a/include/sqlpp11/limit.h
+++ b/include/sqlpp11/limit.h
@@ -272,7 +272,7 @@ namespace sqlpp
 
     private:
       template <typename Check, typename Arg>
-      auto _limit_impl(Check, Arg arg) const -> Check;
+      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>>
diff --git a/include/sqlpp11/offset.h b/include/sqlpp11/offset.h
index 8f1fd3e6..458b974a 100644
--- a/include/sqlpp11/offset.h
+++ b/include/sqlpp11/offset.h
@@ -288,7 +288,7 @@ namespace sqlpp
 
     private:
       template <typename Check, typename Arg>
-      auto _offset_impl(Check, Arg arg) const -> Check;
+      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>>
diff --git a/include/sqlpp11/order_by.h b/include/sqlpp11/order_by.h
index d13eb7a9..16d564cd 100644
--- a/include/sqlpp11/order_by.h
+++ b/include/sqlpp11/order_by.h
@@ -233,7 +233,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Expressions>
-      auto _order_by_impl(inconsistent<Check>, Expressions... expressions) const -> Check;
+      auto _order_by_impl(Check, Expressions... expressions) const -> inconsistent<Check>;
 
       template <typename Database, typename... Expressions>
       auto _order_by_impl(consistent_t, Expressions... expressions) const
diff --git a/include/sqlpp11/pre_join.h b/include/sqlpp11/pre_join.h
index 86b84c92..7cd8a9dc 100644
--- a/include/sqlpp11/pre_join.h
+++ b/include/sqlpp11/pre_join.h
@@ -114,7 +114,7 @@ namespace sqlpp
 
   private:
     template <typename Check, typename Expr>
-    auto on_impl(Check, const Expr&) const -> Check;
+    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>>
@@ -146,7 +146,7 @@ namespace sqlpp
   namespace detail
   {
     template <typename JoinType, typename Check, typename Lhs, typename Rhs>
-    auto join_impl(Check, Lhs lhs, Rhs rhs) -> Check;
+    auto join_impl(Check, Lhs lhs, Rhs rhs) -> inconsistent<Check>;
 
     template <typename JoinType, typename Lhs, typename Rhs>
     auto join_impl(consistent_t, Lhs lhs, Rhs rhs) -> pre_join_t<JoinType, Lhs, Rhs>;
@@ -190,7 +190,7 @@ namespace sqlpp
   namespace detail
   {
     template <typename Check, typename Lhs, typename Rhs>
-    auto cross_join_impl(Check, Lhs lhs, Rhs rhs) -> Check;
+    auto cross_join_impl(Check, Lhs lhs, Rhs rhs) -> inconsistent<Check>;
 
     template <typename Lhs, typename Rhs>
     auto cross_join_impl(consistent_t, Lhs lhs, Rhs rhs)
diff --git a/include/sqlpp11/select_column_list.h b/include/sqlpp11/select_column_list.h
index e6c3c3d2..8059eef6 100644
--- a/include/sqlpp11/select_column_list.h
+++ b/include/sqlpp11/select_column_list.h
@@ -409,7 +409,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Args>
-      auto _columns_impl(Check, std::tuple<Args...> args) const -> Check;
+      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
diff --git a/include/sqlpp11/select_flag_list.h b/include/sqlpp11/select_flag_list.h
index 7f593055..a1caa8df 100644
--- a/include/sqlpp11/select_flag_list.h
+++ b/include/sqlpp11/select_flag_list.h
@@ -223,7 +223,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Flags>
-      auto _flags_impl(inconsistent<Check>, Flags... flgs) const -> Check;
+      auto _flags_impl(Check, Flags... flgs) const -> inconsistent<Check>;
 
       template <typename Database, typename... Flags>
       auto _flags_impl(consistent_t, Flags... flgs) const
diff --git a/include/sqlpp11/single_table.h b/include/sqlpp11/single_table.h
index ee16289e..93881f88 100644
--- a/include/sqlpp11/single_table.h
+++ b/include/sqlpp11/single_table.h
@@ -176,7 +176,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename Table>
-      auto _single_table_impl(Check, Table table) const -> Check;
+      auto _single_table_impl(Check, Table table) const -> inconsistent<Check>;
 
       template <typename Database, typename Table>
       auto _single_table_impl(consistent_t, Table table) const
diff --git a/include/sqlpp11/union.h b/include/sqlpp11/union.h
index 2bac56c7..e113ea16 100644
--- a/include/sqlpp11/union.h
+++ b/include/sqlpp11/union.h
@@ -241,7 +241,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Flag, typename Check, typename Rhs>
-      auto _union_impl(Check, Rhs rhs) const -> Check;
+      auto _union_impl(Check, Rhs rhs) const -> inconsistent<Check>;
 
       template <typename Database, typename Flag, typename Rhs>
       auto _union_impl(consistent_t, Rhs rhs) const
diff --git a/include/sqlpp11/update_list.h b/include/sqlpp11/update_list.h
index c79c17d0..a95f434c 100644
--- a/include/sqlpp11/update_list.h
+++ b/include/sqlpp11/update_list.h
@@ -273,7 +273,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Assignments>
-      auto _set_impl(inconsistent<Check>, Assignments... assignments) const -> Check;
+      auto _set_impl(Check, Assignments... assignments) const -> inconsistent<Check>;
 
       template <typename Database, typename... Assignments>
       auto _set_impl(consistent_t, Assignments... assignments) const
diff --git a/include/sqlpp11/using.h b/include/sqlpp11/using.h
index 84fede64..6586f011 100644
--- a/include/sqlpp11/using.h
+++ b/include/sqlpp11/using.h
@@ -224,7 +224,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename... Tables>
-      auto _using_impl(inconsistent<Check>, Tables... tables) const -> Check;
+      auto _using_impl(Check, Tables... tables) const -> inconsistent<Check>;
 
       template <typename Database, typename... Tables>
       auto _using_impl(consistent_t, Tables... tables) const
diff --git a/include/sqlpp11/where.h b/include/sqlpp11/where.h
index 93b7e45a..c77af5d3 100644
--- a/include/sqlpp11/where.h
+++ b/include/sqlpp11/where.h
@@ -343,7 +343,7 @@ namespace sqlpp
 
     private:
       template <typename Database, typename Check, typename Expression>
-      auto _where_impl(Check, Expression expression) const -> Check;
+      auto _where_impl(Check, Expression expression) const -> inconsistent<Check>;
 
       template <typename Database, typename Expression>
       auto _where_impl(consistent_t, Expression expression) const
diff --git a/test_serializer/CustomQuery.cpp b/test_serializer/CustomQuery.cpp
index 4f3f106a..67294930 100644
--- a/test_serializer/CustomQuery.cpp
+++ b/test_serializer/CustomQuery.cpp
@@ -29,7 +29,7 @@
 
 #include <iostream>
 
-SQLPP_ALIAS_PROVIDER(pragma);
+SQLPP_ALIAS_PROVIDER(pragma)
 
 int CustomQuery(int, char* [])
 {

From 83d5147cd1191ef27859f90500e05361ded4ed29 Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Sat, 3 Sep 2016 12:35:40 +0200
Subject: [PATCH 10/11] Add begin/end to portable static assert to make error
 messages a bit shorter

---
 include/sqlpp11/portable_static_assert.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/sqlpp11/portable_static_assert.h b/include/sqlpp11/portable_static_assert.h
index b0a8036c..c7cbdcfb 100644
--- a/include/sqlpp11/portable_static_assert.h
+++ b/include/sqlpp11/portable_static_assert.h
@@ -40,6 +40,8 @@ namespace sqlpp
     {                                               \
       static_assert(wrong_t<T...>::value, message); \
     }                                               \
+    auto begin() const -> void;                     \
+    auto end() const -> void;                       \
   }
 
   namespace detail

From b688f47d4236223ec72bdfc080a6acc79141b957 Mon Sep 17 00:00:00 2001
From: Roland Bock <rbock@eudoxos.de>
Date: Sat, 3 Sep 2016 13:12:44 +0200
Subject: [PATCH 11/11] Aded gitter link

---
 README.md | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 4d1c69c8..2abd4307 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,12 @@ 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:
+--------
+  * Meet me at [CppCon 2016](https://cppcon2016.sched.org/event/7nKk)
+  * 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:
 -------------------------
@@ -109,9 +115,7 @@ Past talks about sqlpp11 and some coding concepts used within the library:
   * [MUC++:](http://www.meetup.com/MUCplusplus/)
    * 2014-02-27: [Selected C++11 Template Toffees From sqlpp11, Part1](https://www.youtube.com/watch?v=hXnGFYNbmXg), [Part2](https://www.youtube.com/watch?v=WPCV6dvxZ_U), [Part 3](https://www.youtube.com/watch?v=eB7hd_KjTig), [Part 4](https://www.youtube.com/watch?v=NBfqzcN0_EQ)
 
-You can contact me
-  * by posting issues at https://github.com/rbock/sqlpp11/issues
-  * or via email at rbock at eudoxos dot de
+
 
 
 Requirements: