diff --git a/include/sqlpp11/column.h b/include/sqlpp11/column.h
index 25d86233..22842dcc 100644
--- a/include/sqlpp11/column.h
+++ b/include/sqlpp11/column.h
@@ -62,6 +62,8 @@ namespace sqlpp
 
     template <typename T>
     using _is_valid_operand = is_valid_operand<value_type_of<ColumnSpec>, T>;
+    template <typename T>
+    using _is_valid_assignment_operand = is_valid_assignment_operand<value_type_of<ColumnSpec>, T>;
 
     column_t() = default;
     column_t(const column_t&) = default;
@@ -87,7 +89,7 @@ namespace sqlpp
     auto operator=(T t) const -> assignment_t<column_t, wrap_operand_t<T>>
     {
       using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs assignment operand");
+      static_assert(_is_valid_assignment_operand<rhs>::value, "invalid rhs assignment operand");
 
       return {*this, {rhs{t}}};
     }
diff --git a/include/sqlpp11/date.h b/include/sqlpp11/date.h
index 37eb170c..ce1d645a 100644
--- a/include/sqlpp11/date.h
+++ b/include/sqlpp11/date.h
@@ -28,7 +28,7 @@
 #define SQLPP_DATE_H
 
 #include <date.h>
-#include <sqlpp11/date_time_fwd.h>
+#include <sqlpp11/date_time.h>
 #include <sqlpp11/basic_expression_operators.h>
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/exception.h>
@@ -43,10 +43,12 @@ namespace sqlpp
   {
     using _traits = make_traits<date, tag::is_value_type>;
     using _tag = tag::is_date;
-    using _cpp_value_type = cpp::day_point;
+    using _cpp_value_type = ::sqlpp::chrono::day_point;
 
     template <typename T>
     using _is_valid_operand = is_time_point_t<T>;
+    template <typename T>
+    using _is_valid_assignment_operand = is_date_t<T>;
   };
 
   // date parameter value
@@ -194,7 +196,7 @@ namespace sqlpp
     template <typename Target>
     void _bind(Target& target, size_t i)
     {
-      target._bind_day_point_result(i, &_value, &_is_null);
+      target._bind_date_result(i, &_value, &_is_null);
     }
 
   private:
diff --git a/include/sqlpp11/date_time.h b/include/sqlpp11/date_time.h
index 1805b334..9b1933ea 100644
--- a/include/sqlpp11/date_time.h
+++ b/include/sqlpp11/date_time.h
@@ -42,7 +42,7 @@ namespace sqlpp
   {
     using _traits = make_traits<date_time, tag::is_value_type>;
     using _tag = tag::is_date_time;
-    using _cpp_value_type = cpp::ms_point;
+    using _cpp_value_type = ::sqlpp::chrono::mus_point;
 
     template <typename T>
     using _is_valid_operand = is_time_point_t<T>;
@@ -109,7 +109,7 @@ namespace sqlpp
     template <typename Target>
     void _bind(Target& target, size_t index) const
     {
-      target._bind_date_parameter(index, &_value, _is_null);
+      target._bind_date_time_parameter(index, &_value, _is_null);
     }
 
   private:
@@ -194,7 +194,7 @@ namespace sqlpp
     template <typename Target>
     void _bind(Target& target, size_t i)
     {
-      target._bind_date_result(i, &_value, &_is_null);
+      target._bind_date_time_result(i, &_value, &_is_null);
     }
 
   private:
@@ -217,8 +217,8 @@ namespace sqlpp
       }
       else
       {
-        const auto dp = ::date::floor<::date::days>(t);
-        const auto time = ::date::make_time(t - dp);
+        const auto dp = ::date::floor<::date::days>(t.value());
+        const auto time = ::date::make_time(t.value() - dp);
         const auto ymd = ::date::year_month_day{dp};
         context << ymd << ' ' << time;
       }
diff --git a/include/sqlpp11/date_time_fwd.h b/include/sqlpp11/date_time_fwd.h
index 8ed68c38..9ca9be00 100644
--- a/include/sqlpp11/date_time_fwd.h
+++ b/include/sqlpp11/date_time_fwd.h
@@ -31,16 +31,16 @@
 
 namespace sqlpp
 {
-  namespace cpp
+  namespace chrono
   {
     using days = std::chrono::duration<int, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>;
 
     using day_point = std::chrono::time_point<std::chrono::system_clock, days>;
-    using ms_point = std::chrono::time_point<std::chrono::system_clock, std::chrono::microseconds>;
+    using mus_point = std::chrono::time_point<std::chrono::system_clock, std::chrono::microseconds>;
   }
 
   struct date;
   struct date_time;
-};
+}
 
 #endif
diff --git a/include/sqlpp11/value_type_fwd.h b/include/sqlpp11/value_type_fwd.h
index 4448796c..2923d896 100644
--- a/include/sqlpp11/value_type_fwd.h
+++ b/include/sqlpp11/value_type_fwd.h
@@ -58,6 +58,27 @@ namespace sqlpp
         and ValueType::template _is_valid_operand<T>::value  // the correct value type is required, of course
         ;
   };
+
+  template <typename ValueType, typename T, typename Enable = void>
+  struct is_valid_assignment_operand
+  {
+    static constexpr bool value =
+        is_expression_t<T>::value                            // expressions are OK
+        and ValueType::template _is_valid_operand<T>::value  // the correct value type is required, of course
+        ;
+  };
+
+  template <typename ValueType, typename T>
+  struct is_valid_assignment_operand<
+      ValueType,
+      T,
+      typename std::enable_if<std::is_class<typename ValueType::template _is_valid_assignment_operand<T>>::value>::type>
+  {
+    static constexpr bool value =
+        is_expression_t<T>::value                                       // expressions are OK
+        and ValueType::template _is_valid_assignment_operand<T>::value  // the correct value type is required, of course
+        ;
+  };
 }
 
 #endif
diff --git a/include/sqlpp11/wrap_operand.h b/include/sqlpp11/wrap_operand.h
index 013d6667..92925b2e 100644
--- a/include/sqlpp11/wrap_operand.h
+++ b/include/sqlpp11/wrap_operand.h
@@ -85,10 +85,54 @@ namespace sqlpp
     }
   };
 
+  struct date_operand : public alias_operators<date_operand>
+  {
+    using _traits = make_traits<date, tag::is_expression, tag::is_wrapped_value>;
+    using _nodes = detail::type_vector<>;
+    using _is_aggregate_expression = std::true_type;
+
+    using _value_t = ::sqlpp::chrono::day_point;
+
+    date_operand() : _t{}
+    {
+    }
+
+    date_operand(_value_t t) : _t(t)
+    {
+    }
+
+    date_operand(const date_operand&) = default;
+    date_operand(date_operand&&) = default;
+    date_operand& operator=(const date_operand&) = default;
+    date_operand& operator=(date_operand&&) = default;
+    ~date_operand() = default;
+
+    bool _is_trivial() const
+    {
+      return _t == _value_t{};
+    }
+
+    _value_t _t;
+  };
+
+  template <typename Context>
+  struct serializer_t<Context, date_operand>
+  {
+    using _serialize_check = consistent_t;
+    using Operand = date_operand;
+
+    static Context& _(const Operand& t, Context& context)
+    {
+      const auto ymd = ::date::year_month_day{t._t};
+      context << "DATE '" << ymd << "'";
+      return context;
+    }
+  };
+
   template <typename Period>
   struct date_time_operand : public alias_operators<date_time_operand<Period>>
   {
-    using _traits = make_traits<date, tag::is_expression, tag::is_wrapped_value>;
+    using _traits = make_traits<date_time, tag::is_expression, tag::is_wrapped_value>;
     using _nodes = detail::type_vector<>;
     using _is_aggregate_expression = std::true_type;
 
@@ -132,20 +176,6 @@ namespace sqlpp
     }
   };
 
-  template <typename Context>
-  struct serializer_t<Context, date_time_operand<cpp::days>>
-  {
-    using _serialize_check = consistent_t;
-    using Operand = date_time_operand<cpp::days>;
-
-    static Context& _(const Operand& t, Context& context)
-    {
-      const auto ymd = ::date::year_month_day{t._t};
-      context << "DATE '" << ymd << "'";
-      return context;
-    }
-  };
-
   struct integral_operand : public alias_operators<integral_operand>
   {
     using _traits = make_traits<integral, tag::is_expression, tag::is_wrapped_value>;
@@ -293,6 +323,12 @@ namespace sqlpp
     using type = date_time_operand<Period>;
   };
 
+  template <>
+  struct wrap_operand<std::chrono::time_point<std::chrono::system_clock, sqlpp::chrono::days>, void>
+  {
+    using type = date_operand;
+  };
+
   template <typename T>
   struct wrap_operand<T, typename std::enable_if<std::is_integral<T>::value>::type>
   {
diff --git a/tests/DateTime.cpp b/tests/DateTime.cpp
index 2537bf32..1b76446e 100644
--- a/tests/DateTime.cpp
+++ b/tests/DateTime.cpp
@@ -36,32 +36,35 @@ int DateTime(int, char**)
   MockDb::_serializer_context_t printer;
   test::TabDateTime t;
 
-  for (const auto& row : db(select(sqlpp::value(std::chrono::system_clock::now()).as(now))))
+  for (const auto& row : db(select(::sqlpp::value(std::chrono::system_clock::now()).as(now))))
   {
     std::cout << row.now;
   }
+  for (const auto& row : db(select(all_of(t)).from(t).where(true)))
+  {
+    std::cout << row.colDate;
+    std::cout << row.colDateTime;
+  }
   printer.reset();
-  std::cerr << serialize(sqlpp::value(std::chrono::system_clock::now()), printer).str() << std::endl;
+  std::cerr << serialize(::sqlpp::value(std::chrono::system_clock::now()), printer).str() << std::endl;
 
-  db(insert_into(t).set(t.colDate = ::date::floor<sqlpp::cpp::days>(std::chrono::system_clock::now())));
-  db(insert_into(t).set(t.colDate = std::chrono::system_clock::now()));
-  db(insert_into(t).set(t.colDateTime = ::date::floor<sqlpp::cpp::days>(std::chrono::system_clock::now())));
+  db(insert_into(t).set(t.colDate = ::date::floor<::sqlpp::chrono::days>(std::chrono::system_clock::now())));
+  db(insert_into(t).set(t.colDateTime = ::date::floor<::sqlpp::chrono::days>(std::chrono::system_clock::now())));
   db(insert_into(t).set(t.colDateTime = std::chrono::system_clock::now()));
 
   db(update(t)
-         .set(t.colDate = ::date::floor<sqlpp::cpp::days>(std::chrono::system_clock::now()))
+         .set(t.colDate = ::date::floor<::sqlpp::chrono::days>(std::chrono::system_clock::now()))
          .where(t.colDate < std::chrono::system_clock::now()));
-  db(update(t).set(t.colDate = std::chrono::system_clock::now()).where(t.colDate < std::chrono::system_clock::now()));
   db(update(t)
-         .set(t.colDateTime = ::date::floor<sqlpp::cpp::days>(std::chrono::system_clock::now()))
+         .set(t.colDateTime = ::date::floor<::sqlpp::chrono::days>(std::chrono::system_clock::now()))
          .where(t.colDate < std::chrono::system_clock::now()));
   db(update(t)
          .set(t.colDateTime = std::chrono::system_clock::now())
          .where(t.colDate < std::chrono::system_clock::now()));
 
-  db(remove_from(t).where(t.colDate == ::date::floor<sqlpp::cpp::days>(std::chrono::system_clock::now())));
+  db(remove_from(t).where(t.colDate == ::date::floor<::sqlpp::chrono::days>(std::chrono::system_clock::now())));
   db(remove_from(t).where(t.colDate == std::chrono::system_clock::now()));
-  db(remove_from(t).where(t.colDateTime == ::date::floor<sqlpp::cpp::days>(std::chrono::system_clock::now())));
+  db(remove_from(t).where(t.colDateTime == ::date::floor<::sqlpp::chrono::days>(std::chrono::system_clock::now())));
   db(remove_from(t).where(t.colDateTime == std::chrono::system_clock::now()));
 
   return 0;