diff --git a/include/sqlpp11/aggregate_functions/count.h b/include/sqlpp11/aggregate_functions/count.h
index 421e8b9f..8f93c514 100644
--- a/include/sqlpp11/aggregate_functions/count.h
+++ b/include/sqlpp11/aggregate_functions/count.h
@@ -30,7 +30,7 @@
 #include <sqlpp11/char_sequence.h>
 #include <sqlpp11/select_flags.h>
 #include <sqlpp11/aggregate_function_operators.h>
-#include <sqlpp11/data_types/integral/data_type.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/assignment.h b/include/sqlpp11/assignment.h
deleted file mode 100644
index 929523e1..00000000
--- a/include/sqlpp11/assignment.h
+++ /dev/null
@@ -1,71 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/default_value.h>
-#include <sqlpp11/null.h>
-#include <sqlpp11/serialize.h>
-#include <sqlpp11/simple_column.h>
-
-namespace sqlpp
-{
-  template <typename Lhs, typename Rhs>
-  struct assignment_t
-  {
-    using _traits = make_traits<no_value_t, tag::is_assignment>;
-    using _lhs_t = Lhs;
-    using _rhs_t = Rhs;
-    using _nodes = detail::type_vector<_lhs_t, _rhs_t>;
-
-#warning: We check this in the factory function
-    static_assert(can_be_null<_lhs_t>::value ? true
-                                               : not std::is_same<_rhs_t, null_t>::value,
-                  "column must not be null");
-
-    assignment_t(_lhs_t lhs, _rhs_t rhs) : _lhs(lhs), _rhs(rhs)
-    {
-    }
-
-    assignment_t(const assignment_t&) = default;
-    assignment_t(assignment_t&&) = default;
-    assignment_t& operator=(const assignment_t&) = default;
-    assignment_t& operator=(assignment_t&&) = default;
-    ~assignment_t() = default;
-
-    _lhs_t _lhs;
-    _rhs_t _rhs;
-  };
-
-  template <typename Context, typename Lhs, typename Rhs>
-  Context& serialize(const assignment_t<Lhs, Rhs>& t, Context& context)
-  {
-    serialize(simple_column(t._lhs), context);
-    context << "=";
-    serialize_operand(t._rhs, context);
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/basic_expression_operators.h b/include/sqlpp11/basic_expression_operators.h
deleted file mode 100644
index c4522c84..00000000
--- a/include/sqlpp11/basic_expression_operators.h
+++ /dev/null
@@ -1,327 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2016, Roland Bock
- * Copyright (c) 2016, Aaron Bishop
- * 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.
- */
-
-#include <sqlpp11/value_type_fwd.h>
-#include <sqlpp11/bad_expression.h>
-#include <sqlpp11/portable_static_assert.h>
-#include <sqlpp11/consistent.h>
-#include <sqlpp11/operator/as_expression.h>
-#include <sqlpp11/sort_order.h>
-#include <sqlpp11/expression_fwd.h>
-#include <sqlpp11/in_fwd.h>
-#include <sqlpp11/is_null_fwd.h>
-#include <sqlpp11/wrap_operand.h>
-#include <sqlpp11/logic.h>
-#include <sqlpp11/expression_return_types.h>
-
-namespace sqlpp
-{
-  SQLPP_PORTABLE_STATIC_ASSERT(assert_comparison_rhs_is_expression_t, "rhs operand in comparison is not an expression");
-  SQLPP_PORTABLE_STATIC_ASSERT(assert_comparison_rhs_is_valid_operand_t, "invalid rhs operand in comparison");
-  SQLPP_PORTABLE_STATIC_ASSERT(assert_comparison_lhs_rhs_differ_t, "identical lhs and rhs operands in comparison");
-
-  template <typename LhsType, typename RhsType>
-  using check_comparison_impl = static_combined_check_t<
-      static_check_t<logic::any_t<is_expression_t<RhsType>::value, is_multi_expression_t<RhsType>::value>::value,
-                     assert_comparison_rhs_is_expression_t>,
-      static_check_t<value_type_of_t<LhsType>::template _is_valid_operand<RhsType>::value,
-                     assert_comparison_rhs_is_valid_operand_t>,
-      static_check_t<not std::is_same<LhsType, RhsType>::value, assert_comparison_lhs_rhs_differ_t>>;
-
-  template <typename LhsType, typename RhsType>
-  using check_comparison_t = check_comparison_impl<LhsType, wrap_operand_t<RhsType>>;
-
-  template <typename LhsType, typename... RhsType>
-  using check_in_impl = static_combined_check_t<
-      static_check_t<logic::all_t<is_expression_t<RhsType>::value...>::value, assert_comparison_rhs_is_expression_t>,
-      static_check_t<logic::all_t<value_type_of_t<LhsType>::template _is_valid_operand<RhsType>::value...>::value,
-                     assert_comparison_rhs_is_valid_operand_t>,
-      static_check_t<logic::none_t<std::is_same<LhsType, RhsType>::value...>::value,
-                     assert_comparison_lhs_rhs_differ_t>>;
-
-  template <typename LhsType, typename... RhsType>
-  using check_in_t = check_in_impl<LhsType, typename wrap_operand<RhsType>::type...>;
-
-  namespace detail
-  {
-    template <bool Enable, template <typename Lhs, typename Rhs> class Expr, typename Lhs, typename Rhs>
-    struct comparison_expression_impl
-    {
-      using type = bad_expression<boolean>;
-    };
-
-    template <template <typename Lhs, typename Rhs> class Expr, typename Lhs, typename Rhs>
-    struct comparison_expression_impl<true, Expr, Lhs, Rhs>
-    {
-      using type = Expr<wrap_operand_t<Lhs>, wrap_operand_t<Rhs>>;
-    };
-  }  // namespace detail
-  template <template <typename Lhs, typename Rhs> class Expr, typename Lhs, typename Rhs>
-  using comparison_expression_t =
-      typename detail::comparison_expression_impl<check_comparison_t<Lhs, Rhs>::value, Expr, Lhs, Rhs>::type;
-
-  namespace detail
-  {
-    template <bool Enable, template <typename Lhs, typename... Rhs> class Expr, typename Lhs, typename... Rhs>
-    struct in_expression_impl
-    {
-      using type = bad_expression<boolean>;
-    };
-
-    template <template <typename Lhs, typename... Rhs> class Expr, typename Lhs, typename... Rhs>
-    struct in_expression_impl<true, Expr, Lhs, Rhs...>
-    {
-      using type = Expr<Lhs, Rhs...>;
-    };
-  }  // namespace detail
-  template <typename Check, template <typename Lhs, typename... Rhs> class Expr, typename Lhs, typename... Rhs>
-  using in_expression_t = typename detail::in_expression_impl<Check::value, Expr, Lhs, Rhs...>::type;
-
-  // basic operators
-  template <typename Expr>
-  struct basic_expression_operators
-  {
-    template <template <typename Lhs, typename Rhs> class NewExpr, typename T>
-    struct _new_binary_expression
-    {
-      using type = comparison_expression_t<NewExpr, Expr, T>;
-    };
-    template <template <typename Lhs, typename Rhs> class NewExpr, typename T>
-    using _new_binary_expression_t = typename _new_binary_expression<NewExpr, T>::type;
-
-    template <template <typename Lhs, typename... Rhs> class NewExpr, typename... T>
-    struct _new_nary_expression
-    {
-      using _check = check_in_t<Expr, T...>;
-      using type = in_expression_t<_check, NewExpr, Expr, wrap_operand_t<T>...>;
-    };
-
-#if 0
-    template <typename T>
-    auto operator==(T t) const -> _new_binary_expression_t<equal_to_t, T>
-    {
-      using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::verify();
-
-      return {*static_cast<const Expr*>(this), rhs{t}};
-    }
-
-    template <typename T>
-    auto operator!=(T t) const -> _new_binary_expression_t<not_equal_to_t, T>
-    {
-      using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::verify();
-
-      return {*static_cast<const Expr*>(this), rhs{t}};
-    }
-
-    template <typename T>
-    auto operator<(T t) const -> _new_binary_expression_t<less_than_t, T>
-    {
-      using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::verify();
-
-      return {*static_cast<const Expr*>(this), rhs{t}};
-    }
-
-    template <typename T>
-    auto operator<=(T t) const -> _new_binary_expression_t<less_equal_t, T>
-    {
-      using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::verify();
-
-      return {*static_cast<const Expr*>(this), rhs{t}};
-    }
-
-    template <typename T>
-    auto operator>(T t) const -> _new_binary_expression_t<greater_than_t, T>
-    {
-      using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::verify();
-
-      return {*static_cast<const Expr*>(this), rhs{t}};
-    }
-
-    template <typename T>
-    auto operator>=(T t) const -> _new_binary_expression_t<greater_equal_t, T>
-    {
-      using rhs = wrap_operand_t<T>;
-      check_comparison_t<Expr, rhs>::verify();
-
-      return {*static_cast<const Expr*>(this), rhs{t}};
-    }
-
-    auto is_null() const -> is_null_t<Expr>
-    {
-      return {*static_cast<const Expr*>(this)};
-    }
-
-    auto is_not_null() const -> is_not_null_t<Expr>
-    {
-      return {*static_cast<const Expr*>(this)};
-    }
-
-    auto asc() const -> sort_order_t<Expr>
-    {
-      return {*static_cast<const Expr*>(this), sort_type::asc};
-    }
-
-    auto desc() const -> sort_order_t<Expr>
-    {
-      return {*static_cast<const Expr*>(this), sort_type::desc};
-    }
-
-    auto order(sort_type s) const -> sort_order_t<Expr>
-    {
-      return {*static_cast<const Expr*>(this), s};
-    }
-
-    template <typename... T>
-    auto in(T... t) const -> typename _new_nary_expression<in_t, T...>::type
-    {
-      check_in_t<Expr, wrap_operand_t<T>...>::verify();
-      return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...};
-    }
-
-    template <typename... T>
-    auto not_in(T... t) const -> typename _new_nary_expression<not_in_t, T...>::type
-    {
-      check_in_t<Expr, wrap_operand_t<T>...>::verify();
-      return {*static_cast<const Expr*>(this), typename wrap_operand<T>::type{t}...};
-    }
-#endif
-
-    /*
-    template <typename Defer = void>
-    auto operator not() const -> return_type_not_t<Expr, Defer>
-    {
-      return_type_not<Expr, Defer>::check::verify();
-      return {*static_cast<const Expr*>(this)};
-    }
-
-    template <typename R>
-    auto operator and(const R& r) const -> return_type_and_t<Expr, R>
-    {
-      return_type_and<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-
-    template <typename R>
-    auto operator or(const R& r) const -> return_type_or_t<Expr, R>
-    {
-      return_type_or<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-
-    */
-
-    /*
-    template <typename R>
-    auto operator&(const R& r) const -> return_type_bitwise_and_t<Expr, R>
-    {
-      return_type_bitwise_and<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-
-    template <typename R>
-    auto operator|(const R& r) const -> return_type_bitwise_or_t<Expr, R>
-    {
-      return_type_bitwise_or<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-    */
-
-    /*
-    template <typename R>
-    auto operator+(const R& r) const -> return_type_plus_t<Expr, R>
-    {
-      return_type_plus<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-
-    template <typename R>
-    auto operator-(const R& r) const -> return_type_minus_t<Expr, R>
-    {
-      return_type_minus<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-
-    template <typename R>
-    auto operator*(const R& r) const -> return_type_multiplies_t<Expr, R>
-    {
-      return_type_multiplies<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-
-    template <typename R>
-    auto operator/(const R& r) const -> return_type_divides_t<Expr, R>
-    {
-      return_type_divides<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-
-    template <typename R>
-    auto operator%(const R& r) const -> return_type_modulus_t<Expr, R>
-    {
-      return_type_modulus<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-    */
-
-    template <typename Defer = void>
-    auto operator+() const -> return_type_unary_plus_t<Expr, Defer>
-    {
-      return_type_unary_plus<Expr, Defer>::check::verify();
-      return {*static_cast<const Expr*>(this)};
-    }
-
-    /*
-    template <typename Defer = void>
-    auto operator-() const -> return_type_unary_minus_t<Expr, Defer>
-    {
-      return_type_unary_minus<Expr, Defer>::check::verify();
-      return {*static_cast<const Expr*>(this)};
-    }
-
-    template <typename R>
-    auto operator<<(const R& r) const -> return_type_shift_left_t<Expr, R>
-    {
-      return_type_shift_left<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-
-    template <typename R>
-    auto operator>>(const R& r) const -> return_type_shift_right_t<Expr, R>
-    {
-      return_type_shift_right<Expr, R>::check::verify();
-      return {*static_cast<const Expr*>(this), wrap_operand_t<R>{r}};
-    }
-    */
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/case.h b/include/sqlpp11/case.h
index 02e684c4..4ea831d2 100644
--- a/include/sqlpp11/case.h
+++ b/include/sqlpp11/case.h
@@ -27,7 +27,6 @@
  */
 
 #include <sqlpp11/char_sequence.h>
-#include <sqlpp11/data_types/boolean.h>
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/type_traits.h>
 
@@ -57,10 +56,10 @@ namespace sqlpp
 
   template <typename When, typename Then, typename Else>
   struct case_t
-      : public expression_operators<
+      /*: public expression_operators<
             case_t<When, Then, Else>,
             typename std::conditional<is_sql_null_t<Then>::value, value_type_of_t<Else>, value_type_of_t<Then>>::type>,
-        public alias_operators<case_t<When, Then, Else>>
+        public alias_operators<case_t<When, Then, Else>>*/
   {
     using _traits = make_traits<value_type_of_t<Then>, tag::is_expression>;
     using _nodes = detail::type_vector<When, Then, Else>;
diff --git a/include/sqlpp11/column.h b/include/sqlpp11/column.h
index b8450bf2..3acd42e3 100644
--- a/include/sqlpp11/column.h
+++ b/include/sqlpp11/column.h
@@ -30,10 +30,8 @@
 #include <sqlpp11/operator/assign_expression.h>
 #include <sqlpp11/column_fwd.h>
 #include <sqlpp11/default_value.h>
-#include <sqlpp11/null.h>
 #include <sqlpp11/sort_order.h>
 #include <sqlpp11/type_traits.h>
-#include <sqlpp11/assignment.h>
 #include <sqlpp11/wrong.h>
 #include <sqlpp11/detail/type_set.h>
 
@@ -57,9 +55,6 @@ namespace sqlpp
     using _table = Table;
     using _alias_t = typename _spec_t::_alias_t;
 
-    template <typename T>
-    using _is_valid_assignment_operand = is_valid_assignment_operand<typename ColumnSpec::value_type, T>;
-
     column_t() = default;
     column_t(const column_t&) = default;
     column_t(column_t&&) = default;
@@ -90,17 +85,6 @@ namespace sqlpp
     {
       return assign(*this, std::move(value));
     }
-
-    auto operator=(null_t /*unused*/) const -> assignment_t<column_t, null_t>
-    {
-      static_assert(can_be_null<column_t>::value, "column cannot be null");
-      return {*this, null_t{}};
-    }
-
-    auto operator=(default_value_t /*unused*/) const -> assignment_t<column_t, default_value_t>
-    {
-      return {*this, default_value_t{}};
-    }
   };
 
   template<typename Table, typename ColumnSpec>
diff --git a/include/sqlpp11/custom_query.h b/include/sqlpp11/custom_query.h
index 559a8c70..6c337da2 100644
--- a/include/sqlpp11/custom_query.h
+++ b/include/sqlpp11/custom_query.h
@@ -129,10 +129,10 @@ namespace sqlpp
   }
 
   template <typename... Parts>
-  auto custom_query(Parts... parts) -> custom_query_t<wrap_operand_t<Parts>...>
+  auto custom_query(Parts... parts) -> custom_query_t<Parts...>
   {
     static_assert(sizeof...(Parts) > 0, "custom query requires at least one argument");
-    return custom_query_t<wrap_operand_t<Parts>...>(parts...);
+    return custom_query_t<Parts...>(parts...);
   }
 
 }  // namespace sqlpp
diff --git a/include/sqlpp11/data_types.h b/include/sqlpp11/data_types.h
deleted file mode 100644
index feae0446..00000000
--- a/include/sqlpp11/data_types.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2017, Roland Bock, Aaron Bishop
- * 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.
- */
-
-#include <sqlpp11/data_types/blob.h>
-#include <sqlpp11/data_types/boolean.h>
-#include <sqlpp11/data_types/integral.h>
-#include <sqlpp11/data_types/unsigned_integral.h>
-#include <sqlpp11/data_types/floating_point.h>
-#include <sqlpp11/data_types/text.h>
-#include <sqlpp11/data_types/day_point.h>
-#include <sqlpp11/data_types/time_of_day.h>
-#include <sqlpp11/data_types/time_point.h>
-#include <sqlpp11/data_types/no_value.h>
diff --git a/include/sqlpp11/data_types/blob.h b/include/sqlpp11/data_types/blob.h
deleted file mode 100644
index 33f8ba90..00000000
--- a/include/sqlpp11/data_types/blob.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2017, 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.
- */
-
-#include <sqlpp11/data_types/blob/data_type.h>
-#include <sqlpp11/data_types/blob/operand.h>
-#include <sqlpp11/data_types/blob/wrap_operand.h>
-#include <sqlpp11/data_types/blob/expression_operators.h>
-#include <sqlpp11/data_types/blob/column_operators.h>
-#include <sqlpp11/data_types/blob/parameter_value.h>
-
-// blob specific functions
-#include <sqlpp11/data_types/text/like.h>
-#include <sqlpp11/data_types/text/concat.h>
diff --git a/include/sqlpp11/data_types/blob/column_operators.h b/include/sqlpp11/data_types/blob/column_operators.h
deleted file mode 100644
index 54fa7d34..00000000
--- a/include/sqlpp11/data_types/blob/column_operators.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2017, 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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/data_types/blob/data_type.h>
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  template <typename... Args>
-  struct concat_t;
-
-  template <typename Column>
-  struct column_operators<Column, blob>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<blob, T>;
-
-    template <typename T>
-    auto operator+=(T t) const -> assignment_t<Column, concat_t<Column, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this),
-              concat_t<Column, wrap_operand_t<T>>{*static_cast<const Column*>(this), rhs{t}}};
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/blob/data_type.h b/include/sqlpp11/data_types/blob/data_type.h
deleted file mode 100644
index 31437609..00000000
--- a/include/sqlpp11/data_types/blob/data_type.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2017, 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.
- */
-
-#include <vector>
-#include <cstdint>
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/compat/span.h>
-#include <sqlpp11/logic.h>
-
-namespace sqlpp
-{
-  struct blob
-  {
-    using _traits = make_traits<blob, tag::is_value_type>;
-    using _cpp_value_type = std::vector<std::uint8_t>;
-    using _result_type = sqlpp::compat::span<std::uint8_t>;
-
-    template <typename T>
-    using _is_valid_operand = ::sqlpp::logic::any_t<is_blob_t<T>::value, is_text_t<T>::value>;
-  };
-
-  using blob = blob;
-  using mediumblob = blob;
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/blob/expression_operators.h b/include/sqlpp11/data_types/blob/expression_operators.h
deleted file mode 100644
index da1d2767..00000000
--- a/include/sqlpp11/data_types/blob/expression_operators.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2017, 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.
- */
-
-#include <sqlpp11/operand_check.h>
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/data_types/blob/data_type.h>
-#include <sqlpp11/data_types/text/return_type_like.h>
-
-namespace sqlpp
-{
-  template <typename Operand, typename Pattern>
-  struct like_t;
-
-  template <typename L, typename R>
-  struct return_type_like<L, R, binary_operand_check_t<L, is_blob_t, R, is_blob_t>>
-  {
-    using check = consistent_t;
-    using type = like_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_like<L, R, binary_operand_check_t<L, is_blob_t, R, is_text_t>>
-  {
-    using check = consistent_t;
-    using type = like_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename Expression>
-  struct expression_operators<Expression, blob> : public basic_expression_operators<Expression>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<blob, T>;
-
-    template <typename R>
-    auto like(const R& r) const -> return_type_like_t<Expression, R>
-    {
-      typename return_type_like<Expression, R>::check{};
-      return {*static_cast<const Expression*>(this), wrap_operand_t<R>{r}};
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/blob/operand.h b/include/sqlpp11/data_types/blob/operand.h
deleted file mode 100644
index 5bd0cdec..00000000
--- a/include/sqlpp11/data_types/blob/operand.h
+++ /dev/null
@@ -1,80 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2017, 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.
- */
-
-#include <vector>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/alias_operators.h>
-
-namespace sqlpp
-{
-  struct blob;
-
-  struct blob_operand : public alias_operators<blob_operand>
-  {
-    using _traits = make_traits<blob, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = std::vector<std::uint8_t>;
-
-    blob_operand() : _t{}
-    {
-    }
-
-    blob_operand(_value_t t) : _t(t)
-    {
-    }
-
-    template <std::size_t N>
-    blob_operand(const std::array<uint8_t, N>& t) : _t(t.begin(), t.end())
-    {
-    }
-
-    blob_operand(const blob_operand&) = default;
-    blob_operand(blob_operand&&) = default;
-    blob_operand& operator=(const blob_operand&) = default;
-    blob_operand& operator=(blob_operand&&) = default;
-    ~blob_operand() = default;
-
-    _value_t _t;
-  };
-
-  template <typename Context>
-  Context& serialize(const blob_operand& t, Context& context)
-  {
-    constexpr char hexChars[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
-    context << "x'";
-    for (const auto c : t._t)
-    {
-      context << hexChars[c >> 4] << hexChars[c & 0x0F];
-    }
-    context << '\'';
-
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/blob/parameter_value.h b/include/sqlpp11/data_types/blob/parameter_value.h
deleted file mode 100644
index 036de3d7..00000000
--- a/include/sqlpp11/data_types/blob/parameter_value.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2017, 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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/data_types/parameter_value_base.h>
-#include <sqlpp11/data_types/blob/data_type.h>
-#include <sqlpp11/data_types/blob/wrap_operand.h>
-#include <sqlpp11/data_types/blob/operand.h>
-
-namespace sqlpp
-{
-  template <>
-  struct parameter_value_t<blob> : public parameter_value_base<blob>
-  {
-    using base = parameter_value_base<blob>;
-    using base::base;
-    using base::operator=;
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_blob_parameter(index, &_value, _is_null);
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/blob/wrap_operand.h b/include/sqlpp11/data_types/blob/wrap_operand.h
deleted file mode 100644
index a0fd7934..00000000
--- a/include/sqlpp11/data_types/blob/wrap_operand.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2017, 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.
- */
-
-#include <utility>
-#include <vector>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/wrap_operand.h>
-
-namespace sqlpp
-{
-  struct blob_operand;
-
-  template <>
-  struct wrap_operand<std::vector<std::uint8_t>, void>
-  {
-    using type = blob_operand;
-  };
-
-  template <std::size_t N>
-  struct wrap_operand<std::array<std::uint8_t, N>, void>
-  {
-    using type = blob_operand;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/boolean.h b/include/sqlpp11/data_types/boolean.h
deleted file mode 100644
index 627aab6d..00000000
--- a/include/sqlpp11/data_types/boolean.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/boolean/data_type.h>
-#include <sqlpp11/data_types/boolean/operand.h>
-#include <sqlpp11/data_types/boolean/wrap_operand.h>
-#include <sqlpp11/data_types/boolean/expression_operators.h>
-#include <sqlpp11/data_types/boolean/column_operators.h>
-#include <sqlpp11/data_types/boolean/parameter_value.h>
diff --git a/include/sqlpp11/data_types/boolean/column_operators.h b/include/sqlpp11/data_types/boolean/column_operators.h
deleted file mode 100644
index 52e294f1..00000000
--- a/include/sqlpp11/data_types/boolean/column_operators.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  struct boolean;
-
-  template <typename Column>
-  struct column_operators<Column, boolean>
-  {
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/boolean/data_type.h b/include/sqlpp11/data_types/boolean/data_type.h
deleted file mode 100644
index 57370e8a..00000000
--- a/include/sqlpp11/data_types/boolean/data_type.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-
-namespace sqlpp
-{
-  struct boolean
-  {
-    using _traits = make_traits<boolean, tag::is_value_type>;
-    using _cpp_value_type = bool;
-    using _result_type = bool;
-
-    template <typename T>
-    using _is_valid_operand = is_boolean_t<T>;
-  };
-
-  using bit = sqlpp::boolean;
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/boolean/expression_operators.h b/include/sqlpp11/data_types/boolean/expression_operators.h
deleted file mode 100644
index 3a301b50..00000000
--- a/include/sqlpp11/data_types/boolean/expression_operators.h
+++ /dev/null
@@ -1,63 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/expression_return_types.h>
-#include <sqlpp11/operand_check.h>
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-
-namespace sqlpp
-{
-  template <typename Expression>
-  struct expression_operators<Expression, boolean> : public basic_expression_operators<Expression>
-  {
-  };
-
-  /*
-  template <typename L, typename R>
-  struct return_type_and<L, R, unwrapped_binary_operand_check_t<L, is_boolean_t, R, is_boolean_t>>
-  {
-    using check = consistent_t;
-    using type = logical_and_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_or<L, R, unwrapped_binary_operand_check_t<L, is_boolean_t, R, is_boolean_t>>
-  {
-    using check = consistent_t;
-    using type = logical_or_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename T, typename Defer>
-  struct return_type_not<T, Defer, unwrapped_unary_operand_check_t<T, is_boolean_t>>
-  {
-    using check = consistent_t;
-    using type = logical_not_t<wrap_operand_t<T>>;
-  };
-  */
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/boolean/operand.h b/include/sqlpp11/data_types/boolean/operand.h
deleted file mode 100644
index b22c7820..00000000
--- a/include/sqlpp11/data_types/boolean/operand.h
+++ /dev/null
@@ -1,69 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <ciso646>  // Required for some compilers to use aliases for boolean operators
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/alias_operators.h>
-
-namespace sqlpp
-{
-  struct boolean;
-
-  struct boolean_operand : public alias_operators<boolean_operand>
-  {
-    using _traits = make_traits<boolean, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = bool;
-
-    boolean_operand() : _t{}
-    {
-    }
-
-    boolean_operand(_value_t t) : _t(t)
-    {
-    }
-
-    boolean_operand(const boolean_operand&) = default;
-    boolean_operand(boolean_operand&&) = default;
-    boolean_operand& operator=(const boolean_operand&) = default;
-    boolean_operand& operator=(boolean_operand&&) = default;
-    ~boolean_operand() = default;
-
-    _value_t _t;
-  };
-
-  template <typename Context>
-  Context& serialize(const boolean_operand& t, Context& context)
-  {
-    context << t._t;
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/boolean/parameter_value.h b/include/sqlpp11/data_types/boolean/parameter_value.h
deleted file mode 100644
index 60436f16..00000000
--- a/include/sqlpp11/data_types/boolean/parameter_value.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/data_types/parameter_value_base.h>
-#include <sqlpp11/data_types/boolean/data_type.h>
-
-namespace sqlpp
-{
-  template <>
-  struct parameter_value_t<boolean> : public parameter_value_base<boolean, signed char>
-  {
-    using base = parameter_value_base<boolean, signed char>;
-    using base::base;
-    using base::operator=;
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_boolean_parameter(index, &_value, _is_null);
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/boolean/wrap_operand.h b/include/sqlpp11/data_types/boolean/wrap_operand.h
deleted file mode 100644
index 918927f2..00000000
--- a/include/sqlpp11/data_types/boolean/wrap_operand.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/wrap_operand.h>
-
-namespace sqlpp
-{
-  struct boolean_operand;
-
-  template <>
-  struct wrap_operand<bool, void>
-  {
-    using type = boolean_operand;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/column_operators.h b/include/sqlpp11/data_types/column_operators.h
deleted file mode 100644
index 5db03d87..00000000
--- a/include/sqlpp11/data_types/column_operators.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/wrong.h>
-
-namespace sqlpp
-{
-  template <typename Column, typename ValueType>
-  struct column_operators
-  {
-    static_assert(wrong_t<column_operators>::value, "Missing column operators for ValueType");
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/day_point.h b/include/sqlpp11/data_types/day_point.h
deleted file mode 100644
index bad4fa51..00000000
--- a/include/sqlpp11/data_types/day_point.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/data_types/day_point/data_type.h>
-#include <sqlpp11/data_types/day_point/operand.h>
-#include <sqlpp11/data_types/day_point/wrap_operand.h>
-#include <sqlpp11/data_types/day_point/expression_operators.h>
-#include <sqlpp11/data_types/day_point/column_operators.h>
-#include <sqlpp11/data_types/day_point/parameter_value.h>
diff --git a/include/sqlpp11/data_types/day_point/column_operators.h b/include/sqlpp11/data_types/day_point/column_operators.h
deleted file mode 100644
index 2219e331..00000000
--- a/include/sqlpp11/data_types/day_point/column_operators.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/data_types/day_point/data_type.h>
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  template <typename Column>
-  struct column_operators<Column, day_point>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<day_point, T>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/day_point/data_type.h b/include/sqlpp11/data_types/day_point/data_type.h
deleted file mode 100644
index 1a670a56..00000000
--- a/include/sqlpp11/data_types/day_point/data_type.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/chrono.h>
-#include <sqlpp11/type_traits.h>
-
-namespace sqlpp
-{
-  struct day_point
-  {
-    using _traits = make_traits<day_point, tag::is_value_type>;
-    using _cpp_value_type = ::sqlpp::chrono::day_point;
-    using _result_type = ::sqlpp::chrono::day_point;
-
-    template <typename T>
-    using _is_valid_operand = is_day_or_time_point_t<T>;
-    template <typename T>
-    using _is_valid_assignment_operand = is_day_point_t<T>;
-  };
-
-  using date = day_point;
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/day_point/expression_operators.h b/include/sqlpp11/data_types/day_point/expression_operators.h
deleted file mode 100644
index 33b6bb2a..00000000
--- a/include/sqlpp11/data_types/day_point/expression_operators.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/data_types/day_point/data_type.h>
-
-namespace sqlpp
-{
-  template <typename Expression>
-  struct expression_operators<Expression, day_point> : public basic_expression_operators<Expression>
-  {
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/day_point/operand.h b/include/sqlpp11/data_types/day_point/operand.h
deleted file mode 100644
index 0444cf08..00000000
--- a/include/sqlpp11/data_types/day_point/operand.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <date/date.h>
-#include <sqlpp11/chrono.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/alias_operators.h>
-
-namespace sqlpp
-{
-  struct day_point;
-
-  struct day_point_operand : public alias_operators<day_point_operand>
-  {
-    using _traits = make_traits<day_point, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = ::sqlpp::chrono::day_point;
-
-    day_point_operand() = default;
-
-    day_point_operand(_value_t t) : _t(t)
-    {
-    }
-
-    day_point_operand(const day_point_operand&) = default;
-    day_point_operand(day_point_operand&&) = default;
-    day_point_operand& operator=(const day_point_operand&) = default;
-    day_point_operand& operator=(day_point_operand&&) = default;
-    ~day_point_operand() = default;
-
-    _value_t _t;
-  };
-
-  template <typename Context>
-  Context& serialize(const day_point_operand& t, Context& context)
-  {
-    const auto ymd = ::date::year_month_day{t._t};
-    context << "DATE '" << ymd << "'";
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/day_point/parameter_value.h b/include/sqlpp11/data_types/day_point/parameter_value.h
deleted file mode 100644
index 4e7120af..00000000
--- a/include/sqlpp11/data_types/day_point/parameter_value.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/data_types/parameter_value_base.h>
-#include <sqlpp11/data_types/day_point/data_type.h>
-#include <sqlpp11/data_types/day_point/wrap_operand.h>
-#include <sqlpp11/data_types/day_point/operand.h>
-
-namespace sqlpp
-{
-  template <>
-  struct parameter_value_t<day_point> : public parameter_value_base<day_point>
-  {
-    using base = parameter_value_base<day_point>;
-    using base::base;
-    using base::operator=;
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_date_parameter(index, &_value, _is_null);
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/day_point/wrap_operand.h b/include/sqlpp11/data_types/day_point/wrap_operand.h
deleted file mode 100644
index ead6d699..00000000
--- a/include/sqlpp11/data_types/day_point/wrap_operand.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <utility>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/chrono.h>
-#include <sqlpp11/wrap_operand.h>
-
-namespace sqlpp
-{
-  struct day_point_operand;
-
-  template <>
-  struct wrap_operand<std::chrono::time_point<std::chrono::system_clock, sqlpp::chrono::days>, void>
-  {
-    using type = day_point_operand;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/floating_point.h b/include/sqlpp11/data_types/floating_point.h
deleted file mode 100644
index cd872490..00000000
--- a/include/sqlpp11/data_types/floating_point.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/floating_point/data_type.h>
-#include <sqlpp11/data_types/floating_point/operand.h>
-#include <sqlpp11/data_types/floating_point/wrap_operand.h>
-#include <sqlpp11/data_types/floating_point/expression_operators.h>
-#include <sqlpp11/data_types/floating_point/column_operators.h>
-#include <sqlpp11/data_types/floating_point/parameter_value.h>
diff --git a/include/sqlpp11/data_types/floating_point/column_operators.h b/include/sqlpp11/data_types/floating_point/column_operators.h
deleted file mode 100644
index 944ce037..00000000
--- a/include/sqlpp11/data_types/floating_point/column_operators.h
+++ /dev/null
@@ -1,78 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/data_types/floating_point/data_type.h>
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  template <typename Column>
-  struct column_operators<Column, floating_point>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<floating_point, T>;
-
-    template <typename T>
-    auto operator+=(T t) const -> assignment_t<Column, plus_t<Column, floating_point, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
-    }
-
-    template <typename T>
-    auto operator-=(T t) const -> assignment_t<Column, minus_t<Column, floating_point, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
-    }
-
-    template <typename T>
-    auto operator/=(T t) const -> assignment_t<Column, divides_t<Column, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
-    }
-
-    template <typename T>
-    auto operator*=(T t) const -> assignment_t<Column, multiplies_t<Column, floating_point, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/floating_point/data_type.h b/include/sqlpp11/data_types/floating_point/data_type.h
deleted file mode 100644
index c8e7fb98..00000000
--- a/include/sqlpp11/data_types/floating_point/data_type.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-
-namespace sqlpp
-{
-  struct floating_point
-  {
-    using _traits = make_traits<floating_point, tag::is_value_type>;
-    using _cpp_value_type = double;
-    using _result_type = double;
-
-    template <typename T>
-    using _is_valid_operand = is_numeric_t<T>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/floating_point/expression_operators.h b/include/sqlpp11/data_types/floating_point/expression_operators.h
deleted file mode 100644
index 65a615ee..00000000
--- a/include/sqlpp11/data_types/floating_point/expression_operators.h
+++ /dev/null
@@ -1,84 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/expression_return_types.h>
-#include <sqlpp11/operand_check.h>
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/data_types/floating_point/data_type.h>
-
-namespace sqlpp
-{
-  template <typename Expr>
-  struct expression_operators<Expr, floating_point> : public basic_expression_operators<Expr>
-  {
-  };
-
-  template <typename L, typename R>
-  struct return_type_plus<L, R, binary_operand_check_t<L, is_floating_point_t, R, is_numeric_t>>
-  {
-    using check = consistent_t;
-    using type = plus_t<wrap_operand_t<L>, floating_point, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_minus<L, R, binary_operand_check_t<L, is_floating_point_t, R, is_numeric_t>>
-  {
-    using check = consistent_t;
-    using type = minus_t<wrap_operand_t<L>, floating_point, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_multiplies<L, R, binary_operand_check_t<L, is_floating_point_t, R, is_numeric_t>>
-  {
-    using check = consistent_t;
-    using type = multiplies_t<wrap_operand_t<L>, floating_point, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_divides<L, R, binary_operand_check_t<L, is_floating_point_t, R, is_numeric_t>>
-  {
-    using check = consistent_t;
-    using type = divides_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename T, typename Defer>
-  struct return_type_unary_plus<T, Defer, unary_operand_check_t<T, is_floating_point_t>>
-  {
-    using check = consistent_t;
-    using type = unary_plus_t<floating_point, wrap_operand_t<T>>;
-  };
-
-  template <typename T, typename Defer>
-  struct return_type_unary_minus<T, Defer, unary_operand_check_t<T, is_floating_point_t>>
-  {
-    using check = consistent_t;
-    using type = unary_minus_t<floating_point, wrap_operand_t<T>>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/floating_point/operand.h b/include/sqlpp11/data_types/floating_point/operand.h
deleted file mode 100644
index edc87109..00000000
--- a/include/sqlpp11/data_types/floating_point/operand.h
+++ /dev/null
@@ -1,65 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/alias_operators.h>
-
-namespace sqlpp
-{
-  struct floating_point_operand : public alias_operators<floating_point_operand>
-  {
-    using _traits = make_traits<floating_point, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = double;
-
-    floating_point_operand() : _t{}
-    {
-    }
-
-    floating_point_operand(_value_t t) : _t(t)
-    {
-    }
-
-    floating_point_operand(const floating_point_operand&) = default;
-    floating_point_operand(floating_point_operand&&) = default;
-    floating_point_operand& operator=(const floating_point_operand&) = default;
-    floating_point_operand& operator=(floating_point_operand&&) = default;
-    ~floating_point_operand() = default;
-
-    _value_t _t;
-  };
-
-  template <typename Context>
-  Context& serialize(const floating_point_operand& t, Context& context)
-  {
-    context << t._t;
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/floating_point/parameter_value.h b/include/sqlpp11/data_types/floating_point/parameter_value.h
deleted file mode 100644
index 4209db48..00000000
--- a/include/sqlpp11/data_types/floating_point/parameter_value.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/data_types/parameter_value_base.h>
-#include <sqlpp11/data_types/floating_point/data_type.h>
-#include <sqlpp11/data_types/floating_point/wrap_operand.h>
-#include <sqlpp11/data_types/floating_point/operand.h>
-
-namespace sqlpp
-{
-  template <>
-  struct parameter_value_t<floating_point> : public parameter_value_base<floating_point>
-  {
-    using base = parameter_value_base<floating_point>;
-    using base::base;
-    using base::operator=;
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_floating_point_parameter(index, &_value, _is_null);
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/floating_point/wrap_operand.h b/include/sqlpp11/data_types/floating_point/wrap_operand.h
deleted file mode 100644
index 88a007fc..00000000
--- a/include/sqlpp11/data_types/floating_point/wrap_operand.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <utility>
-#include <sqlpp11/wrap_operand.h>
-
-namespace sqlpp
-{
-  struct floating_point_operand;
-
-  template <typename T>
-  struct wrap_operand<T, typename std::enable_if<std::is_floating_point<T>::value>::type>
-  {
-    using type = floating_point_operand;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/integral.h b/include/sqlpp11/data_types/integral.h
deleted file mode 100644
index 0f8f1cad..00000000
--- a/include/sqlpp11/data_types/integral.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/integral/data_type.h>
-#include <sqlpp11/data_types/integral/operand.h>
-#include <sqlpp11/data_types/integral/wrap_operand.h>
-#include <sqlpp11/data_types/integral/expression_operators.h>
-#include <sqlpp11/data_types/integral/column_operators.h>
-#include <sqlpp11/data_types/integral/parameter_value.h>
diff --git a/include/sqlpp11/data_types/integral/column_operators.h b/include/sqlpp11/data_types/integral/column_operators.h
deleted file mode 100644
index e3c5d2ab..00000000
--- a/include/sqlpp11/data_types/integral/column_operators.h
+++ /dev/null
@@ -1,79 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/value_type.h>
-#include <sqlpp11/data_types/integral/data_type.h>
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  template <typename Column>
-  struct column_operators<Column, integral>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<integral, T>;
-
-    template <typename T>
-    auto operator+=(T t) const -> assignment_t<Column, plus_t<Column, value_type_t<T>, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
-    }
-
-    template <typename T>
-    auto operator-=(T t) const -> assignment_t<Column, minus_t<Column, value_type_t<T>, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
-    }
-
-    template <typename T>
-    auto operator/=(T t) const -> assignment_t<Column, divides_t<Column, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
-    }
-
-    template <typename T>
-    auto operator*=(T t) const -> assignment_t<Column, multiplies_t<Column, value_type_t<T>, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/integral/data_type.h b/include/sqlpp11/data_types/integral/data_type.h
deleted file mode 100644
index b2f2b38d..00000000
--- a/include/sqlpp11/data_types/integral/data_type.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-
-namespace sqlpp
-{
-  struct integral
-  {
-    using _traits = make_traits<integral, tag::is_value_type>;
-    using _cpp_value_type = int64_t;
-    using _result_type = int64_t;
-
-    template <typename T>
-    using _is_valid_operand = is_numeric_t<T>;
-  };
-
-  using tinyint = integral;
-  using smallint = integral;
-  using integer = integral;
-  using bigint = integral;
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/integral/expression_operators.h b/include/sqlpp11/data_types/integral/expression_operators.h
deleted file mode 100644
index b0f71e98..00000000
--- a/include/sqlpp11/data_types/integral/expression_operators.h
+++ /dev/null
@@ -1,148 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2016, Roland Bock, Aaron Bishop
- * 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.
- */
-
-#include <sqlpp11/expression_return_types.h>
-#include <sqlpp11/operand_check.h>
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-#include <sqlpp11/value_type.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/data_types/integral/data_type.h>
-
-namespace sqlpp
-{
-  template <typename Expression>
-  struct expression_operators<Expression, integral> : public basic_expression_operators<Expression>
-  {
-  };
-
-  template <typename L, typename R>
-  struct return_type_plus<L, R, binary_operand_check_t<L, is_integral_t, R, is_numeric_not_unsigned_t>>
-  {
-    using check = consistent_t;
-    using type = plus_t<wrap_operand_t<L>, value_type_of_t<wrap_operand_t<R>>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_plus<L, R, binary_operand_check_t<L, is_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = plus_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_minus<L, R, binary_operand_check_t<L, is_integral_t, R, is_numeric_not_unsigned_t>>
-  {
-    using check = consistent_t;
-    using type = minus_t<wrap_operand_t<L>, value_type_of_t<wrap_operand_t<R>>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_minus<L, R, binary_operand_check_t<L, is_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = minus_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_multiplies<L, R, binary_operand_check_t<L, is_integral_t, R, is_numeric_not_unsigned_t>>
-  {
-    using check = consistent_t;
-    using type = multiplies_t<wrap_operand_t<L>, value_type_of_t<wrap_operand_t<R>>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_multiplies<L, R, binary_operand_check_t<L, is_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = multiplies_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_divides<L, R, binary_operand_check_t<L, is_integral_t, R, is_numeric_not_unsigned_t>>
-  {
-    using check = consistent_t;
-    using type = divides_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_divides<L, R, binary_operand_check_t<L, is_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = divides_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_modulus<L, R, binary_operand_check_t<L, is_integral_t, R, is_integral_t>>
-  {
-    using check = consistent_t;
-    using type = modulus_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename T, typename Defer>
-  struct return_type_unary_plus<T, Defer, unary_operand_check_t<T, is_integral_t>>
-  {
-    using check = consistent_t;
-    using type = unary_plus_t<integral, wrap_operand_t<T>>;
-  };
-
-  template <typename T, typename Defer>
-  struct return_type_unary_minus<T, Defer, unary_operand_check_t<T, is_integral_t>>
-  {
-    using check = consistent_t;
-    using type = unary_minus_t<integral, wrap_operand_t<T>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_bitwise_and<L, R, binary_operand_check_t<L, is_integral_t, R, is_integral_t>>
-  {
-    using check = consistent_t;
-    using type = bitwise_and_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_bitwise_or<L, R, binary_operand_check_t<L, is_integral_t, R, is_integral_t>>
-  {
-    using check = consistent_t;
-    using type = bitwise_or_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_shift_left<L, R, binary_operand_check_t<L, is_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = shift_left_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_shift_right<L, R, binary_operand_check_t<L, is_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = shift_right_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/integral/operand.h b/include/sqlpp11/data_types/integral/operand.h
deleted file mode 100644
index 232cd868..00000000
--- a/include/sqlpp11/data_types/integral/operand.h
+++ /dev/null
@@ -1,107 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/alias_operators.h>
-
-namespace sqlpp
-{
-  struct integral;
-
-  struct integral_operand : public alias_operators<integral_operand>
-  {
-    using _traits = make_traits<integral, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = int64_t;
-
-    integral_operand() : _t{}
-    {
-    }
-
-    integral_operand(_value_t t) : _t(t)
-    {
-    }
-
-    integral_operand(const integral_operand&) = default;
-    integral_operand(integral_operand&&) = default;
-    integral_operand& operator=(const integral_operand&) = default;
-    integral_operand& operator=(integral_operand&&) = default;
-    ~integral_operand() = default;
-
-    _value_t _t;
-  };
-
-  struct optional_integral_operand : public alias_operators<optional_integral_operand>
-  {
-    using _traits = make_traits<integral, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = sqlpp::compat::optional<int64_t>;
-    using _can_be_null = std::true_type;
-
-    optional_integral_operand() : _t{}
-    {
-    }
-
-    optional_integral_operand(_value_t t) : _t(t)
-    {
-    }
-
-    optional_integral_operand(const optional_integral_operand&) = default;
-    optional_integral_operand(optional_integral_operand&&) = default;
-    optional_integral_operand& operator=(const optional_integral_operand&) = default;
-    optional_integral_operand& operator=(optional_integral_operand&&) = default;
-    ~optional_integral_operand() = default;
-
-    _value_t _t;
-  };
-
-  template <typename Context>
-  Context& serialize(const integral_operand& t, Context& context)
-  {
-    context << t._t;
-    return context;
-  }
-
-  template <typename Context>
-  Context& serialize(const optional_integral_operand& t, Context& context)
-  {
-    if (t._t.has_value())
-    {
-      context << t._t.value();
-    }
-    else
-    {
-      context << "NULL";
-    }
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/integral/parameter_value.h b/include/sqlpp11/data_types/integral/parameter_value.h
deleted file mode 100644
index a1125b3e..00000000
--- a/include/sqlpp11/data_types/integral/parameter_value.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/data_types/parameter_value_base.h>
-#include <sqlpp11/data_types/integral/data_type.h>
-
-namespace sqlpp
-{
-  template <>
-  struct parameter_value_t<integral> : public parameter_value_base<integral>
-  {
-    using base = parameter_value_base<integral>;
-    using base::base;
-    using base::operator=;
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_integral_parameter(index, &_value, _is_null);
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/integral/wrap_operand.h b/include/sqlpp11/data_types/integral/wrap_operand.h
deleted file mode 100644
index e87e063f..00000000
--- a/include/sqlpp11/data_types/integral/wrap_operand.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2016, Roland Bock, Aaron Bishop
- * 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.
- */
-
-#include <utility>
-#include <sqlpp11/wrap_operand.h>
-
-namespace sqlpp
-{
-  struct integral_operand;
-  struct optional_integral_operand;
-
-  template <typename T>
-  struct wrap_operand<T,
-                      typename std::enable_if<std::is_integral<T>::value and not std::is_same<bool, T>::value and
-                                              not std::is_unsigned<T>::value>::type>
-  {
-    using type = integral_operand;
-  };
-
-  template <typename T>
-  struct wrap_operand<sqlpp::compat::optional<T>,
-                      typename std::enable_if<std::is_integral<T>::value and not std::is_same<bool, T>::value and
-                                              not std::is_unsigned<T>::value>::type>
-  {
-    using type = optional_integral_operand;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/no_value.h b/include/sqlpp11/data_types/no_value.h
deleted file mode 100644
index be2e9716..00000000
--- a/include/sqlpp11/data_types/no_value.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/no_value/data_type.h>
-#include <sqlpp11/data_types/no_value/operand.h>
-#include <sqlpp11/data_types/no_value/wrap_operand.h>
-#include <sqlpp11/data_types/no_value/expression_operators.h>
-#include <sqlpp11/data_types/no_value/column_operators.h>
-#include <sqlpp11/data_types/no_value/parameter_value.h>
diff --git a/include/sqlpp11/data_types/no_value/column_operators.h b/include/sqlpp11/data_types/no_value/column_operators.h
deleted file mode 100644
index 8af777fd..00000000
--- a/include/sqlpp11/data_types/no_value/column_operators.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  struct no_value_t;
-
-  template <typename Base>
-  struct column_operators<Base, no_value_t>
-  {
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/no_value/data_type.h b/include/sqlpp11/data_types/no_value/data_type.h
deleted file mode 100644
index 601f0442..00000000
--- a/include/sqlpp11/data_types/no_value/data_type.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-
-namespace sqlpp
-{
-  struct no_value_t
-  {
-    using _traits = make_traits<no_value_t>;
-    using _cpp_value_type = void;
-
-    template <typename T>
-    using _is_valid_operand = wrong_t<T>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/no_value/expression_operators.h b/include/sqlpp11/data_types/no_value/expression_operators.h
deleted file mode 100644
index 6e94dc40..00000000
--- a/include/sqlpp11/data_types/no_value/expression_operators.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/expression_return_types.h>
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-
-namespace sqlpp
-{
-  template <typename Expression>
-  struct expression_operators<Expression, no_value_t> : public basic_expression_operators<Expression>
-  {
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/no_value/operand.h b/include/sqlpp11/data_types/no_value/operand.h
deleted file mode 100644
index bb44b612..00000000
--- a/include/sqlpp11/data_types/no_value/operand.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
diff --git a/include/sqlpp11/data_types/no_value/parameter_value.h b/include/sqlpp11/data_types/no_value/parameter_value.h
deleted file mode 100644
index bb44b612..00000000
--- a/include/sqlpp11/data_types/no_value/parameter_value.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
diff --git a/include/sqlpp11/data_types/no_value/wrap_operand.h b/include/sqlpp11/data_types/no_value/wrap_operand.h
deleted file mode 100644
index bb44b612..00000000
--- a/include/sqlpp11/data_types/no_value/wrap_operand.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
diff --git a/include/sqlpp11/data_types/parameter_value.h b/include/sqlpp11/data_types/parameter_value.h
deleted file mode 100644
index e8d2f0e2..00000000
--- a/include/sqlpp11/data_types/parameter_value.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/wrong.h>
-
-namespace sqlpp
-{
-  template <typename ValueType>
-  struct parameter_value_t
-  {
-    static_assert(wrong_t<parameter_value_t>::value, "Missing parameter value type for ValueType");
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/parameter_value_base.h b/include/sqlpp11/data_types/parameter_value_base.h
deleted file mode 100644
index e7c64c57..00000000
--- a/include/sqlpp11/data_types/parameter_value_base.h
+++ /dev/null
@@ -1,91 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/value.h>
-
-namespace sqlpp
-{
-  template <typename DataType, typename StorageType = typename DataType::_cpp_value_type>
-  struct parameter_value_base
-  {
-    using _value_type = DataType;
-    using _cpp_value_type = typename _value_type::_cpp_value_type;
-    using _cpp_storage_type = StorageType;
-
-    parameter_value_base() : _value{}, _is_null{true}
-    {
-    }
-
-    explicit parameter_value_base(const _cpp_value_type& val) : _value(val), _is_null(false)
-    {
-    }
-
-    parameter_value_base& operator=(const _cpp_value_type& val)
-    {
-      _value = val;
-      _is_null = false;
-      return *this;
-    }
-
-    parameter_value_base& operator=(const value_t<DataType>& val)
-    {
-      if (val._is_null)
-      {
-        set_null();
-        return *this;
-      }
-      return operator=(val._value);
-    }
-
-    void set_null()
-    {
-      _value = {};
-      _is_null = true;
-    }
-
-    bool is_null() const
-    {
-      return _is_null;
-    }
-
-    const _cpp_value_type& value() const
-    {
-      return _value;
-    }
-
-    operator _cpp_value_type() const
-    {
-      return _value;
-    }
-
-  protected:
-    _cpp_storage_type _value;
-    bool _is_null;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/text.h b/include/sqlpp11/data_types/text.h
deleted file mode 100644
index e236ddd2..00000000
--- a/include/sqlpp11/data_types/text.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/text/data_type.h>
-#include <sqlpp11/data_types/text/operand.h>
-#include <sqlpp11/data_types/text/wrap_operand.h>
-#include <sqlpp11/data_types/text/expression_operators.h>
-#include <sqlpp11/data_types/text/column_operators.h>
-#include <sqlpp11/data_types/text/parameter_value.h>
-
-// text specific functions
-#include <sqlpp11/data_types/text/like.h>
-#include <sqlpp11/data_types/text/concat.h>
diff --git a/include/sqlpp11/data_types/text/column_operators.h b/include/sqlpp11/data_types/text/column_operators.h
deleted file mode 100644
index d6e29f9d..00000000
--- a/include/sqlpp11/data_types/text/column_operators.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/data_types/text/data_type.h>
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  template <typename... Args>
-  struct concat_t;
-
-  template <typename Column>
-  struct column_operators<Column, text>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<text, T>;
-
-    template <typename T>
-    auto operator+=(T t) const -> assignment_t<Column, concat_t<Column, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this),
-              concat_t<Column, wrap_operand_t<T>>{*static_cast<const Column*>(this), rhs{t}}};
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/text/concat.h b/include/sqlpp11/data_types/text/concat.h
deleted file mode 100644
index 4dc1b5f8..00000000
--- a/include/sqlpp11/data_types/text/concat.h
+++ /dev/null
@@ -1,94 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/char_sequence.h>
-#include <sqlpp11/interpret_tuple.h>
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/alias_operators.h>
-#include <sqlpp11/logic.h>
-#include <sqlpp11/wrap_operand.h>
-
-namespace sqlpp
-{
-  struct text;
-
-  struct concat_alias_t
-  {
-    struct _alias_t
-    {
-      static constexpr const char _literal[] = "concat_";
-      using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
-      template <typename T>
-      struct _member_t
-      {
-        T concat;
-      };
-    };
-  };
-
-  template <typename... Args>
-  struct concat_t : public expression_operators<concat_t<Args...>, text>, public alias_operators<concat_t<Args...>>
-  {
-    using _traits = make_traits<text, tag::is_expression, tag::is_selectable>;
-    using _nodes = detail::type_vector<Args...>;
-
-    using _auto_alias_t = concat_alias_t;
-
-    concat_t(Args... args) : _args(args...)
-    {
-    }
-
-    concat_t(const concat_t&) = default;
-    concat_t(concat_t&&) = default;
-    concat_t& operator=(const concat_t&) = default;
-    concat_t& operator=(concat_t&&) = default;
-    ~concat_t() = default;
-
-    std::tuple<Args...> _args;
-  };
-
-  template <typename Context, typename... Args>
-  Context& serialize(const concat_t<Args...>& t, Context& context)
-  {
-    context << "(";
-    interpret_tuple(t._args, "||", context);
-    context << ")";
-    return context;
-  }
-
-  template <typename... Args>
-  auto concat(Args... args) -> concat_t<Args...>
-  {
-    static_assert(sizeof...(Args) >= 2, "concat requires two arguments at least");
-    static_assert(logic::all_t<is_text_t<wrap_operand_t<Args>>::value...>::value,
-                  "at least one non-text argument detected in concat()");
-
-    return {args...};
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/text/data_type.h b/include/sqlpp11/data_types/text/data_type.h
deleted file mode 100644
index 8a19f9da..00000000
--- a/include/sqlpp11/data_types/text/data_type.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-
-#include <string>
-
-#include <sqlpp11/compat/string_view.h>
-
-namespace sqlpp
-{
-  struct text
-  {
-    using _traits = make_traits<text, tag::is_value_type>;
-    using _cpp_value_type = std::string;
-    using _result_type = sqlpp::compat::string_view;
-
-    template <typename T>
-    using _is_valid_operand = is_text_t<T>;
-  };
-
-  using varchar = text;
-  using char_ = text;
-  using binary = text;
-  using varbinary = text;
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/text/expression_operators.h b/include/sqlpp11/data_types/text/expression_operators.h
deleted file mode 100644
index 88d3bba8..00000000
--- a/include/sqlpp11/data_types/text/expression_operators.h
+++ /dev/null
@@ -1,63 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/data_types/text/data_type.h>
-#include <sqlpp11/data_types/text/return_type_like.h>
-
-namespace sqlpp
-{
-  template <typename... Args>
-  struct concat_t;
-
-  template <typename Operand, typename Pattern>
-  struct like_t;
-
-  template <typename L, typename R>
-  struct return_type_like<L, R, binary_operand_check_t<L, is_text_t, R, is_text_t>>
-  {
-    using check = consistent_t;
-    using type = like_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename Expression>
-  struct expression_operators<Expression, text> : public basic_expression_operators<Expression>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<text, T>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_plus<L, R, binary_operand_check_t<L, is_text_t, R, is_text_t>>
-  {
-    using check = consistent_t;
-    using type = concat_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/text/like.h b/include/sqlpp11/data_types/text/like.h
deleted file mode 100644
index e957c2b6..00000000
--- a/include/sqlpp11/data_types/text/like.h
+++ /dev/null
@@ -1,89 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/alias_operators.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/char_sequence.h>
-
-namespace sqlpp
-{
-  struct boolean;
-
-  template <typename Operand, typename Pattern>
-  struct like_t : public expression_operators<like_t<Operand, Pattern>, boolean>,
-                  public alias_operators<like_t<Operand, Pattern>>
-  {
-    using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-    using _nodes = detail::type_vector<Operand, Pattern>;
-
-    struct _alias_t
-    {
-      // workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2100550
-      //      static constexpr const char _literal[] = "like_";
-      static constexpr const char _literal[6] = "like_";
-      using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
-      template <typename T>
-      struct _member_t
-      {
-        T like;
-        T& operator()()
-        {
-          return like;
-        }
-        const T& operator()() const
-        {
-          return like;
-        }
-      };
-    };
-
-    like_t(Operand operand, Pattern pattern) : _operand(operand), _pattern(pattern)
-    {
-    }
-
-    like_t(const like_t&) = default;
-    like_t(like_t&&) = default;
-    like_t& operator=(const like_t&) = default;
-    like_t& operator=(like_t&&) = default;
-    ~like_t() = default;
-
-    Operand _operand;
-    Pattern _pattern;
-  };
-
-  template <typename Context, typename Operand, typename Pattern>
-  Context& serialize(const like_t<Operand, Pattern>& t, Context& context)
-  {
-    serialize_operand(t._operand, context);
-    context << " LIKE(";
-    serialize(t._pattern, context);
-    context << ")";
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/text/operand.h b/include/sqlpp11/data_types/text/operand.h
deleted file mode 100644
index c2f49926..00000000
--- a/include/sqlpp11/data_types/text/operand.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <string>
-#include <utility>
-#include <sqlpp11/compat/string_view.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/alias_operators.h>
-
-namespace sqlpp
-{
-  struct text;
-
-  struct text_operand : public alias_operators<text_operand>
-  {
-    using _traits = make_traits<text, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = std::string;
-
-    text_operand() = default;
-
-    text_operand(_value_t t) : _t(std::move(t))
-    {
-    }
-    // allow construction from an sqlpp::compat::string_view
-    text_operand(sqlpp::compat::string_view t) : _t(t)
-    {
-    }
-    // additional const char* overload, required to disambiguate
-    text_operand(const char* t) : _t(t)
-    {
-    }
-
-    text_operand(const text_operand&) = default;
-    text_operand(text_operand&&) = default;
-    text_operand& operator=(const text_operand&) = default;
-    text_operand& operator=(text_operand&&) = default;
-    ~text_operand() = default;
-
-    _value_t _t;
-  };
-
-  template <typename Context>
-  Context& serialize(const text_operand& t, Context& context)
-  {
-    context << '\'' << context.escape(t._t) << '\'';
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/text/parameter_value.h b/include/sqlpp11/data_types/text/parameter_value.h
deleted file mode 100644
index 23da1693..00000000
--- a/include/sqlpp11/data_types/text/parameter_value.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/data_types/parameter_value_base.h>
-#include <sqlpp11/data_types/text/data_type.h>
-#include <sqlpp11/data_types/text/wrap_operand.h>
-#include <sqlpp11/data_types/text/operand.h>
-
-#include <sqlpp11/compat/string_view.h>
-
-namespace sqlpp
-{
-  template <>
-  struct parameter_value_t<text> : public parameter_value_base<text>
-  {
-    using base = parameter_value_base<text>;
-    using base::base;
-    using base::operator=;
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_text_parameter(index, &_value, _is_null);
-    }
-
-    parameter_value_base& operator=(const sqlpp::compat::string_view& val)
-    {
-      _value = val;
-      _is_null = false;
-      return *this;
-    }
-
-    parameter_value_base& operator=(const char* val)
-    {
-      _value = val;
-      _is_null = false;
-      return *this;
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/text/return_type_like.h b/include/sqlpp11/data_types/text/return_type_like.h
deleted file mode 100644
index dab76a70..00000000
--- a/include/sqlpp11/data_types/text/return_type_like.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2017, 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.
- */
-
-#include <sqlpp11/bad_expression.h>
-
-namespace sqlpp
-{
-  template <typename T, typename Defer, typename Enable = void>
-  struct return_type_like
-  {
-    using check = assert_valid_operands;
-    using type = bad_expression<boolean>;
-  };
-  template <typename T, typename Defer>
-  using return_type_like_t = typename return_type_like<T, Defer>::type;
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/text/wrap_operand.h b/include/sqlpp11/data_types/text/wrap_operand.h
deleted file mode 100644
index 17ccff47..00000000
--- a/include/sqlpp11/data_types/text/wrap_operand.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <utility>
-#include <sqlpp11/compat/string_view.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/wrap_operand.h>
-
-namespace sqlpp
-{
-  struct text_operand;
-  using checked_type = sqlpp::compat::string_view;
-
-  template <typename T>
-  struct wrap_operand<
-      T,
-      typename std::enable_if<std::is_convertible<T, checked_type>::value and not is_result_field_t<T>::value>::type>
-  {
-    using type = text_operand;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_of_day.h b/include/sqlpp11/data_types/time_of_day.h
deleted file mode 100644
index a4d46f56..00000000
--- a/include/sqlpp11/data_types/time_of_day.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/data_types/time_of_day/data_type.h>
-#include <sqlpp11/data_types/time_of_day/operand.h>
-#include <sqlpp11/data_types/time_of_day/wrap_operand.h>
-#include <sqlpp11/data_types/time_of_day/expression_operators.h>
-#include <sqlpp11/data_types/time_of_day/column_operators.h>
-#include <sqlpp11/data_types/time_of_day/parameter_value.h>
diff --git a/include/sqlpp11/data_types/time_of_day/column_operators.h b/include/sqlpp11/data_types/time_of_day/column_operators.h
deleted file mode 100644
index 22197ed4..00000000
--- a/include/sqlpp11/data_types/time_of_day/column_operators.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/data_types/time_of_day/data_type.h>
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  template <typename Column>
-  struct column_operators<Column, time_of_day>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<time_of_day, T>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_of_day/data_type.h b/include/sqlpp11/data_types/time_of_day/data_type.h
deleted file mode 100644
index 1b4c8eaa..00000000
--- a/include/sqlpp11/data_types/time_of_day/data_type.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/chrono.h>
-#include <sqlpp11/type_traits.h>
-
-namespace sqlpp
-{
-  struct time_of_day
-  {
-    using _traits = make_traits<time_of_day, tag::is_value_type>;
-    using _cpp_value_type = std::chrono::microseconds;
-    using _result_type = std::chrono::microseconds;
-
-    template <typename T>
-    using _is_valid_operand = is_time_of_day_t<T>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_of_day/expression_operators.h b/include/sqlpp11/data_types/time_of_day/expression_operators.h
deleted file mode 100644
index d596d4b6..00000000
--- a/include/sqlpp11/data_types/time_of_day/expression_operators.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/data_types/time_of_day/data_type.h>
-
-namespace sqlpp
-{
-  // time_of_day expression operators
-  template <typename Expression>
-  struct expression_operators<Expression, time_of_day> : public basic_expression_operators<Expression>
-  {
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_of_day/operand.h b/include/sqlpp11/data_types/time_of_day/operand.h
deleted file mode 100644
index d4926884..00000000
--- a/include/sqlpp11/data_types/time_of_day/operand.h
+++ /dev/null
@@ -1,69 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/chrono.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/alias_operators.h>
-
-namespace sqlpp
-{
-  struct time_of_day;
-
-  template <typename Period>
-  struct time_of_day_operand : public alias_operators<time_of_day_operand<Period>>
-  {
-    using _traits = make_traits<time_of_day, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = std::chrono::microseconds;
-
-    time_of_day_operand() : _t{}
-    {
-    }
-
-    time_of_day_operand(_value_t t) : _t(t)
-    {
-    }
-
-    time_of_day_operand(const time_of_day_operand&) = default;
-    time_of_day_operand(time_of_day_operand&&) = default;
-    time_of_day_operand& operator=(const time_of_day_operand&) = default;
-    time_of_day_operand& operator=(time_of_day_operand&&) = default;
-    ~time_of_day_operand() = default;
-
-    _value_t _t;
-  };
-
-  template <typename Context, typename Period>
-  Context& serialize(const time_of_day_operand<Period>& t, Context& context)
-  {
-    context << '\'' << ::date::make_time(t._t) << '\'';
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_of_day/parameter_value.h b/include/sqlpp11/data_types/time_of_day/parameter_value.h
deleted file mode 100644
index 8a685750..00000000
--- a/include/sqlpp11/data_types/time_of_day/parameter_value.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/data_types/parameter_value_base.h>
-#include <sqlpp11/data_types/time_of_day/data_type.h>
-#include <sqlpp11/data_types/time_point/wrap_operand.h>
-#include <sqlpp11/data_types/time_point/operand.h>
-
-namespace sqlpp
-{
-  template <>
-  struct parameter_value_t<time_of_day> : public parameter_value_base<time_of_day>
-  {
-    using base = parameter_value_base<time_of_day>;
-    using base::base;
-    using base::operator=;
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_time_of_day_parameter(index, &_value, _is_null);
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_of_day/wrap_operand.h b/include/sqlpp11/data_types/time_of_day/wrap_operand.h
deleted file mode 100644
index 9341f9a8..00000000
--- a/include/sqlpp11/data_types/time_of_day/wrap_operand.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/wrap_operand.h>
-#include <sqlpp11/data_types/time_of_day/operand.h>
-
-namespace sqlpp
-{
-  template <typename Rep, typename Period>
-  struct wrap_operand<std::chrono::duration<Rep, Period>, void>
-  {
-    using type = time_of_day_operand<std::chrono::duration<Rep, Period>>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_point.h b/include/sqlpp11/data_types/time_point.h
deleted file mode 100644
index 7bb8b3e3..00000000
--- a/include/sqlpp11/data_types/time_point.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/data_types/time_point/data_type.h>
-#include <sqlpp11/data_types/time_point/operand.h>
-#include <sqlpp11/data_types/time_point/wrap_operand.h>
-#include <sqlpp11/data_types/time_point/expression_operators.h>
-#include <sqlpp11/data_types/time_point/column_operators.h>
-#include <sqlpp11/data_types/time_point/parameter_value.h>
diff --git a/include/sqlpp11/data_types/time_point/column_operators.h b/include/sqlpp11/data_types/time_point/column_operators.h
deleted file mode 100644
index 4bc7c042..00000000
--- a/include/sqlpp11/data_types/time_point/column_operators.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/data_types/time_point/data_type.h>
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  template <typename Column>
-  struct column_operators<Column, time_point>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<time_point, T>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_point/data_type.h b/include/sqlpp11/data_types/time_point/data_type.h
deleted file mode 100644
index f8187391..00000000
--- a/include/sqlpp11/data_types/time_point/data_type.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/chrono.h>
-#include <sqlpp11/type_traits.h>
-
-namespace sqlpp
-{
-  struct time_point
-  {
-    using _traits = make_traits<time_point, tag::is_value_type>;
-    using _cpp_value_type = ::sqlpp::chrono::microsecond_point;
-    using _result_type = ::sqlpp::chrono::microsecond_point;
-
-    template <typename T>
-    using _is_valid_operand = is_day_or_time_point_t<T>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_point/expression_operators.h b/include/sqlpp11/data_types/time_point/expression_operators.h
deleted file mode 100644
index e82c59ac..00000000
--- a/include/sqlpp11/data_types/time_point/expression_operators.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/data_types/time_point/data_type.h>
-
-namespace sqlpp
-{
-  // time_point expression operators
-  template <typename Expression>
-  struct expression_operators<Expression, time_point> : public basic_expression_operators<Expression>
-  {
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_point/operand.h b/include/sqlpp11/data_types/time_point/operand.h
deleted file mode 100644
index e8a2e033..00000000
--- a/include/sqlpp11/data_types/time_point/operand.h
+++ /dev/null
@@ -1,72 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/chrono.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/alias_operators.h>
-
-namespace sqlpp
-{
-  struct time_point;
-
-  template <typename Period>
-  struct time_point_operand : public alias_operators<time_point_operand<Period>>
-  {
-    using _traits = make_traits<time_point, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = std::chrono::time_point<std::chrono::system_clock, Period>;
-
-    time_point_operand() : _t{}
-    {
-    }
-
-    time_point_operand(_value_t t) : _t(t)
-    {
-    }
-
-    time_point_operand(const time_point_operand&) = default;
-    time_point_operand(time_point_operand&&) = default;
-    time_point_operand& operator=(const time_point_operand&) = default;
-    time_point_operand& operator=(time_point_operand&&) = default;
-    ~time_point_operand() = default;
-
-    _value_t _t;
-  };
-
-  template <typename Context, typename Period>
-  Context& serialize(const time_point_operand<Period>& t, Context& context)
-  {
-    const auto dp = ::sqlpp::chrono::floor<::date::days>(t._t);
-    const auto time = ::date::make_time(t._t - dp);
-    const auto ymd = ::date::year_month_day{dp};
-    context << "TIMESTAMP '" << ymd << ' ' << time << "'";
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_point/parameter_value.h b/include/sqlpp11/data_types/time_point/parameter_value.h
deleted file mode 100644
index f68cd610..00000000
--- a/include/sqlpp11/data_types/time_point/parameter_value.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/data_types/parameter_value_base.h>
-#include <sqlpp11/data_types/time_point/data_type.h>
-#include <sqlpp11/data_types/time_point/wrap_operand.h>
-#include <sqlpp11/data_types/time_point/operand.h>
-
-namespace sqlpp
-{
-  template <>
-  struct parameter_value_t<time_point> : public parameter_value_base<time_point>
-  {
-    using base = parameter_value_base<time_point>;
-    using base::base;
-    using base::operator=;
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_date_time_parameter(index, &_value, _is_null);
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/time_point/wrap_operand.h b/include/sqlpp11/data_types/time_point/wrap_operand.h
deleted file mode 100644
index 482be771..00000000
--- a/include/sqlpp11/data_types/time_point/wrap_operand.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2015-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.
- */
-
-#include <sqlpp11/wrap_operand.h>
-#include <sqlpp11/data_types/time_point/operand.h>
-
-namespace sqlpp
-{
-  template <typename Period>
-  struct wrap_operand<std::chrono::time_point<std::chrono::system_clock, Period>, void>
-  {
-    using type = time_point_operand<Period>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/unsigned_integral.h b/include/sqlpp11/data_types/unsigned_integral.h
deleted file mode 100644
index 38f00402..00000000
--- a/include/sqlpp11/data_types/unsigned_integral.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2016, Roland Bock, Aaron Bishop
- * 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.
- */
-
-#include <sqlpp11/data_types/unsigned_integral/data_type.h>
-#include <sqlpp11/data_types/unsigned_integral/operand.h>
-#include <sqlpp11/data_types/unsigned_integral/wrap_operand.h>
-#include <sqlpp11/data_types/unsigned_integral/expression_operators.h>
-#include <sqlpp11/data_types/unsigned_integral/column_operators.h>
-#include <sqlpp11/data_types/unsigned_integral/parameter_value.h>
diff --git a/include/sqlpp11/data_types/unsigned_integral/column_operators.h b/include/sqlpp11/data_types/unsigned_integral/column_operators.h
deleted file mode 100644
index 1abb05be..00000000
--- a/include/sqlpp11/data_types/unsigned_integral/column_operators.h
+++ /dev/null
@@ -1,79 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/value_type.h>
-#include <sqlpp11/data_types/unsigned_integral/data_type.h>
-#include <sqlpp11/data_types/column_operators.h>
-
-namespace sqlpp
-{
-  template <typename Column>
-  struct column_operators<Column, unsigned_integral>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<unsigned_integral, T>;
-
-    template <typename T>
-    auto operator+=(T t) const -> assignment_t<Column, plus_t<Column, value_type_t<T>, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}};
-    }
-
-    template <typename T>
-    auto operator-=(T t) const -> assignment_t<Column, minus_t<Column, value_type_t<T>, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}};
-    }
-
-    template <typename T>
-    auto operator/=(T t) const -> assignment_t<Column, divides_t<Column, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}};
-    }
-
-    template <typename T>
-    auto operator*=(T t) const -> assignment_t<Column, multiplies_t<Column, value_type_t<T>, wrap_operand_t<T>>>
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
-
-      return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}};
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/unsigned_integral/data_type.h b/include/sqlpp11/data_types/unsigned_integral/data_type.h
deleted file mode 100644
index 5820a78e..00000000
--- a/include/sqlpp11/data_types/unsigned_integral/data_type.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2016, Roland Bock, Aaron Bishop
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-
-namespace sqlpp
-{
-  struct unsigned_integral
-  {
-    using _traits = make_traits<unsigned_integral, tag::is_value_type>;
-    using _cpp_value_type = uint64_t;
-    using _result_type = uint64_t;
-
-    template <typename T>
-    using _is_valid_operand = is_numeric_t<T>;
-  };
-
-  using tinyint_unsigned = unsigned_integral;
-  using smallint_unsigned = unsigned_integral;
-  using integer_unsigned = unsigned_integral;
-  using bigint_unsigned = unsigned_integral;
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/unsigned_integral/expression_operators.h b/include/sqlpp11/data_types/unsigned_integral/expression_operators.h
deleted file mode 100644
index bf99c570..00000000
--- a/include/sqlpp11/data_types/unsigned_integral/expression_operators.h
+++ /dev/null
@@ -1,129 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2016, Roland Bock, Aaron Bishop
- * 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.
- */
-
-#include <sqlpp11/expression_return_types.h>
-#include <sqlpp11/operand_check.h>
-#include <sqlpp11/expression_operators.h>
-#include <sqlpp11/basic_expression_operators.h>
-#include <sqlpp11/value_type.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/data_types/unsigned_integral/data_type.h>
-
-namespace sqlpp
-{
-  struct integral;
-
-  template <typename Expression>
-  struct expression_operators<Expression, unsigned_integral> : public basic_expression_operators<Expression>
-  {
-  };
-
-  template <typename L, typename R>
-  struct return_type_plus<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_numeric_t>>
-  {
-    using check = consistent_t;
-    using type = plus_t<wrap_operand_t<L>, value_type_of_t<wrap_operand_t<R>>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_minus<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_numeric_not_unsigned_t>>
-  {
-    using check = consistent_t;
-    using type = minus_t<wrap_operand_t<L>, value_type_of_t<wrap_operand_t<R>>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_minus<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = minus_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_multiplies<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_numeric_t>>
-  {
-    using check = consistent_t;
-    using type = multiplies_t<wrap_operand_t<L>, value_type_of_t<wrap_operand_t<R>>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_divides<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_numeric_t>>
-  {
-    using check = consistent_t;
-    using type = divides_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_modulus<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = modulus_t<wrap_operand_t<L>, wrap_operand_t<R>>;
-  };
-
-  template <typename T, typename Defer>
-  struct return_type_unary_plus<T, Defer, unary_operand_check_t<T, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = unary_plus_t<unsigned_integral, wrap_operand_t<T>>;
-  };
-
-  template <typename T, typename Defer>
-  struct return_type_unary_minus<T, Defer, unary_operand_check_t<T, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = unary_minus_t<integral, wrap_operand_t<T>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_bitwise_and<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = bitwise_and_t<wrap_operand_t<L>, unsigned_integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_bitwise_or<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = bitwise_or_t<wrap_operand_t<L>, unsigned_integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_shift_left<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = shift_left_t<wrap_operand_t<L>, unsigned_integral, wrap_operand_t<R>>;
-  };
-
-  template <typename L, typename R>
-  struct return_type_shift_right<L, R, binary_operand_check_t<L, is_unsigned_integral_t, R, is_unsigned_integral_t>>
-  {
-    using check = consistent_t;
-    using type = shift_right_t<wrap_operand_t<L>, unsigned_integral, wrap_operand_t<R>>;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/unsigned_integral/operand.h b/include/sqlpp11/data_types/unsigned_integral/operand.h
deleted file mode 100644
index 1a917bbc..00000000
--- a/include/sqlpp11/data_types/unsigned_integral/operand.h
+++ /dev/null
@@ -1,67 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2016, Roland Bock, Aaron Bishop
- * 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.
- */
-
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/alias_operators.h>
-
-namespace sqlpp
-{
-  struct unsigned_integral;
-
-  struct unsigned_integral_operand : public alias_operators<unsigned_integral_operand>
-  {
-    using _traits = make_traits<unsigned_integral, tag::is_expression, tag::is_wrapped_value>;
-    using _nodes = detail::type_vector<>;
-    using _is_literal_expression = std::true_type;
-
-    using _value_t = uint64_t;
-
-    unsigned_integral_operand() : _t{}
-    {
-    }
-
-    unsigned_integral_operand(_value_t t) : _t(t)
-    {
-    }
-
-    unsigned_integral_operand(const unsigned_integral_operand&) = default;
-    unsigned_integral_operand(unsigned_integral_operand&&) = default;
-    unsigned_integral_operand& operator=(const unsigned_integral_operand&) = default;
-    unsigned_integral_operand& operator=(unsigned_integral_operand&&) = default;
-    ~unsigned_integral_operand() = default;
-
-    _value_t _t;
-  };
-
-  template <typename Context>
-  Context& serialize(const unsigned_integral_operand& t, Context& context)
-  {
-    context << t._t;
-    return context;
-  }
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/unsigned_integral/parameter_value.h b/include/sqlpp11/data_types/unsigned_integral/parameter_value.h
deleted file mode 100644
index 417b8d96..00000000
--- a/include/sqlpp11/data_types/unsigned_integral/parameter_value.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2016, Roland Bock, Aaron Bishop
- * 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.
- */
-
-#include <sqlpp11/data_types/parameter_value.h>
-#include <sqlpp11/data_types/parameter_value_base.h>
-#include <sqlpp11/data_types/unsigned_integral/data_type.h>
-
-namespace sqlpp
-{
-  template <>
-  struct parameter_value_t<unsigned_integral> : public parameter_value_base<unsigned_integral>
-  {
-    using base = parameter_value_base<unsigned_integral>;
-    using base::base;
-    using base::operator=;
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_unsigned_integral_parameter(index, &_value, _is_null);
-    }
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/data_types/unsigned_integral/wrap_operand.h b/include/sqlpp11/data_types/unsigned_integral/wrap_operand.h
deleted file mode 100644
index 4c20ce09..00000000
--- a/include/sqlpp11/data_types/unsigned_integral/wrap_operand.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-/*
- * Copyright (c) 2013-2016, Roland Bock, Aaron Bishop
- * 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.
- */
-
-#include <utility>
-#include <sqlpp11/wrap_operand.h>
-
-namespace sqlpp
-{
-  struct unsigned_integral_operand;
-
-  template <typename T>
-  struct wrap_operand<T,
-                      typename std::enable_if<std::is_integral<T>::value and not std::is_same<bool, T>::value and
-                                              std::is_unsigned<T>::value>::type>
-  {
-    using type = unsigned_integral_operand;
-  };
-}  // namespace sqlpp
diff --git a/include/sqlpp11/default_value.h b/include/sqlpp11/default_value.h
index 1f0bf70e..98a6c4a0 100644
--- a/include/sqlpp11/default_value.h
+++ b/include/sqlpp11/default_value.h
@@ -26,7 +26,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/functions.h b/include/sqlpp11/functions.h
index 1bb1277d..a50d9f4e 100644
--- a/include/sqlpp11/functions.h
+++ b/include/sqlpp11/functions.h
@@ -29,7 +29,6 @@
 #include <sqlpp11/noop.h>
 #include <sqlpp11/parameter.h>
 #include <sqlpp11/parameter_list.h>
-#include <sqlpp11/data_types.h>
 #include <sqlpp11/aggregate_functions.h>
 #include <sqlpp11/trim.h>
 #include <sqlpp11/case.h>
diff --git a/include/sqlpp11/insert_value.h b/include/sqlpp11/insert_value.h
index 3e5da228..3b10d57f 100644
--- a/include/sqlpp11/insert_value.h
+++ b/include/sqlpp11/insert_value.h
@@ -27,7 +27,6 @@
  */
 
 #include <sqlpp11/default_value.h>
-#include <sqlpp11/null.h>
 #include <sqlpp11/value.h>
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/detail/type_set.h>
@@ -66,11 +65,6 @@ namespace sqlpp
     {
     }
 
-    insert_value_t(const null_t& /*unused*/)
-        : _is_null(true), _is_default(false), _value{}
-    {
-    }
-
     insert_value_t(const default_value_t& /*unused*/)
         : _is_null(false), _is_default(true), _value{}
     {
diff --git a/include/sqlpp11/insert_value_list.h b/include/sqlpp11/insert_value_list.h
index 9f103865..7237ec4c 100644
--- a/include/sqlpp11/insert_value_list.h
+++ b/include/sqlpp11/insert_value_list.h
@@ -26,7 +26,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sqlpp11/assignment.h>
+#include <sqlpp11/operator/assign_expression.h>
 #include <sqlpp11/column_fwd.h>
 #include <sqlpp11/expression_fwd.h>
 #include <sqlpp11/insert_value.h>
diff --git a/include/sqlpp11/into.h b/include/sqlpp11/into.h
index f256a9b8..51aeb283 100644
--- a/include/sqlpp11/into.h
+++ b/include/sqlpp11/into.h
@@ -26,7 +26,6 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/no_data.h>
 #include <sqlpp11/prepared_insert.h>
diff --git a/include/sqlpp11/noop.h b/include/sqlpp11/noop.h
index db04e547..57f2a7aa 100644
--- a/include/sqlpp11/noop.h
+++ b/include/sqlpp11/noop.h
@@ -27,7 +27,6 @@
  */
 
 #include <type_traits>
-#include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/prepared_execute.h>
 
 namespace sqlpp
diff --git a/include/sqlpp11/null.h b/include/sqlpp11/null.h
deleted file mode 100644
index 3ca4d7d0..00000000
--- a/include/sqlpp11/null.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/data_types/no_value.h>
-
-namespace sqlpp
-{
-  struct null_t
-  {
-    using _traits = make_traits<no_value_t, tag::is_expression, tag::is_sql_null>;
-    using _nodes = detail::type_vector<>;
-  };
-
-  template <typename Context>
-  Context& serialize(const null_t&, Context& context)
-  {
-    context << "NULL";
-    return context;
-  }
-
-  constexpr null_t null = {};
-}  // namespace sqlpp
diff --git a/include/sqlpp11/operand_check.h b/include/sqlpp11/operand_check.h
deleted file mode 100644
index 5c441400..00000000
--- a/include/sqlpp11/operand_check.h
+++ /dev/null
@@ -1,72 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-#include <sqlpp11/wrap_operand.h>
-#include <sqlpp11/detail/enable_if.h>
-
-namespace sqlpp
-{
-  template <typename T, template <typename> class Pred, typename Enable = void>
-  struct unary_operand_check
-  {
-  };
-
-  template <typename T, template <typename> class Pred>
-  struct unary_operand_check<T, Pred, detail::enable_if_t<Pred<T>::value>>
-  {
-    using type = void;
-  };
-
-  template <typename T, template <typename> class Pred>
-  using unary_operand_check_t = typename unary_operand_check<wrap_operand_t<T>, Pred>::type;
-
-  template <typename T, template <typename> class Pred>
-  using unwrapped_unary_operand_check_t = typename unary_operand_check<T, Pred>::type;
-
-  template <typename L,
-            template <typename> class LPred,
-            typename R,
-            template <typename> class RPred,
-            typename Enable = void>
-  struct binary_operand_check
-  {
-  };
-
-  template <typename L, template <typename> class LPred, typename R, template <typename> class RPred>
-  struct binary_operand_check<L, LPred, R, RPred, detail::enable_if_t<LPred<L>::value and RPred<R>::value>>
-  {
-    using type = void;
-  };
-
-  template <typename L, template <typename> class LPred, typename R, template <typename> class RPred>
-  using binary_operand_check_t =
-      typename binary_operand_check<wrap_operand_t<L>, LPred, wrap_operand_t<R>, RPred>::type;
-
-  template <typename L, template <typename> class LPred, typename R, template <typename> class RPred>
-  using unwrapped_binary_operand_check_t = typename binary_operand_check<L, LPred, R, RPred>::type;
-}  // namespace sqlpp
diff --git a/include/sqlpp11/operator/arithmetic_expression.h b/include/sqlpp11/operator/arithmetic_expression.h
index 159a6881..11a63fcf 100644
--- a/include/sqlpp11/operator/arithmetic_expression.h
+++ b/include/sqlpp11/operator/arithmetic_expression.h
@@ -32,6 +32,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace sqlpp
 {
+#warning: We need to put concat somewhere (text and blob)
   template <typename L, typename Operator, typename R>
   struct arithmetic_expression
   {
diff --git a/include/sqlpp11/over.h b/include/sqlpp11/over.h
index d42a4586..a4485278 100644
--- a/include/sqlpp11/over.h
+++ b/include/sqlpp11/over.h
@@ -31,8 +31,8 @@
 namespace sqlpp
 {
   template <typename AggregateExpr>
-  struct over_t : public expression_operators<over_t<AggregateExpr>, integral>,
-                  public alias_operators<over_t<AggregateExpr>>
+  struct over_t /*: public expression_operators<over_t<AggregateExpr>, integral>,
+                  public alias_operators<over_t<AggregateExpr>>*/
   {
     using _traits = make_traits<integral, tag::is_expression>;
     using _nodes = detail::type_vector<AggregateExpr, aggregate_function>;
diff --git a/include/sqlpp11/parameter.h b/include/sqlpp11/parameter.h
index 00b16408..8e6f1734 100644
--- a/include/sqlpp11/parameter.h
+++ b/include/sqlpp11/parameter.h
@@ -28,10 +28,8 @@
 
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/alias_provider.h>
-#include <sqlpp11/data_types/parameter_value.h>
 #include <sqlpp11/expression_operators.h>
 #include <sqlpp11/detail/type_set.h>
-#include <sqlpp11/wrap_operand.h>
 
 namespace sqlpp
 {
@@ -72,7 +70,7 @@ namespace sqlpp
 
   template <typename ValueType, typename AliasProvider>
   auto parameter(const ValueType& /*unused*/, const AliasProvider & /*unused*/)
-      -> parameter_t<wrap_operand_t<ValueType>, AliasProvider>
+      -> parameter_t<ValueType, AliasProvider>
   {
     static_assert(is_value_type_t<ValueType>::value, "first argument is not a value type");
     static_assert(is_alias_provider_t<AliasProvider>::value, "second argument is not an alias provider");
diff --git a/include/sqlpp11/parameterized_verbatim.h b/include/sqlpp11/parameterized_verbatim.h
index 456fb6b3..622ad557 100644
--- a/include/sqlpp11/parameterized_verbatim.h
+++ b/include/sqlpp11/parameterized_verbatim.h
@@ -26,17 +26,16 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sqlpp11/data_types/no_value.h>
+#include <utility>
+
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/serialize.h>
 
-#include <utility>
-
 namespace sqlpp
 {
   template <typename ValueType, typename Expr>
-  struct parameterized_verbatim_t : public expression_operators<verbatim_t<ValueType>, ValueType>,
-                                    public alias_operators<verbatim_t<ValueType>>
+  struct parameterized_verbatim_t /*: public expression_operators<verbatim_t<ValueType>, ValueType>,
+                                    public alias_operators<verbatim_t<ValueType>>*/
   {
     using _traits = make_traits<ValueType, tag::is_expression>;
     using _nodes = detail::type_vector<Expr>;
@@ -68,9 +67,9 @@ namespace sqlpp
 
   template <typename ValueType, typename Expr>
   auto parameterized_verbatim(std::string lhs, Expr expr, std::string rhs)
-    -> parameterized_verbatim_t<ValueType, wrap_operand_t<Expr>>
+    -> parameterized_verbatim_t<ValueType, Expr>
   {
-    static_assert(is_expression_t<wrap_operand_t<Expr>>::value, "parameterized_verbatim() requires an expression as argument");
+    static_assert(is_expression_t<Expr>::value, "parameterized_verbatim() requires an expression as argument");
     return {expr, lhs, rhs};
   }
 
diff --git a/include/sqlpp11/postgresql/bind_result.h b/include/sqlpp11/postgresql/bind_result.h
index 51328ac8..6079f4a4 100644
--- a/include/sqlpp11/postgresql/bind_result.h
+++ b/include/sqlpp11/postgresql/bind_result.h
@@ -28,7 +28,6 @@
  */
 
 #include <sqlpp11/chrono.h>
-#include <sqlpp11/data_types.h>
 #include <sqlpp11/detail/parse_date_time.h>
 #include <sqlpp11/compat/optional.h>
 #include <sqlpp11/compat/string_view.h>
diff --git a/include/sqlpp11/postgresql/returning_column_list.h b/include/sqlpp11/postgresql/returning_column_list.h
index f0d8bcf5..7bc7feca 100644
--- a/include/sqlpp11/postgresql/returning_column_list.h
+++ b/include/sqlpp11/postgresql/returning_column_list.h
@@ -33,7 +33,6 @@
 #include <sqlpp11/expression_fwd.h>
 #include <sqlpp11/field_spec.h>
 #include <sqlpp11/interpret_tuple.h>
-#include <sqlpp11/operand_check.h>
 #include <sqlpp11/policy_update.h>
 #include <sqlpp11/result_row.h>
 #include <sqlpp11/select_pseudo_table.h>
diff --git a/include/sqlpp11/postgresql/serializer.h b/include/sqlpp11/postgresql/serializer.h
index 3ad5e32d..1c3ad837 100644
--- a/include/sqlpp11/postgresql/serializer.h
+++ b/include/sqlpp11/postgresql/serializer.h
@@ -29,7 +29,6 @@
 
 #include <sqlpp11/chrono.h>
 #include <sqlpp11/parameter.h>
-#include <sqlpp11/wrap_operand.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/prepared_execute.h b/include/sqlpp11/prepared_execute.h
index fadd1a6e..b3745a65 100644
--- a/include/sqlpp11/prepared_execute.h
+++ b/include/sqlpp11/prepared_execute.h
@@ -28,7 +28,7 @@
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
-#include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/prepared_insert.h b/include/sqlpp11/prepared_insert.h
index 7c95f39a..dc5949be 100644
--- a/include/sqlpp11/prepared_insert.h
+++ b/include/sqlpp11/prepared_insert.h
@@ -28,7 +28,7 @@
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
-#include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/prepared_remove.h b/include/sqlpp11/prepared_remove.h
index 0baa3778..6eda84fb 100644
--- a/include/sqlpp11/prepared_remove.h
+++ b/include/sqlpp11/prepared_remove.h
@@ -28,7 +28,7 @@
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
-#include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/prepared_select.h b/include/sqlpp11/prepared_select.h
index d5586bfe..ce621229 100644
--- a/include/sqlpp11/prepared_select.h
+++ b/include/sqlpp11/prepared_select.h
@@ -28,7 +28,7 @@
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
-#include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/prepared_update.h b/include/sqlpp11/prepared_update.h
index 8f15b74a..81525587 100644
--- a/include/sqlpp11/prepared_update.h
+++ b/include/sqlpp11/prepared_update.h
@@ -28,7 +28,7 @@
 
 #include <sqlpp11/parameter_list.h>
 #include <sqlpp11/result.h>
-#include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/result_row.h b/include/sqlpp11/result_row.h
index f02e043f..40cde145 100644
--- a/include/sqlpp11/result_row.h
+++ b/include/sqlpp11/result_row.h
@@ -26,10 +26,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <map>
 #include <utility>
 #include <sqlpp11/compat/string_view.h>
-#include <sqlpp11/data_types/text.h>
 #include <sqlpp11/detail/index_sequence.h>
 #include <sqlpp11/field_spec.h>
 #include <sqlpp11/no_name.h>
diff --git a/include/sqlpp11/select_column_list.h b/include/sqlpp11/select_column_list.h
index a86b493f..b8d1b97e 100644
--- a/include/sqlpp11/select_column_list.h
+++ b/include/sqlpp11/select_column_list.h
@@ -26,7 +26,6 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/auto_alias.h>
 #include <sqlpp11/detail/column_tuple_merge.h>
 #include <sqlpp11/detail/type_set.h>
diff --git a/include/sqlpp11/select_pseudo_table.h b/include/sqlpp11/select_pseudo_table.h
index 58ed1f4d..add46101 100644
--- a/include/sqlpp11/select_pseudo_table.h
+++ b/include/sqlpp11/select_pseudo_table.h
@@ -26,7 +26,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sqlpp11/data_types/no_value.h>
+#include <sqlpp11/type_traits.h>
 #include <sqlpp11/table.h>
 
 namespace sqlpp
diff --git a/include/sqlpp11/single_table.h b/include/sqlpp11/single_table.h
index 87e47f34..77287a81 100644
--- a/include/sqlpp11/single_table.h
+++ b/include/sqlpp11/single_table.h
@@ -26,7 +26,6 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/no_data.h>
 #include <sqlpp11/prepared_insert.h>
diff --git a/include/sqlpp11/sqlpp11.h b/include/sqlpp11/sqlpp11.h
index 6fd9b436..57a0afe3 100644
--- a/include/sqlpp11/sqlpp11.h
+++ b/include/sqlpp11/sqlpp11.h
@@ -27,7 +27,6 @@
  */
 
 #include <sqlpp11/alias_provider.h>
-#include <sqlpp11/data_types.h>
 #include <sqlpp11/insert.h>
 #include <sqlpp11/remove.h>
 #include <sqlpp11/update.h>
diff --git a/include/sqlpp11/statement.h b/include/sqlpp11/statement.h
index 452eb5e2..a0e27b59 100644
--- a/include/sqlpp11/statement.h
+++ b/include/sqlpp11/statement.h
@@ -32,6 +32,7 @@
 #include <sqlpp11/prepared_select.h>
 #include <sqlpp11/result.h>
 #include <sqlpp11/serialize.h>
+#include <sqlpp11/statement_fwd.h>
 
 #include <sqlpp11/detail/get_first.h>
 #include <sqlpp11/detail/get_last.h>
@@ -165,8 +166,11 @@ namespace sqlpp
 
   template <typename... Policies>
   struct statement_t : public Policies::template _base_t<detail::statement_policies_t<Policies...>>...,
+#warning: reactivate
+  /*
                        public expression_operators<statement_t<Policies...>,
                                                    value_type_of_t<detail::statement_policies_t<Policies...>>>,
+                                                   */
                        public detail::statement_policies_t<Policies...>::_result_methods_t
   {
     using _policies_t = typename detail::statement_policies_t<Policies...>;
diff --git a/include/sqlpp11/table.h b/include/sqlpp11/table.h
index c8369fa2..45db9ac4 100644
--- a/include/sqlpp11/table.h
+++ b/include/sqlpp11/table.h
@@ -32,7 +32,6 @@
 #include <sqlpp11/column.h>
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/join.h>
-#include <sqlpp11/data_types/no_value.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/type_traits.h b/include/sqlpp11/type_traits.h
index 0a314a6b..2d401e80 100644
--- a/include/sqlpp11/type_traits.h
+++ b/include/sqlpp11/type_traits.h
@@ -314,6 +314,41 @@ namespace sqlpp
   {
   };
 
+
+  template<typename T>
+    struct parameter_value;
+
+  template<typename T>
+    struct parameter_value<sqlpp::compat::optional<T>>
+    {
+      using type = sqlpp::compat::optional<typename parameter_value<T>::type>;
+    };
+
+  template <typename T>
+    using parameter_value_t = typename parameter_value<T>::type;
+
+  template<>
+    struct parameter_value<blob> { using type = std::vector<uint8_t>; };
+
+  template<>
+    struct parameter_value<boolean> { using type = bool; };
+
+  template<>
+    struct parameter_value<integral> { using type = int64_t; };
+
+  template<>
+    struct parameter_value<unsigned_integral> { using type = uint64_t; };
+
+  template<>
+    struct parameter_value<text> { using type = std::string; };
+
+  template<>
+    struct parameter_value<day_point> { using type = std::chrono::time_point<std::chrono::system_clock, sqlpp::chrono::days>; };
+  template<>
+    struct parameter_value<time_of_day> { using type = std::chrono::microseconds; };
+  template<>
+    struct parameter_value<time_point> { using type = std::chrono::time_point<std::chrono::system_clock, std::chrono::microseconds>; };
+
 #warning: These something_t data type classifiers should be removed
   // data types
   struct blob;
diff --git a/include/sqlpp11/value_type.h b/include/sqlpp11/value_type.h
index bb2b4517..de7ebf98 100644
--- a/include/sqlpp11/value_type.h
+++ b/include/sqlpp11/value_type.h
@@ -27,10 +27,9 @@
  */
 
 #include <type_traits>
-#include <sqlpp11/wrap_operand.h>
 
 namespace sqlpp
 {
   template <typename T>
-  using value_type_t = value_type_of_t<wrap_operand_t<T>>;
+  using value_type_t = value_type_of_t<T>;
 }  // namespace sqlpp
diff --git a/include/sqlpp11/verbatim.h b/include/sqlpp11/verbatim.h
index 04cdbdda..af0b9b7c 100644
--- a/include/sqlpp11/verbatim.h
+++ b/include/sqlpp11/verbatim.h
@@ -26,17 +26,17 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sqlpp11/data_types/no_value.h>
+#include <utility>
+
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/serialize.h>
 
-#include <utility>
 
 namespace sqlpp
 {
   template <typename ValueType>  // Csaba Csoma suggests: unsafe_sql instead of verbatim
-  struct verbatim_t : public expression_operators<verbatim_t<ValueType>, ValueType>,
-                      public alias_operators<verbatim_t<ValueType>>
+  struct verbatim_t /*: public expression_operators<verbatim_t<ValueType>, ValueType>,
+                      public alias_operators<verbatim_t<ValueType>>*/
   {
     using _traits = make_traits<ValueType, tag::is_expression>;
     using _nodes = detail::type_vector<>;
diff --git a/include/sqlpp11/verbatim_table.h b/include/sqlpp11/verbatim_table.h
index f111cbe5..a1c0b91c 100644
--- a/include/sqlpp11/verbatim_table.h
+++ b/include/sqlpp11/verbatim_table.h
@@ -26,11 +26,11 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <utility>
+
 #include <sqlpp11/table.h>
 #include <sqlpp11/char_sequence.h>
-#include <sqlpp11/data_types/no_value.h>
-
-#include <utility>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/with.h b/include/sqlpp11/with.h
index 33a007f3..0f0ca995 100644
--- a/include/sqlpp11/with.h
+++ b/include/sqlpp11/with.h
@@ -26,7 +26,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sqlpp11/assignment.h>
+#include <sqlpp11/operator/assign_expression.h>
 #include <sqlpp11/column_fwd.h>
 #include <sqlpp11/interpret_tuple.h>
 #include <sqlpp11/logic.h>
diff --git a/include/sqlpp11/wrap_operand.h b/include/sqlpp11/wrap_operand.h
deleted file mode 100644
index 114f9a96..00000000
--- a/include/sqlpp11/wrap_operand.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-/*
- * 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.
- */
-
-namespace sqlpp
-{
-  template <typename T, typename Enable = void>
-  struct wrap_operand
-  {
-    using type = T;
-  };
-
-  template <typename T>
-  using wrap_operand_t = typename wrap_operand<T>::type;
-}  // namespace sqlpp
diff --git a/scripts/ddl2cpp b/scripts/ddl2cpp
index af50ad01..fa438049 100755
--- a/scripts/ddl2cpp
+++ b/scripts/ddl2cpp
@@ -175,11 +175,11 @@ def initDllParser():
 
     ddlInteger = pp.Or(
         map(pp.CaselessKeyword, sorted(ddlIntegerTypes, reverse=True))
-    ).setParseAction(pp.replaceWith("integer"))
+    ).setParseAction(pp.replaceWith("integral"))
 
     ddlSerial = (
         pp.Or(map(pp.CaselessKeyword, sorted(ddlSerialTypes, reverse=True)))
-        .setParseAction(pp.replaceWith("integer"))
+        .setParseAction(pp.replaceWith("integral"))
         .setResultsName("hasAutoValue")
     )
 
@@ -546,7 +546,7 @@ def beginHeader(pathToHeader, namespace, nsList):
     print("// generated by " + " ".join(sys.argv), file=header)
     print("", file=header)
     print("#include <sqlpp11/table.h>", file=header)
-    print("#include <sqlpp11/data_types.h>", file=header)
+    print("#include <sqlpp11/type_traits.h>", file=header)
     print("#include <sqlpp11/char_sequence.h>", file=header)
     print("", file=header)
     for ns in nsList:
@@ -693,7 +693,7 @@ def createHeader():
                 )
                 DataTypeError = True
             if columnType == "integer" and column.isUnsigned:
-                columnType = columnType + "_unsigned"
+                columnType = "unsigned_" + columnType
             if columnType == "time_point" and not noTimestampWarning:
                 print(
                     "Warning: date and time values are assumed to be without timezone."
diff --git a/tests/core/usage/MockDb.h b/tests/core/usage/MockDb.h
index 8a58cb34..fdbaf694 100644
--- a/tests/core/usage/MockDb.h
+++ b/tests/core/usage/MockDb.h
@@ -29,7 +29,6 @@
 #include <sqlpp11/connection.h>
 #include <sqlpp11/detail/float_safe_ostringstream.h>
 #include <sqlpp11/transaction.h>
-#include <sqlpp11/data_types/no_value.h>
 #include <sqlpp11/schema.h>
 #include <sqlpp11/serialize.h>
 #include <sqlpp11/serializer_context.h>
diff --git a/tests/core/usage/Sample.h b/tests/core/usage/Sample.h
index 71095ddc..27a435d7 100644
--- a/tests/core/usage/Sample.h
+++ b/tests/core/usage/Sample.h
@@ -3,7 +3,7 @@
 // generated by ./scripts/ddl2cpp -auto-id tests/core/usage/sample.sql tests/core/usage/Sample test
 
 #include <sqlpp11/table.h>
-#include <sqlpp11/data_types.h>
+#include <sqlpp11/type_traits.h>
 #include <sqlpp11/char_sequence.h>
 
 namespace test
@@ -24,7 +24,7 @@ namespace test
             const T& operator()() const { return id; }
           };
       };
-      using value_type = ::sqlpp::integer;
+      using value_type = ::sqlpp::integral;
       using has_default = std::true_type;
     };
     struct TextNnD
@@ -58,7 +58,7 @@ namespace test
             const T& operator()() const { return intN; }
           };
       };
-      using value_type = ::sqlpp::compat::optional<::sqlpp::integer>;
+      using value_type = ::sqlpp::compat::optional<::sqlpp::integral>;
       using has_default = std::true_type;
     };
     struct DoubleN
@@ -92,7 +92,7 @@ namespace test
             const T& operator()() const { return uIntN; }
           };
       };
-      using value_type = ::sqlpp::compat::optional<::sqlpp::integer_unsigned>;
+      using value_type = ::sqlpp::compat::optional<::sqlpp::integral>;
       using has_default = std::true_type;
     };
     struct BlobN
@@ -151,7 +151,7 @@ namespace test
             const T& operator()() const { return id; }
           };
       };
-      using value_type = ::sqlpp::integer;
+      using value_type = ::sqlpp::integral;
       using has_default = std::true_type;
     };
     struct TextN
@@ -202,7 +202,7 @@ namespace test
             const T& operator()() const { return intN; }
           };
       };
-      using value_type = ::sqlpp::compat::optional<::sqlpp::integer>;
+      using value_type = ::sqlpp::compat::optional<::sqlpp::integral>;
       using has_default = std::true_type;
     };
   } // namespace TabBar_
@@ -242,7 +242,7 @@ namespace test
             const T& operator()() const { return id; }
           };
       };
-      using value_type = ::sqlpp::integer;
+      using value_type = ::sqlpp::integral;
       using has_default = std::true_type;
     };
     struct DayPointN