From 950859af5ff133383dcfd3f0fc70907cc94afd15 Mon Sep 17 00:00:00 2001
From: Roland Bock <rb@theppro.com>
Date: Thu, 19 Sep 2013 17:07:14 +0200
Subject: [PATCH] Rewrote macro generated function code to handwritten code

This increases the number of Bytes, but it also increases readability,
and reduces complexity.
It also allows to specialize functions for database engines.
---
 include/sqlpp11/any.h       | 93 +++++++++++++++++++++++++++++++++++++
 include/sqlpp11/avg.h       | 92 ++++++++++++++++++++++++++++++++++++
 include/sqlpp11/concat.h    |  6 ++-
 include/sqlpp11/count.h     | 92 ++++++++++++++++++++++++++++++++++++
 include/sqlpp11/exists.h    | 92 ++++++++++++++++++++++++++++++++++++
 include/sqlpp11/functions.h | 58 ++++-------------------
 include/sqlpp11/like.h      |  6 ++-
 include/sqlpp11/max.h       | 92 ++++++++++++++++++++++++++++++++++++
 include/sqlpp11/min.h       | 92 ++++++++++++++++++++++++++++++++++++
 include/sqlpp11/some.h      | 93 +++++++++++++++++++++++++++++++++++++
 include/sqlpp11/sum.h       | 92 ++++++++++++++++++++++++++++++++++++
 11 files changed, 757 insertions(+), 51 deletions(-)
 create mode 100644 include/sqlpp11/any.h
 create mode 100644 include/sqlpp11/avg.h
 create mode 100644 include/sqlpp11/count.h
 create mode 100644 include/sqlpp11/exists.h
 create mode 100644 include/sqlpp11/max.h
 create mode 100644 include/sqlpp11/min.h
 create mode 100644 include/sqlpp11/some.h
 create mode 100644 include/sqlpp11/sum.h

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