diff --git a/include/sqlpp11/any.h b/include/sqlpp11/any.h
new file mode 100644
index 00000000..3130a69e
--- /dev/null
+++ b/include/sqlpp11/any.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2013, 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_ANY_H
+#define SQLPP_ANY_H
+
+#include <sstream>
+#include <sqlpp11/boolean.h>
+
+namespace sqlpp
+{
+	namespace detail
+	{
+		template<typename Select>
+		struct any_t: public boolean::template operators<any_t<Select>>
+		{
+			static_assert(is_select_t<Select>::value, "any() requires a single column select expression as argument");
+			static_assert(is_value_t<Select>::value, "any() requires a single column select expression as argument");
+
+			struct _value_type: public Select::_value_type::_base_value_type
+			{
+				using _is_named_expression = tag_yes;
+			};
+
+			struct _name_t
+			{
+				static constexpr const char* _get_name() { return "ANY"; }
+				template<typename T>
+					struct _member_t
+					{
+						T any;
+					};
+			};
+
+			any_t(Select&& select):
+				_select(std::move(select))
+			{}
+
+			any_t(const Select& select):
+				_select(select)
+			{}
+
+			any_t(const any_t&) = default;
+			any_t(any_t&&) = default;
+			any_t& operator=(const any_t&) = default;
+			any_t& operator=(any_t&&) = default;
+			~any_t() = default;
+
+			template<typename Db>
+				void serialize(std::ostream& os, Db& db) const
+				{
+					os << "ANY(";
+					_select.serialize(os, db);
+					os << ")";
+				}
+
+		private:
+			Select _select;
+		};
+	}
+
+	template<typename T>
+	auto any(T&& t) -> typename detail::any_t<typename operand_t<T, is_select_t>::type>
+	{
+		return { std::forward<T>(t) };
+	}
+
+}
+
+#endif
diff --git a/include/sqlpp11/avg.h b/include/sqlpp11/avg.h
new file mode 100644
index 00000000..fea4e42d
--- /dev/null
+++ b/include/sqlpp11/avg.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2013, 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_AVG_H
+#define SQLPP_AVG_H
+
+#include <sstream>
+#include <sqlpp11/type_traits.h>
+
+namespace sqlpp
+{
+	namespace detail
+	{
+		template<typename Expr>
+		struct avg_t: public boolean::template operators<avg_t<Expr>>
+		{
+			static_assert(is_value_t<Expr>::value, "avg() requires a value expression as argument");
+
+			struct _value_type: public Expr::_value_type::_base_value_type
+			{
+				using _is_named_expression = tag_yes;
+			};
+
+			struct _name_t
+			{
+				static constexpr const char* _get_name() { return "AVG"; }
+				template<typename T>
+					struct _member_t
+					{
+						T avg;
+					};
+			};
+
+			avg_t(Expr&& expr):
+				_expr(std::move(expr))
+			{}
+
+			avg_t(const Expr& expr):
+				_expr(expr)
+			{}
+
+			avg_t(const avg_t&) = default;
+			avg_t(avg_t&&) = default;
+			avg_t& operator=(const avg_t&) = default;
+			avg_t& operator=(avg_t&&) = default;
+			~avg_t() = default;
+
+			template<typename Db>
+				void serialize(std::ostream& os, Db& db) const
+				{
+					os << "AVG(";
+					_expr.serialize(os, db);
+					os << ")";
+				}
+
+		private:
+			Expr _expr;
+		};
+	}
+
+	template<typename T>
+	auto avg(T&& t) -> typename detail::avg_t<typename operand_t<T, is_value_t>::type>
+	{
+		return { std::forward<T>(t) };
+	}
+
+}
+
+#endif
diff --git a/include/sqlpp11/concat.h b/include/sqlpp11/concat.h
index 0070b6dd..c0b0814b 100644
--- a/include/sqlpp11/concat.h
+++ b/include/sqlpp11/concat.h
@@ -42,7 +42,11 @@ namespace sqlpp
 			using _valid_args = typename detail::make_set_if_not<is_text_t, First, Args...>::type;
 			static_assert(_valid_args::size::value == 0, "at least one non-text argument detected in concat()");
 
-			using _value_type = typename First::_value_type::_base_value_type;
+			struct _value_type: public First::_value_type::_base_value_type
+			{
+				using _is_named_expression = tag_yes;
+			};
+
 			struct _name_t
 			{
 				static constexpr const char* _get_name() { return "CONCAT"; }
diff --git a/include/sqlpp11/count.h b/include/sqlpp11/count.h
new file mode 100644
index 00000000..4a3e0774
--- /dev/null
+++ b/include/sqlpp11/count.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2013, 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_COUNT_H
+#define SQLPP_COUNT_H
+
+#include <sstream>
+#include <sqlpp11/numeric.h>
+
+namespace sqlpp
+{
+	namespace detail
+	{
+		template<typename Expr>
+		struct count_t: public numeric::template operators<count_t<Expr>>
+		{
+			static_assert(is_value_t<Expr>::value, "count() requires a sql value as argument");
+
+			struct _value_type: public numeric
+			{
+				using _is_named_expression = tag_yes;
+			};
+
+			struct _name_t
+			{
+				static constexpr const char* _get_name() { return "COUNT"; }
+				template<typename T>
+					struct _member_t
+					{
+						T count;
+					};
+			};
+
+			count_t(Expr&& expr):
+				_expr(std::move(expr))
+			{}
+
+			count_t(const Expr& expr):
+				_expr(expr)
+			{}
+
+			count_t(const count_t&) = default;
+			count_t(count_t&&) = default;
+			count_t& operator=(const count_t&) = default;
+			count_t& operator=(count_t&&) = default;
+			~count_t() = default;
+
+			template<typename Db>
+				void serialize(std::ostream& os, Db& db) const
+				{
+					os << "COUNT(";
+					_expr.serialize(os, db);
+					os << ")";
+				}
+
+		private:
+			Expr _expr;
+		};
+	}
+
+	template<typename T>
+	auto count(T&& t) -> typename detail::count_t<typename operand_t<T, is_value_t>::type>
+	{
+		return { std::forward<T>(t) };
+	}
+
+}
+
+#endif
diff --git a/include/sqlpp11/exists.h b/include/sqlpp11/exists.h
new file mode 100644
index 00000000..2b04d8d8
--- /dev/null
+++ b/include/sqlpp11/exists.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2013, 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_EXISTS_H
+#define SQLPP_EXISTS_H
+
+#include <sstream>
+#include <sqlpp11/boolean.h>
+
+namespace sqlpp
+{
+	namespace detail
+	{
+		template<typename Select>
+		struct exists_t: public boolean::template operators<exists_t<Select>>
+		{
+			static_assert(is_select_t<Select>::value, "exists() requires a select expression as argument");
+
+			struct _value_type: public boolean
+			{
+				using _is_named_expression = tag_yes;
+			};
+
+			struct _name_t
+			{
+				static constexpr const char* _get_name() { return "EXISTS"; }
+				template<typename T>
+					struct _member_t
+					{
+						T exists;
+					};
+			};
+
+			exists_t(Select&& select):
+				_select(std::move(select))
+			{}
+
+			exists_t(const Select& select):
+				_select(select)
+			{}
+
+			exists_t(const exists_t&) = default;
+			exists_t(exists_t&&) = default;
+			exists_t& operator=(const exists_t&) = default;
+			exists_t& operator=(exists_t&&) = default;
+			~exists_t() = default;
+
+			template<typename Db>
+				void serialize(std::ostream& os, Db& db) const
+				{
+					os << "EXISTS(";
+					_select.serialize(os, db);
+					os << ")";
+				}
+
+		private:
+			Select _select;
+		};
+	}
+
+	template<typename T>
+	auto exists(T&& t) -> typename detail::exists_t<typename operand_t<T, is_select_t>::type>
+	{
+		return { std::forward<T>(t) };
+	}
+
+}
+
+#endif
diff --git a/include/sqlpp11/functions.h b/include/sqlpp11/functions.h
index 87225f0e..df97be91 100644
--- a/include/sqlpp11/functions.h
+++ b/include/sqlpp11/functions.h
@@ -27,60 +27,20 @@
 #ifndef SQLPP_FUNCTIONS_H
 #define SQLPP_FUNCTIONS_H
 
+#include <sstream>
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/column_types.h>
-#include <sstream>
+#include <sqlpp11/exists.h>
+#include <sqlpp11/any.h>
+#include <sqlpp11/some.h>
+#include <sqlpp11/count.h>
+#include <sqlpp11/min.h>
+#include <sqlpp11/max.h>
+#include <sqlpp11/avg.h>
+#include <sqlpp11/sum.h>
 
 namespace sqlpp
 {
-#define SQLPP_MAKE_UNARY_TYPED_FUNCTION(NAME, SQL, CONSTRAINT, VALUE_TYPE) \
-	namespace detail\
-	{\
-		template<typename T>\
-			struct NAME##_t\
-			{\
-				static_assert(CONSTRAINT<typename std::decay<T>::type>::value, #NAME "() argument has constraint: " #CONSTRAINT);\
-				static_assert(is_expression_t<typename std::decay<T>::type>::value, #NAME "() argument has contraint: is_expression_t");\
-				using _operand = typename operand_t<T, CONSTRAINT>::type;\
-				\
-				struct _op\
-				{\
-					struct _value_type: public VALUE_TYPE\
-					{\
-						using _is_named_expression = tag_yes;\
-					};\
-					struct _name_t\
-					{\
-						static constexpr const char* _get_name() { return #SQL; }\
-						template<typename M>\
-						struct _member_t\
-						{\
-							M NAME;\
-						};\
-					};\
-				};\
-				\
-				using type = named_unary_function_t<_op, _operand>;\
-			};\
-	}\
-	template<typename T>\
-	auto NAME(T&& t) -> typename detail::NAME##_t<T>::type\
-	{\
-		return { std::forward<T>(t) };\
-	}
-
-#define SQLPP_MAKE_UNARY_FUNCTION(NAME, SQL, CONSTRAINT) SQLPP_MAKE_UNARY_TYPED_FUNCTION(NAME, SQL, CONSTRAINT, _operand::_value_type)
-
-	SQLPP_MAKE_UNARY_FUNCTION(avg, AVG, is_value_t);
-	SQLPP_MAKE_UNARY_FUNCTION(min, MIN, is_value_t);
-	SQLPP_MAKE_UNARY_FUNCTION(max, MAX, is_value_t);
-	SQLPP_MAKE_UNARY_FUNCTION(sum, SUM, is_value_t);
-	SQLPP_MAKE_UNARY_FUNCTION(any, ANY, is_select_t);
-	SQLPP_MAKE_UNARY_FUNCTION(some, SOME, is_select_t);
-	SQLPP_MAKE_UNARY_TYPED_FUNCTION(count, COUNT, is_expression_t, bigint);
-	SQLPP_MAKE_UNARY_TYPED_FUNCTION(exists, EXISTS, is_select_t, boolean);
-	SQLPP_MAKE_UNARY_TYPED_FUNCTION(not_exists, NOT EXISTS, is_select_t, boolean);
-
 	template<typename T>
 		auto value(T&& t) -> typename operand_t<T, is_value_t>::type
 		{
diff --git a/include/sqlpp11/like.h b/include/sqlpp11/like.h
index 6551e71d..907c03d4 100644
--- a/include/sqlpp11/like.h
+++ b/include/sqlpp11/like.h
@@ -43,7 +43,11 @@ namespace sqlpp
 			static_assert(is_text_t<Operand>::value, "Operand for like() has to be a text");
 			static_assert(is_text_t<Pattern>::value, "Pattern for like() has to be a text");
 
-			using _value_type = typename Operand::_value_type::_base_value_type;
+			struct _value_type: public Operand::_value_type::_base_value_type
+			{
+				using _is_named_expression = tag_yes;
+			};
+
 			struct _name_t
 			{
 				static constexpr const char* _get_name() { return "LIKE"; }
diff --git a/include/sqlpp11/max.h b/include/sqlpp11/max.h
new file mode 100644
index 00000000..f7da5e1a
--- /dev/null
+++ b/include/sqlpp11/max.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2013, 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_MAX_H
+#define SQLPP_MAX_H
+
+#include <sstream>
+#include <sqlpp11/type_traits.h>
+
+namespace sqlpp
+{
+	namespace detail
+	{
+		template<typename Expr>
+		struct max_t: public boolean::template operators<max_t<Expr>>
+		{
+			static_assert(is_value_t<Expr>::value, "max() requires a value expression as argument");
+
+			struct _value_type: public Expr::_value_type::_base_value_type
+			{
+				using _is_named_expression = tag_yes;
+			};
+
+			struct _name_t
+			{
+				static constexpr const char* _get_name() { return "MAX"; }
+				template<typename T>
+					struct _member_t
+					{
+						T max;
+					};
+			};
+
+			max_t(Expr&& expr):
+				_expr(std::move(expr))
+			{}
+
+			max_t(const Expr& expr):
+				_expr(expr)
+			{}
+
+			max_t(const max_t&) = default;
+			max_t(max_t&&) = default;
+			max_t& operator=(const max_t&) = default;
+			max_t& operator=(max_t&&) = default;
+			~max_t() = default;
+
+			template<typename Db>
+				void serialize(std::ostream& os, Db& db) const
+				{
+					os << "MAX(";
+					_expr.serialize(os, db);
+					os << ")";
+				}
+
+		private:
+			Expr _expr;
+		};
+	}
+
+	template<typename T>
+	auto max(T&& t) -> typename detail::max_t<typename operand_t<T, is_value_t>::type>
+	{
+		return { std::forward<T>(t) };
+	}
+
+}
+
+#endif
diff --git a/include/sqlpp11/min.h b/include/sqlpp11/min.h
new file mode 100644
index 00000000..920d5837
--- /dev/null
+++ b/include/sqlpp11/min.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2013, 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_MIN_H
+#define SQLPP_MIN_H
+
+#include <sstream>
+#include <sqlpp11/type_traits.h>
+
+namespace sqlpp
+{
+	namespace detail
+	{
+		template<typename Expr>
+		struct min_t: public boolean::template operators<min_t<Expr>>
+		{
+			static_assert(is_value_t<Expr>::value, "min() requires a value expression as argument");
+
+			struct _value_type: public Expr::_value_type::_base_value_type
+			{
+				using _is_named_expression = tag_yes;
+			};
+
+			struct _name_t
+			{
+				static constexpr const char* _get_name() { return "MIN"; }
+				template<typename T>
+					struct _member_t
+					{
+						T min;
+					};
+			};
+
+			min_t(Expr&& expr):
+				_expr(std::move(expr))
+			{}
+
+			min_t(const Expr& expr):
+				_expr(expr)
+			{}
+
+			min_t(const min_t&) = default;
+			min_t(min_t&&) = default;
+			min_t& operator=(const min_t&) = default;
+			min_t& operator=(min_t&&) = default;
+			~min_t() = default;
+
+			template<typename Db>
+				void serialize(std::ostream& os, Db& db) const
+				{
+					os << "MIN(";
+					_expr.serialize(os, db);
+					os << ")";
+				}
+
+		private:
+			Expr _expr;
+		};
+	}
+
+	template<typename T>
+	auto min(T&& t) -> typename detail::min_t<typename operand_t<T, is_value_t>::type>
+	{
+		return { std::forward<T>(t) };
+	}
+
+}
+
+#endif
diff --git a/include/sqlpp11/some.h b/include/sqlpp11/some.h
new file mode 100644
index 00000000..33f095f3
--- /dev/null
+++ b/include/sqlpp11/some.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2013, 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_SOME_H
+#define SQLPP_SOME_H
+
+#include <sstream>
+#include <sqlpp11/boolean.h>
+
+namespace sqlpp
+{
+	namespace detail
+	{
+		template<typename Select>
+		struct some_t: public boolean::template operators<some_t<Select>>
+		{
+			static_assert(is_select_t<Select>::value, "some() requires a single column select expression as argument");
+			static_assert(is_value_t<Select>::value, "some() requires a single column select expression as argument");
+
+			struct _value_type: public Select::_value_type::_base_value_type
+			{
+				using _is_named_expression = tag_yes;
+			};
+
+			struct _name_t
+			{
+				static constexpr const char* _get_name() { return "SOME"; }
+				template<typename T>
+					struct _member_t
+					{
+						T some;
+					};
+			};
+
+			some_t(Select&& select):
+				_select(std::move(select))
+			{}
+
+			some_t(const Select& select):
+				_select(select)
+			{}
+
+			some_t(const some_t&) = default;
+			some_t(some_t&&) = default;
+			some_t& operator=(const some_t&) = default;
+			some_t& operator=(some_t&&) = default;
+			~some_t() = default;
+
+			template<typename Db>
+				void serialize(std::ostream& os, Db& db) const
+				{
+					os << "SOME(";
+					_select.serialize(os, db);
+					os << ")";
+				}
+
+		private:
+			Select _select;
+		};
+	}
+
+	template<typename T>
+	auto some(T&& t) -> typename detail::some_t<typename operand_t<T, is_select_t>::type>
+	{
+		return { std::forward<T>(t) };
+	}
+
+}
+
+#endif
diff --git a/include/sqlpp11/sum.h b/include/sqlpp11/sum.h
new file mode 100644
index 00000000..f7da5e1a
--- /dev/null
+++ b/include/sqlpp11/sum.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2013, 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_MAX_H
+#define SQLPP_MAX_H
+
+#include <sstream>
+#include <sqlpp11/type_traits.h>
+
+namespace sqlpp
+{
+	namespace detail
+	{
+		template<typename Expr>
+		struct max_t: public boolean::template operators<max_t<Expr>>
+		{
+			static_assert(is_value_t<Expr>::value, "max() requires a value expression as argument");
+
+			struct _value_type: public Expr::_value_type::_base_value_type
+			{
+				using _is_named_expression = tag_yes;
+			};
+
+			struct _name_t
+			{
+				static constexpr const char* _get_name() { return "MAX"; }
+				template<typename T>
+					struct _member_t
+					{
+						T max;
+					};
+			};
+
+			max_t(Expr&& expr):
+				_expr(std::move(expr))
+			{}
+
+			max_t(const Expr& expr):
+				_expr(expr)
+			{}
+
+			max_t(const max_t&) = default;
+			max_t(max_t&&) = default;
+			max_t& operator=(const max_t&) = default;
+			max_t& operator=(max_t&&) = default;
+			~max_t() = default;
+
+			template<typename Db>
+				void serialize(std::ostream& os, Db& db) const
+				{
+					os << "MAX(";
+					_expr.serialize(os, db);
+					os << ")";
+				}
+
+		private:
+			Expr _expr;
+		};
+	}
+
+	template<typename T>
+	auto max(T&& t) -> typename detail::max_t<typename operand_t<T, is_value_t>::type>
+	{
+		return { std::forward<T>(t) };
+	}
+
+}
+
+#endif