diff --git a/include/sqlpp11/data_types/floating_point/column_operators.h b/include/sqlpp11/data_types/floating_point/column_operators.h
index dd3cda2b..6daf5131 100644
--- a/include/sqlpp11/data_types/floating_point/column_operators.h
+++ b/include/sqlpp11/data_types/floating_point/column_operators.h
@@ -28,6 +28,7 @@
 #define SQLPP_FLOATING_POINT_COLUMN_OPERATORS_H
 
 #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>
 
diff --git a/include/sqlpp11/data_types/integral/column_operators.h b/include/sqlpp11/data_types/integral/column_operators.h
index 72f30fd2..cd447123 100644
--- a/include/sqlpp11/data_types/integral/column_operators.h
+++ b/include/sqlpp11/data_types/integral/column_operators.h
@@ -28,6 +28,8 @@
 #define SQLPP_INTEGRAL_COLUMN_OPERATORS_H
 
 #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>
 
diff --git a/include/sqlpp11/data_types/integral/data_type.h b/include/sqlpp11/data_types/integral/data_type.h
index f029d5a9..4ffce0c4 100644
--- a/include/sqlpp11/data_types/integral/data_type.h
+++ b/include/sqlpp11/data_types/integral/data_type.h
@@ -27,13 +27,7 @@
 #ifndef SQLPP_INTEGRAL_DATA_TYPE_H
 #define SQLPP_INTEGRAL_DATA_TYPE_H
 
-#include <cstdlib>
-#include <sqlpp11/basic_expression_operators.h>
 #include <sqlpp11/type_traits.h>
-#include <sqlpp11/exception.h>
-#include <sqlpp11/value_type.h>
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/result_field.h>
 
 namespace sqlpp
 {
diff --git a/include/sqlpp11/data_types/integral/expression_operators.h b/include/sqlpp11/data_types/integral/expression_operators.h
index da18e0a8..5dc1d0af 100644
--- a/include/sqlpp11/data_types/integral/expression_operators.h
+++ b/include/sqlpp11/data_types/integral/expression_operators.h
@@ -28,6 +28,7 @@
 #define SQLPP_INTEGRAL_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>
 #include <sqlpp11/assignment.h>
diff --git a/include/sqlpp11/data_types/text.h b/include/sqlpp11/data_types/text.h
index cb6619d5..dcd08b38 100644
--- a/include/sqlpp11/data_types/text.h
+++ b/include/sqlpp11/data_types/text.h
@@ -27,256 +27,17 @@
 #ifndef SQLPP_TEXT_H
 #define SQLPP_TEXT_H
 
-#include <sqlpp11/assignment.h>
-#include <sqlpp11/basic_expression_operators.h>
-#include <sqlpp11/type_traits.h>
-#include <sqlpp11/exception.h>
-#include <sqlpp11/like.h>
-#include <sqlpp11/result_field.h>
+#include <sqlpp11/data_types/text/data_type.h>
+#include <sqlpp11/data_types/text/expression_operators.h>
+#include <sqlpp11/data_types/text/column_operators.h>
+#include <sqlpp11/data_types/text/parameter_type.h>
+#include <sqlpp11/data_types/text/result_field.h>
+#include <sqlpp11/data_types/text/operand.h>
+#include <sqlpp11/data_types/text/wrap_operand.h>
+#include <sqlpp11/data_types/text/serialize.h>
 
-namespace sqlpp
-{
-  template <typename... Args>
-  struct concat_t;
+// text specific functions
+#include <sqlpp11/data_types/text/like.h>
+#include <sqlpp11/data_types/text/concat.h>
 
-  // text value type
-  struct text
-  {
-    using _traits = make_traits<text, tag::is_value_type>;
-    using _tag = tag::is_text;
-    using _cpp_value_type = std::string;
-
-    template <typename T>
-    using _is_valid_operand = is_text_t<T>;
-  };
-
-  // text parameter type
-  template <>
-  struct parameter_value_t<text>
-  {
-    using _value_type = text;
-    using _cpp_value_type = typename _value_type::_cpp_value_type;
-
-    parameter_value_t() : _value(""), _is_null(true)
-    {
-    }
-
-    parameter_value_t(const _cpp_value_type& val) : _value(val), _is_null(false)
-    {
-    }
-
-    parameter_value_t& operator=(const _cpp_value_type& val)
-    {
-      _value = val;
-      _is_null = false;
-      return *this;
-    }
-
-    parameter_value_t& operator=(const tvin_t<wrap_operand_t<_cpp_value_type>>& t)
-    {
-      if (t._is_trivial())
-      {
-        _value = "";
-        _is_null = true;
-      }
-      else
-      {
-        _value = t._value._t;
-        _is_null = false;
-      }
-      return *this;
-    }
-
-    parameter_value_t& operator=(const std::nullptr_t&)
-    {
-      _value = "";
-      _is_null = true;
-      return *this;
-    }
-
-    bool is_null() const
-    {
-      return _is_null;
-    }
-
-    _cpp_value_type value() const
-    {
-      return _value;
-    }
-
-    operator _cpp_value_type() const
-    {
-      return value();
-    }
-
-    template <typename Target>
-    void _bind(Target& target, size_t index) const
-    {
-      target._bind_text_parameter(index, &_value, _is_null);
-    }
-
-  private:
-    _cpp_value_type _value;
-    bool _is_null;
-  };
-
-  // text expression operators
-  template <typename Base>
-  struct expression_operators<Base, text> : public basic_expression_operators<Base, text>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<text, T>;
-
-    template <typename T>
-    concat_t<Base, wrap_operand_t<T>> operator+(T t) const
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid rhs operand");
-
-      return {*static_cast<const Base*>(this), {t}};
-    }
-
-    template <typename T>
-    like_t<Base, wrap_operand_t<T>> like(T t) const
-    {
-      using rhs = wrap_operand_t<T>;
-      static_assert(_is_valid_operand<rhs>::value, "invalid argument for like()");
-
-      return {*static_cast<const Base*>(this), {t}};
-    }
-  };
-
-  // text column operators
-  template <typename Base>
-  struct column_operators<Base, text>
-  {
-    template <typename T>
-    using _is_valid_operand = is_valid_operand<text, T>;
-
-    template <typename T>
-    auto operator+=(T t) const -> assignment_t<Base, concat_t<Base, 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 Base*>(this),
-              concat_t<Base, wrap_operand_t<T>>{*static_cast<const Base*>(this), rhs{t}}};
-    }
-  };
-
-  // text result field
-  template <typename Db, typename FieldSpec>
-  struct result_field_t<text, Db, FieldSpec> : public result_field_methods_t<result_field_t<text, Db, FieldSpec>>
-  {
-    static_assert(std::is_same<value_type_of<FieldSpec>, text>::value, "field type mismatch");
-    using _cpp_value_type = typename text::_cpp_value_type;
-
-    result_field_t() : _is_valid(false), _value_ptr(nullptr), _len(0)
-    {
-    }
-
-    void _validate()
-    {
-      _is_valid = true;
-    }
-
-    void _invalidate()
-    {
-      _is_valid = false;
-      _value_ptr = nullptr;
-      _len = 0;
-    }
-
-    bool operator==(const _cpp_value_type& rhs) const
-    {
-      return value() == rhs;
-    }
-    bool operator!=(const _cpp_value_type& rhs) const
-    {
-      return not operator==(rhs);
-    }
-
-    bool is_null() const
-    {
-      if (not _is_valid)
-        throw exception("accessing is_null in non-existing row");
-      return _value_ptr == nullptr;
-    }
-
-    bool _is_trivial() const
-    {
-      if (not _is_valid)
-        throw exception("accessing is_null in non-existing row");
-
-      return value() == "";
-    }
-
-    _cpp_value_type value() const
-    {
-      if (not _is_valid)
-        throw exception("accessing value in non-existing row");
-
-      if (not _value_ptr)
-      {
-        if (enforce_null_result_treatment_t<Db>::value and not null_is_trivial_value_t<FieldSpec>::value)
-        {
-          throw exception("accessing value of NULL field");
-        }
-        else
-        {
-          return "";
-        }
-      }
-      return std::string(_value_ptr, _value_ptr + _len);
-    }
-
-    template <typename Target>
-    void _bind(Target& target, size_t i)
-    {
-      target._bind_text_result(i, &_value_ptr, &_len);
-    }
-
-  private:
-    bool _is_valid;
-    const char* _value_ptr;
-    size_t _len;
-  };
-
-  template <typename Context, typename Db, typename FieldSpec>
-  struct serializer_t<Context, result_field_t<text, Db, FieldSpec>>
-  {
-    using _serialize_check = consistent_t;
-    using T = result_field_t<text, Db, FieldSpec>;
-
-    static Context& _(const T& t, Context& context)
-    {
-      if (t.is_null() and not null_is_trivial_value_t<T>::value)
-      {
-        context << "NULL";
-      }
-      else
-      {
-        context << '\'' << context.escape(t.value()) << '\'';
-      }
-      return context;
-    }
-  };
-
-  template <typename Db, typename FieldSpec>
-  inline std::ostream& operator<<(std::ostream& os, const result_field_t<text, Db, FieldSpec>& e)
-  {
-    if (e.is_null() and not null_is_trivial_value_t<FieldSpec>::value)
-    {
-      return os << "NULL";
-    }
-    else
-    {
-      return os << e.value();
-    }
-  }
-
-  using blob = text;
-  using varchar = text;
-  using char_ = text;
-}
 #endif
diff --git a/include/sqlpp11/data_types/text/column_operators.h b/include/sqlpp11/data_types/text/column_operators.h
new file mode 100644
index 00000000..fd2d8695
--- /dev/null
+++ b/include/sqlpp11/data_types/text/column_operators.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2013-2015, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_TEXT_COLUMN_OPERATORS_H
+#define SQLPP_TEXT_COLUMN_OPERATORS_H
+
+#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 Base>
+  struct column_operators<Base, text>
+  {
+    template <typename T>
+    using _is_valid_operand = is_valid_operand<text, T>;
+
+    template <typename T>
+    auto operator+=(T t) const -> assignment_t<Base, concat_t<Base, 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 Base*>(this),
+              concat_t<Base, wrap_operand_t<T>>{*static_cast<const Base*>(this), rhs{t}}};
+    }
+  };
+}
+#endif
diff --git a/include/sqlpp11/concat.h b/include/sqlpp11/data_types/text/concat.h
similarity index 100%
rename from include/sqlpp11/concat.h
rename to include/sqlpp11/data_types/text/concat.h
diff --git a/include/sqlpp11/data_types/text/data_type.h b/include/sqlpp11/data_types/text/data_type.h
new file mode 100644
index 00000000..e9644357
--- /dev/null
+++ b/include/sqlpp11/data_types/text/data_type.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2013-2015, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_TEXT_DATA_TYPE_H
+#define SQLPP_TEXT_DATA_TYPE_H
+
+#include <sqlpp11/type_traits.h>
+
+namespace sqlpp
+{
+  struct text
+  {
+    using _traits = make_traits<text, tag::is_value_type>;
+    using _tag = tag::is_text;
+    using _cpp_value_type = std::string;
+
+    template <typename T>
+    using _is_valid_operand = is_text_t<T>;
+  };
+
+  using blob = text;
+  using varchar = text;
+  using char_ = text;
+}
+#endif
diff --git a/include/sqlpp11/data_types/text/expression_operators.h b/include/sqlpp11/data_types/text/expression_operators.h
new file mode 100644
index 00000000..01d9ccb7
--- /dev/null
+++ b/include/sqlpp11/data_types/text/expression_operators.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2013-2015, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_TEXT_EXPRESSION_OPERATORS_H
+#define SQLPP_TEXT_EXPRESSION_OPERATORS_H
+
+#include <sqlpp11/basic_expression_operators.h>
+#include <sqlpp11/type_traits.h>
+#include <sqlpp11/data_types/text/data_type.h>
+#include <sqlpp11/assignment.h>
+
+namespace sqlpp
+{
+  template <typename... Args>
+  struct concat_t;
+
+  template <typename Operand, typename Pattern>
+  struct like_t;
+
+  template <typename Base>
+  struct expression_operators<Base, text> : public basic_expression_operators<Base, text>
+  {
+    template <typename T>
+    using _is_valid_operand = is_valid_operand<text, T>;
+
+    template <typename T>
+    concat_t<Base, wrap_operand_t<T>> operator+(T t) const
+    {
+      using rhs = wrap_operand_t<T>;
+      static_assert(_is_valid_operand<rhs>::value, "invalid rhs operand");
+
+      return {*static_cast<const Base*>(this), {t}};
+    }
+
+    template <typename T>
+    like_t<Base, wrap_operand_t<T>> like(T t) const
+    {
+      using rhs = wrap_operand_t<T>;
+      static_assert(_is_valid_operand<rhs>::value, "invalid argument for like()");
+
+      return {*static_cast<const Base*>(this), {t}};
+    }
+  };
+}
+#endif
diff --git a/include/sqlpp11/like.h b/include/sqlpp11/data_types/text/like.h
similarity index 100%
rename from include/sqlpp11/like.h
rename to include/sqlpp11/data_types/text/like.h
diff --git a/include/sqlpp11/data_types/text/operand.h b/include/sqlpp11/data_types/text/operand.h
new file mode 100644
index 00000000..a73341e2
--- /dev/null
+++ b/include/sqlpp11/data_types/text/operand.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2013-2015, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_TEXT_OPERAND_H
+#define SQLPP_TEXT_OPERAND_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_aggregate_expression = std::true_type;
+
+    using _value_t = std::string;
+
+    text_operand() : _t{}
+    {
+    }
+
+    text_operand(_value_t 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;
+
+    bool _is_trivial() const
+    {
+      return _t.empty();
+    }
+
+    _value_t _t;
+  };
+}
+#endif
diff --git a/include/sqlpp11/data_types/text/parameter_type.h b/include/sqlpp11/data_types/text/parameter_type.h
new file mode 100644
index 00000000..796b7e29
--- /dev/null
+++ b/include/sqlpp11/data_types/text/parameter_type.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2013-2015, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_TEXT_PARAMETER_TYPE_H
+#define SQLPP_TEXT_PARAMETER_TYPE_H
+
+#include <sqlpp11/data_types/parameter_value.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/tvin.h>
+
+namespace sqlpp
+{
+  template <>
+  struct parameter_value_t<text>
+  {
+    using _value_type = text;
+    using _cpp_value_type = typename _value_type::_cpp_value_type;
+
+    parameter_value_t() : _value(""), _is_null(true)
+    {
+    }
+
+    parameter_value_t(const _cpp_value_type& val) : _value(val), _is_null(false)
+    {
+    }
+
+    parameter_value_t& operator=(const _cpp_value_type& val)
+    {
+      _value = val;
+      _is_null = false;
+      return *this;
+    }
+
+    parameter_value_t& operator=(const tvin_t<wrap_operand_t<_cpp_value_type>>& t)
+    {
+      if (t._is_trivial())
+      {
+        _value = "";
+        _is_null = true;
+      }
+      else
+      {
+        _value = t._value._t;
+        _is_null = false;
+      }
+      return *this;
+    }
+
+    parameter_value_t& operator=(const std::nullptr_t&)
+    {
+      _value = "";
+      _is_null = true;
+      return *this;
+    }
+
+    bool is_null() const
+    {
+      return _is_null;
+    }
+
+    _cpp_value_type value() const
+    {
+      return _value;
+    }
+
+    operator _cpp_value_type() const
+    {
+      return value();
+    }
+
+    template <typename Target>
+    void _bind(Target& target, size_t index) const
+    {
+      target._bind_text_parameter(index, &_value, _is_null);
+    }
+
+  private:
+    _cpp_value_type _value;
+    bool _is_null;
+  };
+}
+#endif
diff --git a/include/sqlpp11/data_types/text/result_field.h b/include/sqlpp11/data_types/text/result_field.h
new file mode 100644
index 00000000..b166c0e8
--- /dev/null
+++ b/include/sqlpp11/data_types/text/result_field.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2013-2015, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_TEXT_RESULT_FIELD_H
+#define SQLPP_TEXT_RESULT_FIELD_H
+
+#include <sqlpp11/basic_expression_operators.h>
+#include <sqlpp11/exception.h>
+#include <sqlpp11/result_field.h>
+#include <sqlpp11/result_field_methods.h>
+#include <sqlpp11/type_traits.h>
+#include <sqlpp11/data_types/text/data_type.h>
+
+namespace sqlpp
+{
+  template <typename Db, typename FieldSpec>
+  struct result_field_t<text, Db, FieldSpec> : public result_field_methods_t<result_field_t<text, Db, FieldSpec>>
+  {
+    static_assert(std::is_same<value_type_of<FieldSpec>, text>::value, "field type mismatch");
+    using _cpp_value_type = typename text::_cpp_value_type;
+
+    result_field_t() : _is_valid(false), _value_ptr(nullptr), _len(0)
+    {
+    }
+
+    void _validate()
+    {
+      _is_valid = true;
+    }
+
+    void _invalidate()
+    {
+      _is_valid = false;
+      _value_ptr = nullptr;
+      _len = 0;
+    }
+
+    bool operator==(const _cpp_value_type& rhs) const
+    {
+      return value() == rhs;
+    }
+    bool operator!=(const _cpp_value_type& rhs) const
+    {
+      return not operator==(rhs);
+    }
+
+    bool is_null() const
+    {
+      if (not _is_valid)
+        throw exception("accessing is_null in non-existing row");
+      return _value_ptr == nullptr;
+    }
+
+    bool _is_trivial() const
+    {
+      if (not _is_valid)
+        throw exception("accessing is_null in non-existing row");
+
+      return value() == "";
+    }
+
+    _cpp_value_type value() const
+    {
+      if (not _is_valid)
+        throw exception("accessing value in non-existing row");
+
+      if (not _value_ptr)
+      {
+        if (enforce_null_result_treatment_t<Db>::value and not null_is_trivial_value_t<FieldSpec>::value)
+        {
+          throw exception("accessing value of NULL field");
+        }
+        else
+        {
+          return "";
+        }
+      }
+      return std::string(_value_ptr, _value_ptr + _len);
+    }
+
+    template <typename Target>
+    void _bind(Target& target, size_t i)
+    {
+      target._bind_text_result(i, &_value_ptr, &_len);
+    }
+
+  private:
+    bool _is_valid;
+    const char* _value_ptr;
+    size_t _len;
+  };
+}
+#endif
diff --git a/include/sqlpp11/data_types/text/serialize.h b/include/sqlpp11/data_types/text/serialize.h
new file mode 100644
index 00000000..41d3d442
--- /dev/null
+++ b/include/sqlpp11/data_types/text/serialize.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2013-2015, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_TEXT_SERIALIZE_H
+#define SQLPP_TEXT_SERIALIZE_H
+
+#include <sqlpp11/result_field.h>
+#include <sqlpp11/data_types/text/operand.h>
+#include <ostream>
+
+namespace sqlpp
+{
+  template <typename Context>
+  struct serializer_t<Context, text_operand>
+  {
+    using _serialize_check = consistent_t;
+    using Operand = text_operand;
+
+    static Context& _(const Operand& t, Context& context)
+    {
+      context << '\'' << context.escape(t._t) << '\'';
+      return context;
+    }
+  };
+
+  template <typename Db, typename FieldSpec>
+  inline std::ostream& operator<<(std::ostream& os, const result_field_t<text, Db, FieldSpec>& e)
+  {
+    if (e.is_null() and not null_is_trivial_value_t<FieldSpec>::value)
+    {
+      return os << "NULL";
+    }
+    else
+    {
+      return os << e.value();
+    }
+  }
+}
+#endif
diff --git a/include/sqlpp11/data_types/text/wrap_operand.h b/include/sqlpp11/data_types/text/wrap_operand.h
new file mode 100644
index 00000000..f80e26d8
--- /dev/null
+++ b/include/sqlpp11/data_types/text/wrap_operand.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2013-2015, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SQLPP_TEXT_WRAP_OPERAND_H
+#define SQLPP_TEXT_WRAP_OPERAND_H
+
+#include <utility>
+#include <sqlpp11/type_traits.h>
+#include <sqlpp11/wrap_operand.h>
+
+namespace sqlpp
+{
+  struct text_operand;
+
+  template <typename T>
+  struct wrap_operand<
+      T,
+      typename std::enable_if<std::is_convertible<T, std::string>::value and not is_result_field_t<T>::value>::type>
+  {
+    using type = text_operand;
+  };
+}
+#endif
diff --git a/include/sqlpp11/functions.h b/include/sqlpp11/functions.h
index fd9512eb..916b0a66 100644
--- a/include/sqlpp11/functions.h
+++ b/include/sqlpp11/functions.h
@@ -36,7 +36,6 @@
 #include <sqlpp11/is_not_null.h>
 #include <sqlpp11/exists.h>
 #include <sqlpp11/any.h>
-#include <sqlpp11/concat.h>
 #include <sqlpp11/some.h>
 #include <sqlpp11/count.h>
 #include <sqlpp11/min.h>
diff --git a/include/sqlpp11/result_field.h b/include/sqlpp11/result_field.h
index 96d98422..821880a8 100644
--- a/include/sqlpp11/result_field.h
+++ b/include/sqlpp11/result_field.h
@@ -28,7 +28,8 @@
 #define SQLPP_RESULT_FIELD_H
 
 #include <sqlpp11/wrong.h>
-#include <sqlpp11/result_field_methods.h>
+#include <sqlpp11/wrap_operand.h>
+#include <sqlpp11/type_traits.h>
 
 namespace sqlpp
 {
@@ -52,7 +53,7 @@ namespace sqlpp
       }
       else
       {
-        context << t.value();
+        serialize(wrap_operand_t<T>{t}, context);
       }
       return context;
     }
diff --git a/include/sqlpp11/type_traits.h b/include/sqlpp11/type_traits.h
index 98bc1b35..797bec57 100644
--- a/include/sqlpp11/type_traits.h
+++ b/include/sqlpp11/type_traits.h
@@ -229,6 +229,15 @@ namespace sqlpp
   SQLPP_RECURSIVE_TRAIT_GENERATOR(can_be_null)
   SQLPP_RECURSIVE_TRAIT_GENERATOR(contains_aggregate_function)
 
+  template <typename ValueType, typename T>
+  struct is_valid_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
+        ;
+  };
+
   namespace detail
   {
     template <typename KnownAggregates, typename T, typename Leaf = void>
diff --git a/include/sqlpp11/value_type_fwd.h b/include/sqlpp11/value_type_fwd.h
index 8406ea39..5b105b18 100644
--- a/include/sqlpp11/value_type_fwd.h
+++ b/include/sqlpp11/value_type_fwd.h
@@ -38,15 +38,6 @@ namespace sqlpp
     static_assert(wrong_t<expression_operators>::value, "Missing expression operators for ValueType");
   };
 
-  template <typename ValueType, typename T>
-  struct is_valid_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, typename Enable = void>
   struct is_valid_assignment_operand
   {
diff --git a/include/sqlpp11/wrap_operand.h b/include/sqlpp11/wrap_operand.h
index ac93c00f..02edabad 100644
--- a/include/sqlpp11/wrap_operand.h
+++ b/include/sqlpp11/wrap_operand.h
@@ -50,7 +50,6 @@ namespace sqlpp
 namespace sqlpp
 {
   struct integral;
-  struct text;
 
   struct day_point_operand : public alias_operators<day_point_operand>
   {
@@ -143,49 +142,6 @@ namespace sqlpp
     }
   };
 
-  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_aggregate_expression = std::true_type;
-
-    using _value_t = std::string;
-
-    text_operand() : _t{}
-    {
-    }
-
-    text_operand(_value_t 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;
-
-    bool _is_trivial() const
-    {
-      return _t.empty();
-    }
-
-    _value_t _t;
-  };
-
-  template <typename Context>
-  struct serializer_t<Context, text_operand>
-  {
-    using _serialize_check = consistent_t;
-    using Operand = text_operand;
-
-    static Context& _(const Operand& t, Context& context)
-    {
-      context << '\'' << context.escape(t._t) << '\'';
-      return context;
-    }
-  };
-
   template <typename Period>
   struct wrap_operand<std::chrono::time_point<std::chrono::system_clock, Period>, void>
   {
@@ -197,14 +153,6 @@ namespace sqlpp
   {
     using type = day_point_operand;
   };
-
-  template <typename T>
-  struct wrap_operand<
-      T,
-      typename std::enable_if<std::is_convertible<T, std::string>::value and not is_result_field_t<T>::value>::type>
-  {
-    using type = text_operand;
-  };
 }
 
 #endif