From 864bd58effb3370259be7493c4023e7dde8d28f4 Mon Sep 17 00:00:00 2001
From: rbock <rbock@eudoxos.de>
Date: Sun, 5 Jul 2015 11:51:49 +0200
Subject: [PATCH] More functions are now auto-aliased

---
 include/sqlpp11/any.h                    | 13 -----
 include/sqlpp11/auto_alias.h             | 66 ++++++++++++++++++++++++
 include/sqlpp11/avg.h                    | 25 +++++----
 include/sqlpp11/concat.h                 | 19 ++++---
 include/sqlpp11/detail/copy_tuple_args.h | 17 +-----
 include/sqlpp11/exists.h                 | 23 +++++----
 include/sqlpp11/functions.h              |  2 +-
 include/sqlpp11/in.h                     | 23 +++++----
 include/sqlpp11/is_not_null.h            | 19 ++++---
 include/sqlpp11/is_null.h                | 25 +++++----
 include/sqlpp11/max.h                    | 19 ++++---
 include/sqlpp11/min.h                    | 19 ++++---
 include/sqlpp11/not_in.h                 | 25 +++++----
 include/sqlpp11/select_column_list.h     |  4 +-
 include/sqlpp11/some.h                   | 13 -----
 include/sqlpp11/sum.h                    | 25 +++++----
 tests/CMakeLists.txt                     | 26 +++++-----
 tests/Function.cpp                       | 21 ++++----
 18 files changed, 230 insertions(+), 154 deletions(-)
 create mode 100644 include/sqlpp11/auto_alias.h

diff --git a/include/sqlpp11/any.h b/include/sqlpp11/any.h
index 8585de1d..23ad6db0 100644
--- a/include/sqlpp11/any.h
+++ b/include/sqlpp11/any.h
@@ -39,19 +39,6 @@ namespace sqlpp
 			using _traits = make_traits<value_type_of<Select>, tag::is_multi_expression>;
 			using _nodes = detail::type_vector<Select>;
 
-			struct _alias_t
-			{
-        static constexpr const char _literal[] =  "any_";
-        using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
-				template<typename T>
-					struct _member_t
-					{
-						T any;
-						T& operator()() { return any; }
-						const T& operator()() const { return any; }
-					};
-			};
-
 			any_t(Select select):
 				_select(select)
 			{}
diff --git a/include/sqlpp11/auto_alias.h b/include/sqlpp11/auto_alias.h
new file mode 100644
index 00000000..1b47c559
--- /dev/null
+++ b/include/sqlpp11/auto_alias.h
@@ -0,0 +1,66 @@
+/*
+ * 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_AUTO_ALIAS_H
+#define SQLPP_AUTO_ALIAS_H
+
+#include <sqlpp11/alias.h>
+
+namespace sqlpp
+{
+	template<typename T, typename Enable = void>
+		struct has_auto_alias_t
+		{
+			static constexpr bool value = false;
+		};
+
+	template<typename T>
+		struct has_auto_alias_t<T, typename std::enable_if<not wrong_t<typename T::_auto_alias_t>::value>::type>
+		{
+			static constexpr bool value = true;
+		};
+
+	namespace detail
+	{
+		template<typename T, typename Enable = void>
+			struct auto_alias_impl
+			{
+				using type = T;
+			};
+
+		template<typename T>
+			struct auto_alias_impl<T, typename std::enable_if<has_auto_alias_t<T>::value>::type>
+			{
+				using type = expression_alias_t<T, typename T::_auto_alias_t>;
+			};
+	}
+
+	template<typename T>
+		using auto_alias_t = typename detail::auto_alias_impl<T>::type;
+}
+
+
+#endif
diff --git a/include/sqlpp11/avg.h b/include/sqlpp11/avg.h
index d332cf33..bc5b7f3d 100644
--- a/include/sqlpp11/avg.h
+++ b/include/sqlpp11/avg.h
@@ -32,17 +32,8 @@
 
 namespace sqlpp
 {
-	template<typename Flag, typename Expr>
-		struct avg_t:
-			public expression_operators<avg_t<Flag, Expr>, floating_point>,
-			public alias_operators<avg_t<Flag, Expr>>
+	struct avg_alias_t
 	{
-		using _traits = make_traits<floating_point, tag::is_expression, tag::is_selectable>;
-		using _nodes = detail::type_vector<Expr, aggregate_function>;
-
-		static_assert(is_noop<Flag>::value or std::is_same<distinct_t, Flag>::value, "avg() used with flag other than 'distinct'");
-		static_assert(is_numeric_t<Expr>::value, "avg() requires a value expression as argument");
-
 		struct _alias_t
 		{
 			static constexpr const char _literal[] =  "avg_";
@@ -55,6 +46,20 @@ namespace sqlpp
 					const T& operator()() const { return avg; }
 				};
 		};
+	};
+
+	template<typename Flag, typename Expr>
+		struct avg_t:
+			public expression_operators<avg_t<Flag, Expr>, floating_point>,
+			public alias_operators<avg_t<Flag, Expr>>
+	{
+		using _traits = make_traits<floating_point, tag::is_expression, tag::is_selectable>;
+		using _nodes = detail::type_vector<Expr, aggregate_function>;
+
+		static_assert(is_noop<Flag>::value or std::is_same<distinct_t, Flag>::value, "avg() used with flag other than 'distinct'");
+		static_assert(is_numeric_t<Expr>::value, "avg() requires a value expression as argument");
+
+		using _auto_alias_t = avg_alias_t;
 
 		avg_t(Expr expr):
 			_expr(expr)
diff --git a/include/sqlpp11/concat.h b/include/sqlpp11/concat.h
index d93cdf52..757b3d1e 100644
--- a/include/sqlpp11/concat.h
+++ b/include/sqlpp11/concat.h
@@ -37,14 +37,8 @@ namespace sqlpp
 {
 	struct text;
 
-	template<typename... Args>
-		struct concat_t: 
-			public expression_operators<concat_t<Args...>, text>,
-			public alias_operators<concat_t<Args...>>
+	struct concat_alias_t
 	{
-		using _traits = make_traits<text, tag::is_expression, tag::is_selectable>;
-		using _nodes = detail::type_vector<Args...>;
-
 		struct _alias_t
 		{
 			static constexpr const char _literal[] =  "concat_";
@@ -55,6 +49,17 @@ namespace sqlpp
 					T concat;
 				};
 		};
+	};
+
+	template<typename... Args>
+		struct concat_t: 
+			public expression_operators<concat_t<Args...>, text>,
+			public alias_operators<concat_t<Args...>>
+	{
+		using _traits = make_traits<text, tag::is_expression, tag::is_selectable>;
+		using _nodes = detail::type_vector<Args...>;
+
+		using _auto_alias_t = concat_alias_t;
 
 		concat_t(Args... args):
 			_args(args...)
diff --git a/include/sqlpp11/detail/copy_tuple_args.h b/include/sqlpp11/detail/copy_tuple_args.h
index fe0c9f4a..6aeeff88 100644
--- a/include/sqlpp11/detail/copy_tuple_args.h
+++ b/include/sqlpp11/detail/copy_tuple_args.h
@@ -28,7 +28,7 @@
 #define SQLPP_DETAIL_COPY_TUPLE_ARGS_H
 
 #include <tuple>
-#include <sqlpp11/alias.h>
+#include <sqlpp11/auto_alias.h>
 
 namespace sqlpp
 {
@@ -37,21 +37,6 @@ namespace sqlpp
 
 	namespace detail
 	{
-		template<typename T, typename Enable = void>
-			struct auto_alias_impl
-			{
-				using type = T;
-			};
-
-		template<typename T>
-			struct auto_alias_impl<T, typename std::enable_if<not wrong_t<typename T::_auto_alias_t>::value>::type>
-			{
-				using type = expression_alias_t<T, typename T::_auto_alias_t>;
-			};
-
-		template<typename T>
-			using auto_alias_t = typename detail::auto_alias_impl<T>::type;
-
 		template<typename T>
 			struct as_column_tuple
 			{
diff --git a/include/sqlpp11/exists.h b/include/sqlpp11/exists.h
index be72191f..1d14728e 100644
--- a/include/sqlpp11/exists.h
+++ b/include/sqlpp11/exists.h
@@ -32,16 +32,8 @@
 
 namespace sqlpp
 {
-	template<typename Select>
-		struct exists_t: 
-			public expression_operators<exists_t<Select>, boolean>,
-			public alias_operators<exists_t<Select>>
+	struct exists_alias_t
 	{
-		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-		using _nodes = detail::type_vector<Select>;
-
-		static_assert(is_select_t<Select>::value, "exists() requires a select expression as argument");
-
 		struct _alias_t
 		{
 			static constexpr const char _literal[] =  "exists_";
@@ -54,6 +46,19 @@ namespace sqlpp
 					const T& operator()() const { return exists; }
 				};
 		};
+	};
+
+	template<typename Select>
+		struct exists_t: 
+			public expression_operators<exists_t<Select>, boolean>,
+			public alias_operators<exists_t<Select>>
+	{
+		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
+		using _nodes = detail::type_vector<Select>;
+
+		static_assert(is_select_t<Select>::value, "exists() requires a select expression as argument");
+
+		using _auto_alias_t = exists_alias_t;
 
 		exists_t(Select select):
 			_select(select)
diff --git a/include/sqlpp11/functions.h b/include/sqlpp11/functions.h
index bc935e51..f2949276 100644
--- a/include/sqlpp11/functions.h
+++ b/include/sqlpp11/functions.h
@@ -34,7 +34,6 @@
 #include <sqlpp11/not_in.h>
 #include <sqlpp11/is_null.h>
 #include <sqlpp11/is_not_null.h>
-#include <sqlpp11/value_type.h>
 #include <sqlpp11/exists.h>
 #include <sqlpp11/any.h>
 #include <sqlpp11/concat.h>
@@ -44,6 +43,7 @@
 #include <sqlpp11/max.h>
 #include <sqlpp11/avg.h>
 #include <sqlpp11/sum.h>
+#include <sqlpp11/value_type.h>
 #include <sqlpp11/verbatim.h> // Csaba Csoma suggests: unsafe_sql instead of verbatim
 #include <sqlpp11/verbatim_table.h>
 #include <sqlpp11/value_or_null.h>
diff --git a/include/sqlpp11/in.h b/include/sqlpp11/in.h
index 0176e379..9628ee84 100644
--- a/include/sqlpp11/in.h
+++ b/include/sqlpp11/in.h
@@ -35,16 +35,8 @@
 
 namespace sqlpp
 {
-	template<typename Operand, typename... Args>
-		struct in_t:
-			public expression_operators<in_t<Operand, Args...>, boolean>,
-			public alias_operators<in_t<Operand, Args...>>
+	struct in_alias_t
 	{
-		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-		using _nodes = detail::type_vector<Operand, Args...>;
-
-		static_assert(sizeof...(Args) > 0, "in() requires at least one argument");
-
 		struct _alias_t
 		{
 			static constexpr const char _literal[] =  "in_";
@@ -55,6 +47,19 @@ namespace sqlpp
 					T in;
 				};
 		};
+	};
+
+	template<typename Operand, typename... Args>
+		struct in_t:
+			public expression_operators<in_t<Operand, Args...>, boolean>,
+			public alias_operators<in_t<Operand, Args...>>
+	{
+		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
+		using _nodes = detail::type_vector<Operand, Args...>;
+
+		static_assert(sizeof...(Args) > 0, "in() requires at least one argument");
+
+		using _auto_alias_t = in_alias_t;
 
 		in_t(Operand operand, Args... args):
 			_operand(operand),
diff --git a/include/sqlpp11/is_not_null.h b/include/sqlpp11/is_not_null.h
index 78e49123..e124b8e4 100644
--- a/include/sqlpp11/is_not_null.h
+++ b/include/sqlpp11/is_not_null.h
@@ -34,14 +34,8 @@
 
 namespace sqlpp
 {
-	template<typename Operand>
-		struct is_not_null_t:
-			public expression_operators<is_not_null_t<Operand>, boolean>,
-			public alias_operators<is_not_null_t<Operand>>
+	struct is_not_null_alias_t
 	{
-		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-		using _nodes = detail::type_vector<Operand>;
-
 		struct _alias_t
 		{
 			static constexpr const char _literal[] =  "is_not_null_";
@@ -52,6 +46,17 @@ namespace sqlpp
 					T is_not_null;
 				};
 		};
+	};
+
+	template<typename Operand>
+		struct is_not_null_t:
+			public expression_operators<is_not_null_t<Operand>, boolean>,
+			public alias_operators<is_not_null_t<Operand>>
+	{
+		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
+		using _nodes = detail::type_vector<Operand>;
+
+		using _auto_alias_t = is_not_null_alias_t;
 
 		is_not_null_t(Operand operand):
 			_operand(operand)
diff --git a/include/sqlpp11/is_null.h b/include/sqlpp11/is_null.h
index 0a798067..6bddbf6a 100644
--- a/include/sqlpp11/is_null.h
+++ b/include/sqlpp11/is_null.h
@@ -34,6 +34,20 @@
 
 namespace sqlpp
 {
+	struct is_null_alias_t
+	{
+		struct _alias_t
+		{
+			static constexpr const char _literal[] =  "is_null_";
+			using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
+			template<typename T>
+				struct _member_t
+				{
+					T is_null;
+				};
+		};
+	};
+
 	template<typename Operand>
 		struct is_null_t:
 			public expression_operators<is_null_t<Operand>, boolean>,
@@ -42,16 +56,7 @@ namespace sqlpp
 		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
 		using _nodes = detail::type_vector<Operand>;
 
-		struct _alias_t
-		{
-			static constexpr const char _literal[] =  "is_nnull_";
-			using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
-			template<typename T>
-				struct _member_t
-				{
-					T is_null;
-				};
-		};
+		using _auto_alias_t = is_null_alias_t;
 
 		is_null_t(Operand operand):
 			_operand(operand)
diff --git a/include/sqlpp11/max.h b/include/sqlpp11/max.h
index f2011988..7516d927 100644
--- a/include/sqlpp11/max.h
+++ b/include/sqlpp11/max.h
@@ -32,14 +32,8 @@
 
 namespace sqlpp
 {
-	template<typename Expr>
-		struct max_t:
-			public expression_operators<max_t<Expr>, value_type_of<Expr>>,
-			public alias_operators<max_t<Expr>>
+	struct max_alias_t
 	{
-		using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
-		using _nodes = detail::type_vector<Expr, aggregate_function>;
-
 		struct _alias_t
 		{
 			static constexpr const char _literal[] =  "max_";
@@ -52,6 +46,17 @@ namespace sqlpp
 					const T& operator()() const { return max; }
 				};
 		};
+	};
+
+	template<typename Expr>
+		struct max_t:
+			public expression_operators<max_t<Expr>, value_type_of<Expr>>,
+			public alias_operators<max_t<Expr>>
+	{
+		using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
+		using _nodes = detail::type_vector<Expr, aggregate_function>;
+
+		using _auto_alias_t = max_alias_t;
 
 		max_t(Expr expr):
 			_expr(expr)
diff --git a/include/sqlpp11/min.h b/include/sqlpp11/min.h
index 7f885c07..3bead069 100644
--- a/include/sqlpp11/min.h
+++ b/include/sqlpp11/min.h
@@ -32,14 +32,8 @@
 
 namespace sqlpp
 {
-	template<typename Expr>
-		struct min_t:
-			public expression_operators<min_t<Expr>, value_type_of<Expr>>,
-			public alias_operators<min_t<Expr>>
+	struct min_alias_t
 	{
-		using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
-		using _nodes = detail::type_vector<Expr, aggregate_function>;
-
 		struct _alias_t
 		{
 			static constexpr const char _literal[] =  "min_";
@@ -52,6 +46,17 @@ namespace sqlpp
 					const T& operator()() const { return min; }
 				};
 		};
+	};
+
+	template<typename Expr>
+		struct min_t:
+			public expression_operators<min_t<Expr>, value_type_of<Expr>>,
+			public alias_operators<min_t<Expr>>
+	{
+		using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
+		using _nodes = detail::type_vector<Expr, aggregate_function>;
+
+		using _auto_alias_t = min_alias_t;
 
 		min_t(Expr expr):
 			_expr(expr)
diff --git a/include/sqlpp11/not_in.h b/include/sqlpp11/not_in.h
index cddfc119..c42edc70 100644
--- a/include/sqlpp11/not_in.h
+++ b/include/sqlpp11/not_in.h
@@ -35,6 +35,20 @@
 
 namespace sqlpp
 {
+	struct not_in_alias_t
+	{
+		struct _alias_t
+		{
+			static constexpr const char _literal[] =  "not_in_";
+			using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
+			template<typename T>
+				struct _member_t
+				{
+					T in;
+				};
+		};
+	};
+
 	template<typename Operand, typename... Args>
 		struct not_in_t:
 			public expression_operators<not_in_t<Operand, Args...>, boolean>,
@@ -45,16 +59,7 @@ namespace sqlpp
 
 		static_assert(sizeof...(Args) > 0, "not_in() requires at least one argument");
 
-		struct _alias_t
-		{
-			static constexpr const char _literal[] =  "not_in_";
-			using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
-			template<typename T>
-				struct _member_t
-				{
-					T not_in;
-				};
-		};
+		using _auto_alias_t = not_in_alias_t;
 
 		not_in_t(Operand operand, Args... args):
 			_operand(operand),
diff --git a/include/sqlpp11/select_column_list.h b/include/sqlpp11/select_column_list.h
index 8389859e..9d73be09 100644
--- a/include/sqlpp11/select_column_list.h
+++ b/include/sqlpp11/select_column_list.h
@@ -188,7 +188,7 @@ namespace sqlpp
 					template<typename NamedExpression, typename TableCheckRequired = std::true_type>
 						void add(NamedExpression namedExpression)
 						{
-							using named_expression = detail::auto_alias_t<NamedExpression>;
+							using named_expression = auto_alias_t<NamedExpression>;
 							static_assert(_is_dynamic::value, "selected_columns::add() can only be called for dynamic_column");
 							static_assert(is_selectable_t<named_expression>::value, "invalid named expression argument in selected_columns::add()");
 							static_assert(TableCheckRequired::value or Policies::template _no_unknown_tables<named_expression>::value, "named expression uses tables unknown to this statement in selected_columns::add()");
@@ -210,7 +210,7 @@ namespace sqlpp
 					template<typename NamedExpression>
 						void _add_impl(NamedExpression namedExpression, const std::true_type&)
 						{
-							return _data._dynamic_columns.emplace_back(detail::auto_alias_t<NamedExpression>{namedExpression});
+							return _data._dynamic_columns.emplace_back(auto_alias_t<NamedExpression>{namedExpression});
 						}
 
 					template<typename NamedExpression>
diff --git a/include/sqlpp11/some.h b/include/sqlpp11/some.h
index 1800e974..272530b5 100644
--- a/include/sqlpp11/some.h
+++ b/include/sqlpp11/some.h
@@ -39,19 +39,6 @@ namespace sqlpp
 			using _traits = make_traits<value_type_of<Select>, tag::is_multi_expression>;
 			using _nodes = detail::type_vector<Select>;
 
-			struct _alias_t
-			{
-        static constexpr const char _literal[] =  "some_";
-        using _name_t = sqlpp::make_char_sequence<sizeof(_literal), _literal>;
-				template<typename T>
-					struct _member_t
-					{
-						T some;
-						T& operator()() { return some; }
-						const T& operator()() const { return some; }
-					};
-			};
-
 			some_t(Select select):
 				_select(select)
 			{}
diff --git a/include/sqlpp11/sum.h b/include/sqlpp11/sum.h
index b766d2e3..0211706b 100644
--- a/include/sqlpp11/sum.h
+++ b/include/sqlpp11/sum.h
@@ -32,17 +32,8 @@
 
 namespace sqlpp
 {
-	template<typename Flag, typename Expr>
-		struct sum_t:
-			public expression_operators<sum_t<Flag, Expr>, value_type_of<Expr>>,
-			public alias_operators<sum_t<Flag, Expr>>
+	struct sum_alias_t
 	{
-		using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
-		using _nodes = detail::type_vector<Expr, aggregate_function>;
-
-		static_assert(is_noop<Flag>::value or std::is_same<distinct_t, Flag>::value, "sum() used with flag other than 'distinct'");
-		static_assert(is_numeric_t<Expr>::value, "sum() requires a numeric expression as argument");
-
 		struct _alias_t
 		{
 			static constexpr const char _literal[] =  "sum_";
@@ -55,6 +46,20 @@ namespace sqlpp
 					const T& operator()() const { return sum; }
 				};
 		};
+	};
+
+	template<typename Flag, typename Expr>
+		struct sum_t:
+			public expression_operators<sum_t<Flag, Expr>, value_type_of<Expr>>,
+			public alias_operators<sum_t<Flag, Expr>>
+	{
+		using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
+		using _nodes = detail::type_vector<Expr, aggregate_function>;
+
+		static_assert(is_noop<Flag>::value or std::is_same<distinct_t, Flag>::value, "sum() used with flag other than 'distinct'");
+		static_assert(is_numeric_t<Expr>::value, "sum() requires a numeric expression as argument");
+
+		using _auto_alias_t = sum_alias_t;
 
 		sum_t(Expr expr):
 			_expr(expr)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index c2022160..66ba4a0f 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -30,20 +30,20 @@ target_compile_options(sqlpp11_testing INTERFACE -Wall -Wextra -pedantic)
 endif ()
 
 set(test_names
-  #BooleanExpression
-  #CustomQuery
-  #Interpret
-  #Insert
-  #Remove
-  #Update
+  BooleanExpression
+  CustomQuery
+  Interpret
+  Insert
+  Remove
+  Update
   Select
-  #SelectType
-  #Function
-  #Prepared
-  #Minimalistic
-  #Result
-  #Union
-  #With
+  SelectType
+  Function
+  Prepared
+  Minimalistic
+  Result
+  Union
+  With
   )
 
 create_test_sourcelist(test_sources test_main.cpp ${test_names})
diff --git a/tests/Function.cpp b/tests/Function.cpp
index ac62a789..1956257a 100644
--- a/tests/Function.cpp
+++ b/tests/Function.cpp
@@ -25,6 +25,7 @@
 
 #include "Sample.h"
 #include "MockDb.h"
+#include <sqlpp11/auto_alias.h>
 #include <sqlpp11/alias_provider.h>
 #include <sqlpp11/select.h>
 #include <sqlpp11/functions.h>
@@ -256,11 +257,11 @@ int Function(int, char**)
 	{
 		using TI = decltype(avg(t.alpha));
 		using TF = decltype(avg(f.omega));
-		static_assert(sqlpp::is_selectable_t<TI>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TI>::value, "type requirement");
 		static_assert(sqlpp::is_numeric_t<TI>::value, "type requirement");
 		static_assert(not sqlpp::is_integral_t<TI>::value, "type requirement");
 		static_assert(sqlpp::is_floating_point_t<TI>::value, "type requirement");
-		static_assert(sqlpp::is_selectable_t<TF>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TF>::value, "type requirement");
 		static_assert(sqlpp::is_numeric_t<TF>::value, "type requirement");
 		static_assert(not sqlpp::is_integral_t<TF>::value, "type requirement");
 		static_assert(sqlpp::is_floating_point_t<TF>::value, "type requirement");
@@ -271,15 +272,15 @@ int Function(int, char**)
 		using TI = decltype(count(t.alpha));
 		using TT = decltype(count(t.beta));
 		using TF = decltype(count(f.omega));
-		static_assert(sqlpp::is_selectable_t<TI>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TI>::value, "type requirement");
 		static_assert(sqlpp::is_numeric_t<TI>::value, "type requirement");
 		static_assert(sqlpp::is_integral_t<TI>::value, "type requirement");
 		static_assert(not sqlpp::is_floating_point_t<TI>::value, "type requirement");
-		static_assert(sqlpp::is_selectable_t<TF>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TF>::value, "type requirement");
 		static_assert(sqlpp::is_numeric_t<TF>::value, "type requirement");
 		static_assert(sqlpp::is_integral_t<TF>::value, "type requirement");
 		static_assert(not sqlpp::is_floating_point_t<TF>::value, "type requirement");
-		static_assert(sqlpp::is_selectable_t<TT>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TT>::value, "type requirement");
 		static_assert(sqlpp::is_numeric_t<TT>::value, "type requirement");
 		static_assert(sqlpp::is_integral_t<TT>::value, "type requirement");
 		static_assert(not sqlpp::is_floating_point_t<TT>::value, "type requirement");
@@ -292,15 +293,15 @@ int Function(int, char**)
 		using TI = decltype(max(t.alpha));
 		using TF = decltype(max(f.omega));
 		using TT = decltype(max(t.beta));
-		static_assert(sqlpp::is_selectable_t<TI>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TI>::value, "type requirement");
 		static_assert(sqlpp::is_numeric_t<TI>::value, "type requirement");
 		static_assert(sqlpp::is_integral_t<TI>::value, "type requirement");
 		static_assert(not sqlpp::is_floating_point_t<TI>::value, "type requirement");
-		static_assert(sqlpp::is_selectable_t<TF>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TF>::value, "type requirement");
 		static_assert(sqlpp::is_numeric_t<TF>::value, "type requirement");
 		static_assert(not sqlpp::is_integral_t<TF>::value, "type requirement");
 		static_assert(sqlpp::is_floating_point_t<TF>::value, "type requirement");
-		static_assert(sqlpp::is_selectable_t<TT>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TT>::value, "type requirement");
 		static_assert(not sqlpp::is_numeric_t<TT>::value, "type requirement");
 		static_assert(sqlpp::is_text_t<TT>::value, "type requirement");
 	}
@@ -310,7 +311,7 @@ int Function(int, char**)
 		using TI = decltype(min(t.alpha));
 		using TF = decltype(min(f.omega));
 		using TT = decltype(min(t.beta));
-		static_assert(sqlpp::is_selectable_t<TI>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TI>::value, "type requirement");
 		static_assert(sqlpp::is_numeric_t<TI>::value, "type requirement");
 		static_assert(sqlpp::is_integral_t<TI>::value, "type requirement");
 		static_assert(not sqlpp::is_floating_point_t<TI>::value, "type requirement");
@@ -327,7 +328,7 @@ int Function(int, char**)
 	{
 		using TI = decltype(sum(t.alpha));
 		using TF = decltype(sum(f.omega));
-		static_assert(sqlpp::is_selectable_t<TF>::value, "type requirement");
+		static_assert(sqlpp::has_auto_alias_t<TF>::value, "type requirement");
 		static_assert(sqlpp::is_numeric_t<TI>::value, "type requirement");
 		static_assert(sqlpp::is_integral_t<TI>::value, "type requirement");
 		static_assert(not sqlpp::is_floating_point_t<TI>::value, "type requirement");