Merge branch 'feature/recursive_traits' into develop

include/sqlpp11/alias.h

@@ -36,7 +36,7 @@ namespace sqlpp
 		struct expression_alias_t
 		{
 			using _traits = make_traits<value_type_of<Expression>, tag::is_selectable, tag::is_alias>;
-			using _recursive_traits = make_recursive_traits<Expression>;
+			using _nodes = detail::type_vector<Expression>;
 
 			static_assert(is_expression_t<Expression>::value, "invalid argument for an expression alias");
 			static_assert(not is_alias_t<Expression>::value, "cannot create an alias of an alias");

include/sqlpp11/any.h

@@ -37,7 +37,7 @@ namespace sqlpp
 		struct any_t
 		{
 			using _traits = make_traits<value_type_of<Select>, tag::is_multi_expression>;
-			using _recursive_traits = make_recursive_traits<Select>;
+			using _nodes = detail::type_vector<Select>;
 
 			struct _alias_t
 			{

include/sqlpp11/assignment.h

@@ -41,7 +41,7 @@ namespace sqlpp
 		struct assignment_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_assignment>;
-			using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
+			using _nodes = detail::type_vector<Lhs, Rhs>;
 
 			using _lhs_t = Lhs;
 			using _rhs_t = rhs_wrap_t<allow_tvin_t<Rhs>, trivial_value_is_null_t<_lhs_t>::value>;

include/sqlpp11/avg.h

@@ -38,7 +38,7 @@ namespace sqlpp
 			public alias_operators<avg_t<Flag, Expr>>
 	{
 		using _traits = make_traits<floating_point, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Expr, aggregate_function>;
+		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");

include/sqlpp11/boolean_expression.h

@@ -36,7 +36,7 @@ namespace sqlpp
 		struct boolean_expression_t: public expression_operators<boolean_expression_t<Database>, boolean>
 		{
 			using _traits = make_traits<boolean, tag::is_expression>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			template<typename Expr>
 			boolean_expression_t(Expr expr):

include/sqlpp11/column.h

@@ -52,19 +52,9 @@ namespace sqlpp
 			using _tags = detail::make_joined_set_t<detail::type_set<tag::is_column, tag::is_expression, tag::is_selectable>, typename ColumnSpec::_traits::_tags>;
 		};
 
-		struct _recursive_traits
+		using _nodes = detail::type_vector<>;
-		{
+		using _required_tables = detail::type_set<Table>;
-			using _required_ctes = detail::type_set<>;
+		using _can_be_null = column_spec_can_be_null_t<ColumnSpec>;
-			using _provided_ctes = detail::type_set<>;
-			using _required_tables = detail::type_set<Table>;
-			using _provided_tables = detail::type_set<>;
-			using _provided_outer_tables = detail::type_set<>;
-			using _extra_tables = detail::type_set<>;
-			using _parameters = std::tuple<>;
-			using _tags = typename std::conditional<column_spec_can_be_null_t<ColumnSpec>::value,
-									detail::type_set<tag::can_be_null>,
-									detail::type_set<>>::type;
-		};
 
 		using _spec_t = ColumnSpec;
 		using _table = Table;

include/sqlpp11/concat.h

@@ -42,7 +42,7 @@ namespace sqlpp
 			public alias_operators<concat_t<First, Args...>>
 	{
 		using _traits = make_traits<value_type_of<First>, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<First, Args...>;
+		using _nodes = detail::type_vector<First, Args...>;
 
 		static_assert(sizeof...(Args) > 0, "concat requires two arguments at least");
 		static_assert(logic::all_t<is_text_t<First>::value, is_text_t<Args>::value...>::value, "at least one non-text argument detected in concat()");

include/sqlpp11/count.h

@@ -39,19 +39,9 @@ namespace sqlpp
 			public alias_operators<count_t<Flag, Expr>>
 	{
 		using _traits = make_traits<integral, tag::is_expression, tag::is_selectable>;
-		struct _recursive_traits
-		{
-			using _required_ctes = required_ctes_of<Expr>;
-			using _provided_ctes = detail::type_set<>;
-			using _required_tables = required_tables_of<Expr>;
-			using _provided_tables = provided_tables_of<Expr>;
-			using _provided_outer_tables = provided_outer_tables_of<Expr>;
-			using _extra_tables = extra_tables_of<Expr>;
-			using _parameters = parameters_of<Expr>;
-			using _tags = detail::make_difference_set_t<detail::joined_set_t<recursive_tags_of<Expr>, recursive_tags_of<aggregate_function>>, 
-						                                      detail::type_set<tag::can_be_null>>;
-		};
 
+		using _nodes = detail::type_vector<Expr, aggregate_function>;
+		using _can_be_null = std::false_type;
 
 		static_assert(is_noop<Flag>::value or std::is_same<distinct_t, Flag>::value, "count() used with flag other than 'distinct'");
 
@@ -108,6 +98,7 @@ namespace sqlpp
 	template<typename T>
 		auto count(T t) -> count_t<noop, wrap_operand_t<T>>
 		{
+			static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, "count() cannot be used on an aggregate function");
 			static_assert(is_expression_t<wrap_operand_t<T>>::value, "count() requires an expression as argument");
 			return { t };
 		}
@@ -115,6 +106,7 @@ namespace sqlpp
 	template<typename T>
 		auto count(const distinct_t&, T t) -> count_t<distinct_t, wrap_operand_t<T>>
 		{
+			static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, "count() cannot be used on an aggregate function");
 			static_assert(is_expression_t<wrap_operand_t<T>>::value, "count() requires an expression as argument");
 			return { t };
 		}

include/sqlpp11/cte.h

@@ -43,17 +43,9 @@ namespace sqlpp
 	template<typename Flag, typename Lhs, typename Rhs>
 		struct cte_union_t
 		{
-			struct _recursive_traits
+			using _nodes = detail::type_vector<>;
-			{
+			using _required_ctes = detail::make_joined_set_t<required_ctes_of<Lhs>, required_ctes_of<Rhs>>;
-				using _required_ctes = detail::make_joined_set_t<required_ctes_of<Lhs>, required_ctes_of<Rhs>>;
+			using _parameters = detail::type_vector_cat_t<parameters_of<Lhs>, parameters_of<Rhs>>;
-				using _provided_ctes = detail::type_set<>;
-				using _required_tables = detail::type_set<>;
-				using _provided_tables = detail::type_set<>;
-				using _provided_outer_tables = detail::type_set<>;
-				using _extra_tables = detail::type_set<>;
-				using _parameters = detail::make_parameter_tuple_t<parameters_of<Lhs>, parameters_of<Rhs>>;
-				using _tags = detail::type_set<>;
-			};
 
 			cte_union_t(Lhs lhs, Rhs rhs):
 				_lhs(lhs),
@@ -140,17 +132,10 @@ namespace sqlpp
 		struct cte_t: public member_t<cte_column_spec_t<FieldSpecs>, column_t<AliasProvider, cte_column_spec_t<FieldSpecs>>>...
 		{
 			using _traits = make_traits<no_value_t, tag::is_cte, tag::is_table>; // FIXME: is table? really?
-			struct _recursive_traits
+			using _nodes = detail::type_vector<>;
-			{
+			using _required_ctes = detail::make_joined_set_t<required_ctes_of<Statement>, detail::type_set<AliasProvider>>;
-				using _required_ctes = detail::make_joined_set_t<required_ctes_of<Statement>, detail::type_set<AliasProvider>>;
+			using _parameters = parameters_of<Statement>;
-				using _provided_ctes = detail::type_set<>;
+
-				using _required_tables = detail::type_set<>;
-				using _provided_tables = detail::type_set<>;
-				using _provided_outer_tables = detail::type_set<>;
-				using _extra_tables = detail::type_set<>;
-				using _parameters = parameters_of<Statement>;
-				using _tags = detail::type_set<>;
-			};
 			using _alias_t = typename AliasProvider::_alias_t;
 			constexpr static bool _is_recursive = detail::is_element_of<AliasProvider, required_ctes_of<Statement>>::value;
 
@@ -235,17 +220,9 @@ namespace sqlpp
 		struct cte_ref_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_alias, tag::is_cte, tag::is_table>; // FIXME: is table? really?
-			struct _recursive_traits
+			using _nodes = detail::type_vector<>;
-			{
+			using _required_ctes = detail::make_type_set_t<AliasProvider>;
-				using _required_ctes = detail::make_type_set_t<AliasProvider>;
+			using _provided_tables = detail::type_set<AliasProvider>;
-				using _provided_ctes = detail::type_set<>;
-				using _required_tables = detail::type_set<>;
-				using _provided_tables = detail::type_set<AliasProvider>;
-				using _provided_outer_tables = detail::type_set<>;
-				using _extra_tables = detail::type_set<>;
-				using _parameters = std::tuple<>;
-				using _tags = detail::type_set<>;
-			};
 
 			using _alias_t = typename AliasProvider::_alias_t;
 

include/sqlpp11/custom_query.h

@@ -54,9 +54,9 @@ namespace sqlpp
 	{
 		using _methods_t = typename detail::custom_parts_t<Database, Parts...>::_result_methods_t;
 		using _traits = make_traits<no_value_t, tag::is_statement>;
-		using _recursive_traits = make_recursive_traits<Parts...>;
+		using _nodes = detail::type_vector<Parts...>;
 
-		using _parameter_check = typename std::conditional<std::tuple_size<typename _recursive_traits::_parameters>::value == 0,
+		using _parameter_check = typename std::conditional<detail::type_vector_size<parameters_of<custom_query_t>>::value == 0,
 					consistent_t, assert_no_parameters_t>::type;
 		using _run_check = detail::get_first_if<is_inconsistent_t, consistent_t, 
 					_parameter_check>;

include/sqlpp11/default_value.h

@@ -34,7 +34,7 @@ namespace sqlpp
 	struct default_value_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_expression>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		static constexpr bool _is_trivial() { return false; }
 	};

include/sqlpp11/detail/type_vector.h

@@ -0,0 +1,88 @@
+/*
+ * 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_DETAIL_TYPE_VECTOR_H
+#define SQLPP_DETAIL_TYPE_VECTOR_H
+
+#include <sqlpp11/wrong.h>
+
+namespace sqlpp
+{
+	namespace detail
+	{
+		template<typename... T>
+			struct type_vector
+			{};
+
+		template<typename...T>
+			struct type_vector_cat_impl
+			{
+				static_assert(wrong_t<type_vector_cat_impl>::value, "type_vector_cat must be called with type_vector arguments");
+			};
+
+		template<>
+			struct type_vector_cat_impl<>
+			{
+				using type = type_vector<>;
+			};
+
+		template<typename... T>
+			struct type_vector_cat_impl<type_vector<T...>>
+			{
+				using type = type_vector<T...>;
+			};
+
+		template<typename... L, typename... R>
+			struct type_vector_cat_impl<type_vector<L...>, type_vector<R...>>
+			{
+				using type = type_vector<L..., R...>;
+			};
+
+		template<typename... L, typename... Rest>
+			struct type_vector_cat_impl<type_vector<L...>, Rest...>
+			{
+				using type = typename type_vector_cat_impl<type_vector<L...>, typename type_vector_cat_impl<Rest...>::type>::type;
+			};
+
+		template<typename... T>
+			using type_vector_cat_t = typename type_vector_cat_impl<T...>::type;
+
+		template<typename T>
+			struct type_vector_size
+			{
+				static_assert(wrong_t<type_vector_size>::value, "type_vector_size needs to be called with a type_vector argument");
+			};
+
+		template<typename... T>
+			struct type_vector_size<type_vector<T...>>
+			{
+				static constexpr std::size_t value = sizeof...(T);
+			};
+	}
+}
+
+
+#endif

include/sqlpp11/exists.h

@@ -38,7 +38,7 @@ namespace sqlpp
 			public alias_operators<exists_t<Select>>
 	{
 		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Select>;
+		using _nodes = detail::type_vector<Select>;
 
 		static_assert(is_select_t<Select>::value, "exists() requires a select expression as argument");
 

include/sqlpp11/expression.h

@@ -44,7 +44,7 @@ namespace sqlpp
 			public alias_operators<binary_expression_t<Lhs, op::equal_to, Rhs>>
 		{
 			using _traits = make_traits<boolean, tag::is_expression>;
-			using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
+			using _nodes = detail::type_vector<Lhs, Rhs>;
 			using _lhs_t = Lhs;
 			using _rhs_t = rhs_wrap_t<allow_tvin_t<Rhs>, trivial_value_is_null_t<_lhs_t>::value>;
 
@@ -93,7 +93,7 @@ namespace sqlpp
 			public alias_operators<binary_expression_t<Lhs, op::not_equal_to, Rhs>>
 		{
 			using _traits = make_traits<boolean, tag::is_expression>;
-			using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
+			using _nodes = detail::type_vector<Lhs, Rhs>;
 			using _lhs_t = Lhs;
 			using _rhs_t = rhs_wrap_t<allow_tvin_t<Rhs>, trivial_value_is_null_t<_lhs_t>::value>;
 
@@ -142,7 +142,7 @@ namespace sqlpp
 			public alias_operators<unary_expression_t<op::logical_not, Rhs>>
 		{
 			using _traits = make_traits<boolean, tag::is_expression>;
-			using _recursive_traits = make_recursive_traits<Rhs>;
+			using _nodes = detail::type_vector<Rhs>;
 
 			unary_expression_t(Rhs rhs):
 				_rhs(rhs)
@@ -188,7 +188,7 @@ namespace sqlpp
 			public alias_operators<binary_expression_t<Lhs, O, Rhs>>
 	{
 		using _traits = make_traits<value_type_of<O>, tag::is_expression>;
-		using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
+		using _nodes = detail::type_vector<Lhs, Rhs>;
 
 		binary_expression_t(Lhs lhs, Rhs rhs):
 			_lhs(lhs), 
@@ -228,7 +228,7 @@ namespace sqlpp
 			public alias_operators<unary_expression_t<O, Rhs>>
 	{
 		using _traits = make_traits<value_type_of<O>, tag::is_expression>;
-		using _recursive_traits = make_recursive_traits<Rhs>;
+		using _nodes = detail::type_vector<Rhs>;
 
 		unary_expression_t(Rhs rhs):
 			_rhs(rhs)

include/sqlpp11/extra_tables.h

@@ -52,17 +52,9 @@ namespace sqlpp
 		struct extra_tables_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_extra_tables>;
-			struct _recursive_traits
+			using _nodes = detail::type_vector<>;
-			{
+			using _required_ctes = detail::make_joined_set_t<required_ctes_of<Tables>...>;
-				using _required_ctes = detail::make_joined_set_t<required_ctes_of<Tables>...>;
+			using _extra_tables = detail::type_set<Tables...>;
-				using _provided_ctes = detail::type_set<>;
-				using _required_tables = detail::type_set<>;
-				using _provided_outer_tables = detail::type_set<>;
-				using _provided_tables = detail::type_set<>;
-				using _extra_tables = detail::type_set<Tables...>;
-				using _parameters = std::tuple<>;
-				using _tags = detail::type_set<>;
-			};
 
 			// Data
 			using _data_t = extra_tables_data_t<Tables...>;
@@ -98,7 +90,7 @@ namespace sqlpp
 	struct no_extra_tables_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/field_spec.h

@@ -38,7 +38,7 @@ namespace sqlpp
 						tag_if<tag::can_be_null, CanBeNull>,
 						tag_if<tag::null_is_trivial_value, NullIsTrivialValue>
 							>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			using _alias_t = NameType;
 		};

include/sqlpp11/from.h

@@ -61,7 +61,7 @@ namespace sqlpp
 		struct from_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_from>;
-			using _recursive_traits = make_recursive_traits<Tables...>;
+			using _nodes = detail::type_vector<Tables...>;
 			using _is_dynamic = is_database<Database>;
 
 			// Data
@@ -125,7 +125,7 @@ namespace sqlpp
 	struct no_from_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/functions.h

@@ -82,7 +82,7 @@ namespace sqlpp
 		struct value_list_t // to be used in .in() method
 		{
 			using _traits = make_traits<value_type_t<typename Container::value_type>, tag::is_expression>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			using _container_t = Container;
 

include/sqlpp11/group_by.h

@@ -71,7 +71,7 @@ namespace sqlpp
 		struct group_by_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_group_by>;
-			using _recursive_traits = make_recursive_traits<Expressions...>;
+			using _nodes = detail::type_vector<Expressions...>;
 
 			using _is_dynamic = is_database<Database>;
 
@@ -141,7 +141,7 @@ namespace sqlpp
 	struct no_group_by_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/having.h

@@ -70,7 +70,7 @@ namespace sqlpp
 		struct having_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_having>;
-			using _recursive_traits = make_recursive_traits<Expressions...>;
+			using _nodes = detail::type_vector<Expressions...>;
 
 			using _is_dynamic = is_database<Database>;
 
@@ -141,7 +141,7 @@ namespace sqlpp
 	struct no_having_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/in.h

@@ -41,7 +41,7 @@ namespace sqlpp
 			public alias_operators<in_t<Operand, Args...>>
 	{
 		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Operand, Args...>;
+		using _nodes = detail::type_vector<Operand, Args...>;
 
 		static_assert(sizeof...(Args) > 0, "in() requires at least one argument");
 

include/sqlpp11/insert_value.h

@@ -50,7 +50,7 @@ namespace sqlpp
 				struct type
 				{
 					using _traits = make_traits<no_value_t, tag::is_noop>;
-					using _recursive_traits = make_recursive_traits<>;
+					using _nodes = detail::type_vector<>;
 				};
 			};
 	}

include/sqlpp11/insert_value_list.h

@@ -64,7 +64,7 @@ namespace sqlpp
 	struct insert_default_values_t
 	{
 		using _traits = make_traits<no_value_t>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = insert_default_values_data_t;
@@ -133,7 +133,7 @@ namespace sqlpp
 		struct insert_list_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_insert_list>;
-			using _recursive_traits = make_recursive_traits<lhs_t<Assignments>..., rhs_t<Assignments>...>;
+			using _nodes = detail::type_vector<lhs_t<Assignments>..., rhs_t<Assignments>...>;
 
 			using _is_dynamic = is_database<Database>;
 
@@ -245,7 +245,7 @@ namespace sqlpp
 		struct column_list_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_column_list>;
-			using _recursive_traits = make_recursive_traits<Columns...>;
+			using _nodes = detail::type_vector<Columns...>;
 
 			using _value_tuple_t = typename column_list_data_t<Columns...>::_value_tuple_t;
 
@@ -322,7 +322,7 @@ namespace sqlpp
 	struct no_insert_value_list_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/into.h

@@ -59,7 +59,7 @@ namespace sqlpp
 		struct into_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_into>;
-			using _recursive_traits = make_recursive_traits<Table>;
+			using _nodes = detail::type_vector<Table>;
 
 			using _data_t = into_data_t<Database, Table>;
 
@@ -108,7 +108,7 @@ namespace sqlpp
 	struct no_into_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/is_not_null.h

@@ -40,7 +40,7 @@ namespace sqlpp
 			public alias_operators<is_not_null_t<Operand>>
 	{
 		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Operand>;
+		using _nodes = detail::type_vector<Operand>;
 
 		struct _alias_t
 		{

include/sqlpp11/is_null.h

@@ -40,7 +40,7 @@ namespace sqlpp
 			public alias_operators<is_null_t<Operand>>
 	{
 		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Operand>;
+		using _nodes = detail::type_vector<Operand>;
 
 		struct _alias_t
 		{

include/sqlpp11/join.h

@@ -66,18 +66,8 @@ namespace sqlpp
 		struct join_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_table, tag::is_join>;
-			struct _recursive_traits
+			using _nodes = detail::type_vector<Lhs, Rhs>;
-			{
+			using _can_be_null = std::false_type;
-				using _required_ctes = detail::make_joined_set_t<required_ctes_of<Lhs>, required_ctes_of<Rhs>>;
-				using _provided_ctes = detail::type_set<>;
-				using _required_tables = detail::make_joined_set_t<required_tables_of<Lhs>, required_tables_of<Rhs>>;
-				using _provided_tables = detail::make_joined_set_t<provided_tables_of<Lhs>, provided_tables_of<Rhs>>;
-				using _provided_outer_tables = typename JoinType::template _provided_outer_tables<Lhs, Rhs>;
-				using _extra_tables = detail::make_joined_set_t<extra_tables_of<Lhs>, extra_tables_of<Rhs>>;
-				using _parameters = detail::make_parameter_tuple_t<parameters_of<Lhs>, parameters_of<Rhs>>;
-				using _tags = detail::type_set<>;
-			};
-
 
 			static_assert(is_table_t<Lhs>::value, "lhs argument for join() has to be a table or join");
 			static_assert(is_table_t<Rhs>::value, "rhs argument for join() has to be a table");
@@ -86,7 +76,7 @@ namespace sqlpp
 
 			static_assert(detail::is_disjunct_from<provided_tables_of<Lhs>, provided_tables_of<Rhs>>::value, "joined tables must not be identical");
 
-			static_assert(_recursive_traits::_required_tables::size::value == 0, "joined tables must not depend on other tables");
+			static_assert(required_tables_of<join_t>::size::value == 0, "joined tables must not depend on other tables");
 
 			template<typename OnT> 
 				using set_on_t = join_t<JoinType, Lhs, Rhs, OnT>;

include/sqlpp11/like.h

@@ -40,7 +40,7 @@ namespace sqlpp
 			public alias_operators<like_t<Operand, Pattern>>
 	{
 		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Operand, Pattern>;
+		using _nodes = detail::type_vector<Operand, Pattern>;
 
 		struct _alias_t
 		{

include/sqlpp11/limit.h

@@ -55,7 +55,7 @@ namespace sqlpp
 		struct limit_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_limit>;
-			using _recursive_traits = make_recursive_traits<Limit>;
+			using _nodes = detail::type_vector<Limit>;
 
 			// Data
 			using _data_t = limit_data_t<Limit>;
@@ -118,7 +118,7 @@ namespace sqlpp
 		struct dynamic_limit_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_limit>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			// Data
 			using _data_t = dynamic_limit_data_t<Database>;
@@ -163,7 +163,7 @@ namespace sqlpp
 	struct no_limit_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/max.h

@@ -38,7 +38,7 @@ namespace sqlpp
 			public alias_operators<max_t<Expr>>
 	{
 		using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Expr, aggregate_function>;
+		using _nodes = detail::type_vector<Expr, aggregate_function>;
 
 		struct _alias_t
 		{
@@ -84,6 +84,7 @@ namespace sqlpp
 	template<typename T>
 		auto max(T t) -> max_t<wrap_operand_t<T>>
 		{
+			static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, "max() cannot be used on an aggregate function");
 			static_assert(is_expression_t<wrap_operand_t<T>>::value, "max() requires an expression as argument");
 			return { t };
 		}

include/sqlpp11/min.h

@@ -38,7 +38,7 @@ namespace sqlpp
 			public alias_operators<min_t<Expr>>
 	{
 		using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Expr, aggregate_function>;
+		using _nodes = detail::type_vector<Expr, aggregate_function>;
 
 		struct _alias_t
 		{
@@ -84,6 +84,7 @@ namespace sqlpp
 	template<typename T>
 		auto min(T t) -> min_t<wrap_operand_t<T>>
 		{
+			static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, "min() cannot be used on an aggregate function");
 			static_assert(is_expression_t<wrap_operand_t<T>>::value, "min() requires an expression as argument");
 			return { t };
 		}

include/sqlpp11/multi_column.h

@@ -42,7 +42,7 @@ namespace sqlpp
 		struct multi_column_t
 		{
 			using _traits = make_traits<no_value_t>;
-			using _recursive_traits = make_recursive_traits<Columns...>;
+			using _nodes = detail::type_vector<Columns...>;
 
 			static_assert(logic::all_t<is_selectable_t<Columns>::value...>::value, "multi_column parameters need to be named expressions");
 
@@ -73,7 +73,7 @@ namespace sqlpp
 		struct multi_column_alias_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_alias, tag::is_multi_column, tag::is_selectable>;
-			using _recursive_traits = make_recursive_traits<Columns...>;
+			using _nodes = detail::type_vector<Columns...>;
 
 			static_assert(logic::all_t<is_selectable_t<Columns>::value...>::value, "multi_column parameters need to be named expressions");
 

include/sqlpp11/noop.h

@@ -37,7 +37,7 @@ namespace sqlpp
 	struct noop 
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		struct _alias_t {};
 

include/sqlpp11/not_in.h

@@ -41,7 +41,7 @@ namespace sqlpp
 			public alias_operators<not_in_t<Operand, Args...>>
 	{
 		using _traits = make_traits<boolean, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Operand, Args...>;
+		using _nodes = detail::type_vector<Operand, Args...>;
 
 		static_assert(sizeof...(Args) > 0, "not_in() requires at least one argument");
 

include/sqlpp11/null.h

@@ -34,7 +34,7 @@ namespace sqlpp
 	struct null_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_expression, tag::is_sql_null>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 	};
 
 	template<typename Context>

include/sqlpp11/offset.h

@@ -55,7 +55,7 @@ namespace sqlpp
 		struct offset_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_offset>;
-			using _recursive_traits = make_recursive_traits<Offset>;
+			using _nodes = detail::type_vector<Offset>;
 
 			static_assert(is_integral_t<Offset>::value, "offset requires an integral value or integral parameter");
 
@@ -120,7 +120,7 @@ namespace sqlpp
 		struct dynamic_offset_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_offset>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			// Data
 			using _data_t = dynamic_offset_data_t<Database>;
@@ -177,7 +177,7 @@ namespace sqlpp
 	struct no_offset_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/on.h

@@ -38,7 +38,7 @@ namespace sqlpp
 		struct on_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_on>;
-			using _recursive_traits = make_recursive_traits<Expressions...>;
+			using _nodes = detail::type_vector<Expressions...>;
 
 			using _is_dynamic = is_database<Database>;
 

include/sqlpp11/order_by.h

@@ -71,7 +71,7 @@ namespace sqlpp
 		struct order_by_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_order_by>;
-			using _recursive_traits = make_recursive_traits<Expressions...>;
+			using _nodes = detail::type_vector<Expressions...>;
 
 			using _is_dynamic = is_database<Database>;
 
@@ -141,7 +141,7 @@ namespace sqlpp
 	struct no_order_by_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/parameter.h

@@ -38,17 +38,10 @@ namespace sqlpp
 			public expression_operators<parameter_t<ValueType, NameType>, ValueType>
 	{
 		using _traits = make_traits<ValueType, tag::is_parameter, tag::is_expression>;
-		struct _recursive_traits
+
-		{
+		using _nodes = detail::type_vector<>;
-			using _required_ctes = detail::type_set<>;
+		using _parameters = detail::type_vector<parameter_t>;
-			using _provided_ctes = detail::type_set<>;
+		using _can_be_null = std::true_type;
-			using _required_tables = detail::type_set<>;
-			using _provided_tables = detail::type_set<>;
-			using _provided_outer_tables = detail::type_set<>;
-			using _extra_tables = detail::type_set<>;
-			using _parameters = std::tuple<parameter_t>;
-			using _tags = detail::type_set<tag::can_be_null>;
-		};
 
 		using _instance_t = member_t<NameType, parameter_value_t<ValueType>>;
 

include/sqlpp11/parameter_list.h

@@ -37,11 +37,11 @@ namespace sqlpp
 	template<typename T>
 		struct parameter_list_t
 		{
-			static_assert(wrong_t<parameter_list_t>::value, "Template parameter for parameter_list_t has to be a tuple");
+			static_assert(wrong_t<parameter_list_t>::value, "Template parameter for parameter_list_t has to be a type_vector");
 		};
 
 	template<typename... Parameter>
-		struct parameter_list_t<std::tuple<Parameter...>>: public Parameter::_instance_t...
+		struct parameter_list_t<detail::type_vector<Parameter...>>: public Parameter::_instance_t...
 		{
 			using _member_tuple_t = std::tuple<typename Parameter::_instance_t...>;
 			using size = std::integral_constant<std::size_t, sizeof...(Parameter)>;

include/sqlpp11/prepared_execute.h

@@ -37,7 +37,7 @@ namespace sqlpp
 		struct prepared_execute_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			using _parameter_list_t = make_parameter_list_t<Statement>;
 			using _prepared_statement_t = typename Db::_prepared_statement_t;

include/sqlpp11/prepared_insert.h

@@ -37,7 +37,7 @@ namespace sqlpp
 		struct prepared_insert_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			using _parameter_list_t = make_parameter_list_t<Insert>;
 			using _prepared_statement_t = typename Db::_prepared_statement_t;

include/sqlpp11/prepared_remove.h

@@ -37,7 +37,7 @@ namespace sqlpp
 		struct prepared_remove_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			using _parameter_list_t = make_parameter_list_t<Remove>;
 			using _prepared_statement_t = typename Db::_prepared_statement_t;

include/sqlpp11/prepared_select.h

@@ -37,7 +37,7 @@ namespace sqlpp
 		struct prepared_select_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			using _result_row_t = typename Statement::template _result_row_t<Database>;
 			using _parameter_list_t = make_parameter_list_t<Composite>;

include/sqlpp11/prepared_update.h

@@ -37,7 +37,7 @@ namespace sqlpp
 		struct prepared_update_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_prepared_statement>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			using _parameter_list_t = make_parameter_list_t<Update>;
 			using _prepared_statement_t = typename Db::_prepared_statement_t;

include/sqlpp11/result_field_methods.h

@@ -81,20 +81,8 @@ namespace sqlpp
 						tag::is_expression, 
 						tag_if<tag::null_is_trivial_value, _base_t::_null_is_trivial>>;
 
-			struct _recursive_traits
+			using _nodes = detail::type_vector<>;
-			{
+			using _can_be_null = column_spec_can_be_null_t<_field_spec_t>;
-				using _required_ctes = detail::type_set<>;
-				using _provided_ctes = detail::type_set<>;
-				using _required_tables = detail::type_set<>;
-				using _provided_tables = detail::type_set<>;
-				using _provided_outer_tables = detail::type_set<>;
-				using _extra_tables = detail::type_set<>;
-				using _parameters = std::tuple<>;
-				using _tags = typename std::conditional<column_spec_can_be_null_t<_field_spec_t>::value,
-										detail::type_set<tag::can_be_null>,
-										detail::type_set<>>::type;
-			};
-
 		};
 
 }

include/sqlpp11/result_row.h

@@ -185,7 +185,7 @@ namespace sqlpp
 		struct _field_spec_t
 		{
 			using _traits = make_traits<text, tag::is_noop, tag::can_be_null, tag::null_is_trivial_value>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			struct _alias_t {};
 		};

include/sqlpp11/rhs_wrap.h

@@ -118,7 +118,7 @@ namespace sqlpp
 		struct rhs_wrap_t
 		{
 			using _traits = typename Expr::_traits;
-			using _recursive_traits = typename Expr::_recursive_traits;
+			using _nodes = detail::type_vector<Expr>;
 
 			rhs_wrap_t(Expr expr):
 				_expr(expr) 

include/sqlpp11/select_column_list.h

@@ -164,7 +164,7 @@ namespace sqlpp
 		struct select_column_list_t
 		{
 			using _traits = typename detail::select_traits<Columns...>::_traits;
-			using _recursive_traits = make_recursive_traits<Columns...>;
+			using _nodes = detail::type_vector<Columns...>;
 
 			using _alias_t = typename detail::select_traits<Columns...>::_alias_t;
 
@@ -353,7 +353,7 @@ namespace sqlpp
 	struct no_select_column_list_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop, tag::is_missing>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		struct _alias_t {};
 

include/sqlpp11/select_flag_list.h

@@ -60,7 +60,7 @@ namespace sqlpp
 		struct select_flag_list_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_select_flag_list>;
-			using _recursive_traits = make_recursive_traits<Flags...>;
+			using _nodes = detail::type_vector<Flags...>;
 
 			using _is_dynamic = is_database<Database>;
 
@@ -128,7 +128,7 @@ namespace sqlpp
 	struct no_select_flag_list_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/select_flags.h

@@ -38,7 +38,7 @@ namespace sqlpp
 	struct all_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_select_flag>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 	};
 	static constexpr all_t all = {};
 
@@ -57,7 +57,7 @@ namespace sqlpp
 	struct distinct_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_select_flag>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 	};
 	static constexpr distinct_t distinct = {};
 
@@ -76,7 +76,7 @@ namespace sqlpp
 	struct straight_join_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_select_flag>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 	};
 	static constexpr straight_join_t straight_join = {};
 

include/sqlpp11/select_pseudo_table.h

@@ -58,7 +58,7 @@ namespace sqlpp
 																						 NamedExpr...>, select_column_spec_t<Select, NamedExpr>...>
 	{
 		using _traits = make_traits<no_value_t, tag::is_table, tag::is_pseudo_table>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		select_pseudo_table_t(Select select):
 			_select(select)

include/sqlpp11/simple_column.h

@@ -39,7 +39,7 @@ namespace sqlpp
 			_column_t _column;
 
 			using _traits = make_traits<no_value_t, tag::is_noop>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 		};
 
 	template<typename Context, typename Column>

include/sqlpp11/single_table.h

@@ -58,7 +58,7 @@ namespace sqlpp
 		struct single_table_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_single_table>;
-			using _recursive_traits = make_recursive_traits<Table>;
+			using _nodes = detail::type_vector<Table>;
 
 			static_assert(is_table_t<Table>::value, "argument has to be a table");
 			static_assert(required_tables_of<Table>::size::value == 0, "table depends on another table");
@@ -99,7 +99,7 @@ namespace sqlpp
 	struct no_single_table_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_noop>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/some.h

@@ -37,7 +37,7 @@ namespace sqlpp
 		struct some_t
 		{
 			using _traits = make_traits<value_type_of<Select>, tag::is_multi_expression>;
-			using _recursive_traits = make_recursive_traits<Select>;
+			using _nodes = detail::type_vector<Select>;
 
 			struct _alias_t
 			{

include/sqlpp11/sort_order.h

@@ -42,7 +42,7 @@ namespace sqlpp
 		struct sort_order_t
 		{
 			using _traits = make_traits<no_value_t,  tag::is_sort_order>;
-			using _recursive_traits = make_recursive_traits<Expression>;
+			using _nodes = detail::type_vector<Expression>;
 
 			Expression _expression;
 		};

include/sqlpp11/statement.h

@@ -130,14 +130,12 @@ namespace sqlpp
 
 				// A select can be used as a pseudo table if
 				//   - at least one column is selected
-				//   - the select is complete (leaks no table requirements)
+				//   - the select is complete (leaks no table requirements or cte requirements)
 				static constexpr bool _can_be_used_as_table()
 				{
 					return has_result_row_t<_statement_t>::value
 					 	and _required_tables::size::value == 0
-					 	and _all_provided_ctes::size::value == 0 // a sub-select must not contain a WITH
+					 	and _required_ctes::size::value == 0;
-						? true
-						: false;
 				}
 
 				using _value_type = typename std::conditional<
@@ -146,34 +144,23 @@ namespace sqlpp
 					no_value_t // if a required statement part is missing (e.g. columns in a select), then the statement cannot be used as a value
 						>::type;
 
+				using _traits = make_traits<_value_type, tag_if<tag::is_expression, not std::is_same<_value_type, no_value_t>::value>>;
+
+				using _nodes = detail::type_vector<>;
 				using _can_be_null = logic::any_t<
 					can_be_null_t<_result_type_provider>::value, 
 					detail::make_intersect_set_t<
 						required_tables_of<_result_type_provider>, 
 						_all_provided_outer_tables
 						>::size::value != 0>;
-
+				using _parameters = detail::type_vector_cat_t<parameters_of<Policies>...>;
-				using _traits = make_traits<_value_type, tag_if<tag::is_expression, not std::is_same<_value_type, no_value_t>::value>>;
+				// required_tables and _required_ctes are defined above
-
-				struct _recursive_traits
-				{
-					using _required_ctes = statement_policies_t::_required_ctes;
-					using _provided_ctes = detail::type_set<>;
-					using _required_tables = statement_policies_t::_required_tables;
-					using _provided_tables = detail::type_set<>;
-					using _provided_outer_tables = detail::type_set<>;
-					using _extra_tables = detail::type_set<>;
-					using _parameters = detail::make_parameter_tuple_t<parameters_of<Policies>...>;
-					using _tags = typename std::conditional<_can_be_null::value,
-											detail::type_set<tag::can_be_null>,
-											detail::type_set<>>::type;
-				};
 
 				using _cte_check = typename std::conditional<_required_ctes::size::value == 0,
 							consistent_t, assert_no_unknown_ctes_t>::type;
 				using _table_check = typename std::conditional<_required_tables::size::value == 0,
 							consistent_t, assert_no_unknown_tables_t>::type;
-				using _parameter_check = typename std::conditional<std::tuple_size<typename _recursive_traits::_parameters>::value == 0,
+				using _parameter_check = typename std::conditional<detail::type_vector_size<_parameters>::value == 0,
 							consistent_t, assert_no_parameters_t>::type;
 			};
 	}
@@ -212,7 +199,7 @@ namespace sqlpp
 					tag_if<tag::is_selectable, is_expression_t<_policies_t>::value>,
 					tag_if<tag::is_return_value, logic::none_t<is_noop_t<_result_type_provider>::value>::value>,
 					tag::requires_braces>;
-		using _recursive_traits = typename _policies_t::_recursive_traits;
+		using _nodes = detail::type_vector<_policies_t>;
 		using _used_outer_tables = typename _policies_t::_all_provided_outer_tables;
 
 		using _alias_t = typename _result_type_provider::_alias_t;
@@ -237,7 +224,7 @@ namespace sqlpp
 
 		static constexpr size_t _get_static_no_of_parameters()
 		{
-			return std::tuple_size<parameters_of<statement_t>>::value;
+			return detail::type_vector_size<parameters_of<statement_t>>::value;
 		}
 
 		size_t _get_no_of_parameters() const
@@ -286,7 +273,7 @@ namespace sqlpp
 		struct statement_name_t
 		{
 			using _traits = make_traits<no_value_t, Tag>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			// Data
 			using _data_t = NameData;

include/sqlpp11/sum.h

@@ -38,7 +38,7 @@ namespace sqlpp
 			public alias_operators<sum_t<Flag, Expr>>
 	{
 		using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
-		using _recursive_traits = make_recursive_traits<Expr, aggregate_function>;
+		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");

include/sqlpp11/table.h

@@ -46,17 +46,8 @@ namespace sqlpp
 	{
 		using _traits = make_traits<no_value_t, tag::is_table>;
 
-		struct _recursive_traits
+		using _nodes = detail::type_vector<>;
-		{
+		using _provided_tables = detail::type_set<Table>;
-			using _required_ctes = detail::type_set<>;
-			using _provided_ctes = detail::type_set<>;
-			using _required_tables = detail::type_set<>;
-			using _provided_tables = detail::type_set<Table>;
-			using _provided_outer_tables = detail::type_set<>;
-			using _extra_tables = detail::type_set<>;
-			using _parameters = std::tuple<>;
-			using _tags = detail::type_set<>;
-		};
 
 		static_assert(sizeof...(ColumnSpec), "at least one column required per table");
 		using _required_insert_columns = typename detail::make_type_set_if<require_insert_t, column_t<Table, ColumnSpec>...>::type;

include/sqlpp11/table_alias.h

@@ -42,17 +42,9 @@ namespace sqlpp
 		//FIXME: Need to add join functionality
 		using _traits = make_traits<value_type_of<Table>, tag::is_table, tag::is_alias, tag_if<tag::is_selectable, is_expression_t<Table>::value>>;
 
-		struct _recursive_traits
+		using _nodes = detail::type_vector<>;
-		{
+		using _required_ctes = required_ctes_of<Table>;
-			using _required_ctes = required_ctes_of<Table>;
+		using _provided_tables = detail::type_set<AliasProvider>;
-			using _provided_ctes = detail::type_set<>;
-			using _required_tables = detail::type_set<>;
-			using _provided_tables = detail::type_set<AliasProvider>;
-			using _provided_outer_tables = detail::type_set<>;
-			using _extra_tables = detail::type_set<>;
-			using _parameters = std::tuple<>;
-			using _tags = detail::type_set<>;
-		};
 
 		static_assert(required_tables_of<Table>::size::value == 0, "table aliases must not depend on external tables");
 

include/sqlpp11/tvin.h

@@ -40,7 +40,7 @@ namespace sqlpp
 		struct tvin_arg_t
 		{
 			using _traits = make_traits<value_type_of<Operand>, tag::is_expression>;
-			using _recursive_traits = make_recursive_traits<Operand>;
+			using _nodes = detail::type_vector<Operand>;
 
 			using _operand_t = Operand;
 
@@ -102,7 +102,7 @@ namespace sqlpp
 		struct tvin_t
 		{
 			using _traits = make_traits<value_type_of<Operand>, tag::is_expression>;
-			using _recursive_traits = make_recursive_traits<Operand>;
+			using _nodes = detail::type_vector<Operand>;
 
 			using _operand_t = Operand;
 

include/sqlpp11/type_traits.h

@@ -30,6 +30,7 @@
 #include <type_traits>
 #include <tuple>
 #include <sqlpp11/serializer.h>
+#include <sqlpp11/detail/type_vector.h>
 #include <sqlpp11/detail/type_set.h>
 #include <sqlpp11/detail/get_first.h>
 
@@ -38,29 +39,8 @@ namespace sqlpp
 	namespace tag
 	{
 		struct can_be_null{};
-		struct contains_aggregate_function{};
 	}
 
-	namespace detail
-	{
-		template<typename T, typename Enable = void>
-		struct can_be_null_impl { using type = std::false_type; };
-		template<typename T>
-		struct can_be_null_impl<T, typename std::enable_if<is_element_of<tag::can_be_null, typename T::_recursive_traits::_tags>::value>::type> { using type = std::true_type; };
-	}
-	template<typename T>
-	using can_be_null_t = typename detail::can_be_null_impl<T>::type;
-
-	namespace detail
-	{
-		template<typename T, typename Enable = void>
-		struct contains_aggregate_function_impl { using type = std::false_type; };
-		template<typename T>
-		struct contains_aggregate_function_impl<T, typename std::enable_if<is_element_of<tag::contains_aggregate_function, typename T::_recursive_traits::_tags>::value>::type> { using type = std::true_type; };
-	}
-	template<typename T>
-	using contains_aggregate_function_t = typename detail::contains_aggregate_function_impl<T>::type;
-
 	namespace detail
 	{
 		template<typename T, typename Enable = void>
@@ -71,23 +51,6 @@ namespace sqlpp
 	template<typename T>
 	using column_spec_can_be_null_t = typename detail::column_spec_can_be_null_impl<T>::type;
 
-	namespace tag
-	{
-		struct is_expression{};
-	}
-	namespace detail
-	{
-		template<typename T, typename Enable = void>
-		struct is_expression_impl { using type = std::false_type; };
-		template<typename T>
-		struct is_expression_impl<T, typename std::enable_if<
-					detail::is_element_of<tag::is_expression, typename T::_traits::_tags>::value
-					and not detail::is_element_of<tag::contains_aggregate_function, typename T::_recursive_traits::_tags>::value
-					>::type> { using type = std::true_type; };
-	}
-	template<typename T>
-	using is_expression_t = typename detail::is_expression_impl<T>::type;
-
 #define SQLPP_VALUE_TRAIT_GENERATOR(name) \
 	namespace tag\
 	{\
@@ -116,6 +79,7 @@ namespace sqlpp
 	SQLPP_VALUE_TRAIT_GENERATOR(is_text)
 	SQLPP_VALUE_TRAIT_GENERATOR(is_wrapped_value)
 	SQLPP_VALUE_TRAIT_GENERATOR(is_selectable)
+	SQLPP_VALUE_TRAIT_GENERATOR(is_expression)
 	SQLPP_VALUE_TRAIT_GENERATOR(is_multi_expression)
 	SQLPP_VALUE_TRAIT_GENERATOR(is_alias)
 	SQLPP_VALUE_TRAIT_GENERATOR(is_select_flag)
@@ -175,40 +139,86 @@ namespace sqlpp
 	template<typename Database>
 		using is_database = typename std::conditional<std::is_same<Database, void>::value, std::false_type, std::true_type>::type;
 
-	namespace detail
-	{
-		template<typename... T>
-			using make_parameter_tuple_t = decltype(std::tuple_cat(std::declval<T>()...));
-	}
 	template<typename T>
 		using value_type_of = typename T::_traits::_value_type;
 
 	template<typename T>
 		using cpp_value_type_of = typename value_type_of<T>::_cpp_value_type;
 
-	template<typename T>
+#define SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(trait) \
-		using required_ctes_of = typename T::_recursive_traits::_required_ctes;
+	namespace detail\
+	{\
+		template<typename T, typename Leaf = void>\
+			struct trait##_of_impl\
+			{\
+				using type = typename trait##_of_impl<typename T::_nodes>::type;\
+			};\
+		template<typename T>\
+			struct trait##_of_impl<T, typename std::enable_if<std::is_class<typename T::_##trait>::value>::type>\
+			{\
+				using type = typename T::_##trait;\
+			};\
+		template<typename... Nodes>\
+			struct trait##_of_impl<type_vector<Nodes...>, void>\
+			{\
+				using type = detail::make_joined_set_t<typename trait##_of_impl<Nodes>::type...>;\
+			};\
+	}\
+	template<typename T>\
+		using trait##_of = typename detail::trait##_of_impl<T>::type;
 
-	template<typename T>
+	SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(required_ctes)
-		using provided_ctes_of = typename T::_recursive_traits::_provided_ctes;
+	SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(provided_ctes)
+	SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(required_tables)
+	SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(provided_tables)
+	SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(provided_outer_tables)
+	SQLPP_RECURSIVE_TRAIT_SET_GENERATOR(extra_tables)
 
-	template<typename T>
+#define SQLPP_RECURSIVE_TRAIT_GENERATOR(trait) \
-		using required_tables_of = typename T::_recursive_traits::_required_tables;
+	namespace detail\
+	{\
+		template<typename T, typename Leaf = void>\
+			struct trait##_impl\
+			{\
+				using type = typename trait##_impl<typename T::_nodes>::type;\
+			};\
+		template<typename T>\
+			struct trait##_impl<T, typename std::enable_if<std::is_class<typename T::_##trait>::value>::type>\
+			{\
+				using type = typename T::_##trait;\
+			};\
+		template<typename... Nodes>\
+			struct trait##_impl<type_vector<Nodes...>, void>\
+			{\
+				using type = logic::any_t<trait##_impl<Nodes>::type::value...>;\
+			};\
+	}\
+	template<typename T>\
+		using trait##_t = typename detail::trait##_impl<T>::type;
 
-	template<typename T>
+	SQLPP_RECURSIVE_TRAIT_GENERATOR(can_be_null)
-		using provided_tables_of = typename T::_recursive_traits::_provided_tables;
+	SQLPP_RECURSIVE_TRAIT_GENERATOR(contains_aggregate_function)
 
-	template<typename T>
+	namespace detail
-		using provided_outer_tables_of = typename T::_recursive_traits::_provided_outer_tables;
+	{
-
+		template<typename T, typename Leaf = void>
-	template<typename T>
+			struct parameters_of_impl
-		using extra_tables_of = typename T::_recursive_traits::_extra_tables;
+			{
-
+				using type = typename parameters_of_impl<typename T::_nodes>::type;
-	template<typename T>
+			};
-		using parameters_of = typename T::_recursive_traits::_parameters;
+		template<typename T>
-
+			struct parameters_of_impl<T, typename std::enable_if<std::is_class<typename T::_parameters>::value>::type>
-	template<typename T>
+			{
-		using recursive_tags_of = typename T::_recursive_traits::_tags;
+				using type = typename T::_parameters;
+			};
+		template<typename... Nodes>
+			struct parameters_of_impl<type_vector<Nodes...>, void>
+			{
+				using type = detail::type_vector_cat_t<typename parameters_of_impl<Nodes>::type...>;
+			};
+	}
+	template<typename T>\
+		using parameters_of = typename detail::parameters_of_impl<T>::type;
 
 	template<typename T>
 		using alias_of = typename T::_alias_t;
@@ -223,36 +233,10 @@ namespace sqlpp
 			using _tags = detail::make_type_set_t<typename ValueType::_tag, Tags...>;
 		};
 
-	template<typename... Arguments>
-		struct make_recursive_traits
-		{
-			using _required_ctes = detail::make_joined_set_t<required_ctes_of<Arguments>...>;
-			using _provided_ctes = detail::make_joined_set_t<provided_ctes_of<Arguments>...>;
-			using _required_tables = detail::make_joined_set_t<required_tables_of<Arguments>...>;
-			using _provided_tables = detail::make_joined_set_t<provided_tables_of<Arguments>...>;
-			using _provided_outer_tables = detail::make_joined_set_t<provided_outer_tables_of<Arguments>...>;
-			using _extra_tables = detail::make_joined_set_t<extra_tables_of<Arguments>...>;
-			using _parameters = detail::make_parameter_tuple_t<parameters_of<Arguments>...>;
-			using _tags = detail::make_joined_set_t<recursive_tags_of<Arguments>...>;
-		};
-
-	template<typename... Tags>
-		struct recursive_tags
-		{
-			using _required_ctes = detail::type_set<>;
-			using _provided_ctes = detail::type_set<>;
-			using _required_tables = detail::type_set<>;
-			using _provided_tables = detail::type_set<>;
-			using _provided_outer_tables = detail::type_set<>;
-			using _extra_tables = detail::type_set<>;
-			using _parameters = std::tuple<>;
-			using _tags = detail::type_set<Tags...>;
-		};
-
 	struct aggregate_function
 	{
-		struct _traits { using _value_type = void; using _tags = detail::type_set<>; };
+		using _nodes = detail::type_vector<>;
-		using _recursive_traits = recursive_tags<tag::contains_aggregate_function>;
+		using _contains_aggregate_function = std::true_type;
 	};
 
 	template<typename NameProvider, typename Member>

include/sqlpp11/union.h

@@ -66,7 +66,7 @@ namespace sqlpp
 		struct union_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_union, tag::is_return_value>;
-			using _recursive_traits = make_recursive_traits<Lhs, Rhs>;
+			using _nodes = detail::type_vector<Lhs, Rhs>;
 
 			using _alias_t = struct{};
 
@@ -114,7 +114,7 @@ namespace sqlpp
 	struct no_union_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_union>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/update_list.h

@@ -68,7 +68,7 @@ namespace sqlpp
 		struct update_list_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_update_list>;
-			using _recursive_traits = make_recursive_traits<Assignments...>;
+			using _nodes = detail::type_vector<Assignments...>;
 			using _is_dynamic = is_database<Database>;
 
 			// Data
@@ -153,7 +153,7 @@ namespace sqlpp
 	struct no_update_list_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_where>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/using.h

@@ -58,7 +58,7 @@ namespace sqlpp
 		struct using_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_using_>;
-			using _recursive_traits = make_recursive_traits<Tables...>;
+			using _nodes = detail::type_vector<Tables...>;
 
 			using _is_dynamic = is_database<Database>;
 
@@ -121,7 +121,7 @@ namespace sqlpp
 	struct no_using_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_where>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/value_or_null.h

@@ -51,7 +51,7 @@ namespace sqlpp
 			using _cpp_value_type = typename ValueType::_cpp_value_type;
 
 			using _traits = make_traits<ValueType, tag::is_expression>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			value_or_null_t(_cpp_value_type value):
 				_value(value),

include/sqlpp11/verbatim.h

@@ -39,10 +39,8 @@ namespace sqlpp
 			public alias_operators<verbatim_t<ValueType>>
 	{
 		using _traits = make_traits<ValueType, tag::is_expression>;
-		struct _recursive_traits : public make_recursive_traits<>
+		using _nodes = detail::type_vector<>;
-		{
+		using _can_be_null = std::true_type; // since we do not know what's going on inside the verbatim, we assume it can be null
-			using _tags = detail::type_set<tag::can_be_null>; // since we do not know what's going on inside the verbatim, we assume it can be null
-		};
 
 		verbatim_t(std::string verbatim): _verbatim(verbatim) {}
 		verbatim_t(const verbatim_t&) = default;

include/sqlpp11/verbatim_table.h

@@ -50,10 +50,7 @@ namespace sqlpp
 
 	struct verbatim_table_t: public table_t<verbatim_table_t, detail::unusable_pseudo_column_t>
 	{
-		struct _recursive_traits: public table_t<verbatim_table_t, detail::unusable_pseudo_column_t>::_recursive_traits
+		using _nodes = detail::type_vector<>;
-		{
-			using _provided_outer_tables = detail::type_set<verbatim_table_t>;
-		};
 
 		struct _alias_t
 		{

include/sqlpp11/where.h

@@ -71,7 +71,7 @@ namespace sqlpp
 		struct where_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_where>;
-			using _recursive_traits = make_recursive_traits<Expressions...>;
+			using _nodes = detail::type_vector<Expressions...>;
 
 			using _is_dynamic = is_database<Database>;
 
@@ -149,7 +149,7 @@ namespace sqlpp
 		struct where_t<void, bool>
 		{
 			using _traits = make_traits<no_value_t, tag::is_where>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			// Data
 			using _data_t = where_data_t<void, bool>;
@@ -198,7 +198,7 @@ namespace sqlpp
 		struct no_where_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_where>;
-			using _recursive_traits = make_recursive_traits<>;
+			using _nodes = detail::type_vector<>;
 
 			// Data
 			using _data_t = no_data_t;

include/sqlpp11/with.h

@@ -66,17 +66,9 @@ namespace sqlpp
 		struct with_t
 		{
 			using _traits = make_traits<no_value_t, tag::is_with>;
-			struct _recursive_traits
+			using _nodes = detail::type_vector<>;
-			{
+			using _provided_ctes = detail::make_joined_set_t<required_ctes_of<Expressions>...>; // WITH provides common table expressions
-				using _required_ctes = detail::type_set<>;
+			using _parameters = detail::type_vector_cat_t<parameters_of<Expressions>...>;
-				using _provided_ctes = detail::make_joined_set_t<required_ctes_of<Expressions>...>; // with provides common table expressions
-				using _required_tables = detail::type_set<>;
-				using _provided_tables = detail::type_set<>;
-				using _provided_outer_tables = detail::type_set<>;
-				using _extra_tables = detail::type_set<>;
-				using _parameters = detail::make_parameter_tuple_t<parameters_of<Expressions>...>;
-				using _tags = detail::type_set<>;
-			};
 
 			using _is_dynamic = is_database<Database>;
 
@@ -116,7 +108,7 @@ namespace sqlpp
 	struct no_with_t
 	{
 		using _traits = make_traits<no_value_t, tag::is_with>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		// Data
 		using _data_t = no_data_t;

include/sqlpp11/wrap_operand.h

@@ -43,7 +43,7 @@ namespace sqlpp
 	struct boolean_operand: public alias_operators<boolean_operand>
 	{
 		using _traits = make_traits<boolean, tag::is_expression, tag::is_wrapped_value>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		using _value_t = bool;
 
@@ -82,7 +82,7 @@ namespace sqlpp
 	struct integral_operand: public alias_operators<integral_operand>
 	{
 		using _traits = make_traits<integral, tag::is_expression, tag::is_wrapped_value>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		using _value_t = int64_t;
 
@@ -122,7 +122,7 @@ namespace sqlpp
 	struct floating_point_operand: public alias_operators<floating_point_operand>
 	{
 		using _traits = make_traits<floating_point, tag::is_expression, tag::is_wrapped_value>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		using _value_t = double;
 
@@ -161,7 +161,7 @@ namespace sqlpp
 	struct text_operand: public alias_operators<text_operand>
 	{
 		using _traits = make_traits<text, tag::is_expression, tag::is_wrapped_value>;
-		using _recursive_traits = make_recursive_traits<>;
+		using _nodes = detail::type_vector<>;
 
 		using _value_t = std::string;
 

test_constraints/CMakeLists.txt

@@ -24,8 +24,8 @@ function(test_constraint name pattern)
 
 endfunction(test_constraint)
 
-test_constraint(count_of_count "requires an expression as argument")
+test_constraint(count_of_count "count() cannot be used on an aggregate function")
-test_constraint(max_of_max "requires an expression as argument")
+test_constraint(max_of_max "max() cannot be used on an aggregate function")
 test_constraint(no_conversion_operator_if_null_not_trivial "int i = row.alpha")
 test_constraint(require_insert "required column is missing")
 test_constraint(must_not_insert "one assignment is prohibited")

tests/PreparedTest.cpp

@@ -40,40 +40,48 @@ int main()
 
 	// empty parameter lists
 	{
-		using T = sqlpp::parameters_of<decltype(t.alpha)>;
+		using T = sqlpp::make_parameter_list_t<decltype(t.alpha)>;
-		static_assert(std::is_same<T, std::tuple<>>::value, "type requirement");
+		static_assert(T::size::value == 0, "type requirement");
 	}
 
 	// single parameter
 	{
-		using T = sqlpp::parameters_of<decltype(parameter(t.alpha))>;
+		using T = sqlpp::make_parameter_list_t<decltype(parameter(t.alpha))>;
-		static_assert(std::is_same<T, std::tuple<decltype(parameter(t.alpha))>>::value, "type requirement");
+		static_assert(T::size::value == 1, "type requirement");
+		auto t = T{};
+		t.alpha = 7;
 	}
 
 	// single parameter
 	{
-		using T = sqlpp::parameters_of<decltype(parameter(t.alpha))>;
+		using T = sqlpp::make_parameter_list_t<decltype(parameter(t.beta))>;
-		static_assert(std::is_same<T, std::tuple<decltype(parameter(t.alpha))>>::value, "type requirement");
+		static_assert(T::size::value == 1, "type requirement");
+		auto t = T{};
+		t.beta = "cheesecake";
 	}
 
 	// single parameter in expression
 	{
-		using T = sqlpp::parameters_of<decltype(t.alpha == parameter(t.alpha))>;
+		using T = sqlpp::make_parameter_list_t<decltype(t.alpha == parameter(t.alpha))>;
-		static_assert(std::is_same<T, std::tuple<decltype(parameter(t.alpha))>>::value, "type requirement");
+		static_assert(T::size::value == 1, "type requirement");
+		auto t = T{};
+		t.alpha = 7;
 	}
 
 
 	// single parameter in larger expression
 	{
-		using T = sqlpp::parameters_of<decltype((t.beta.like("%") and t.alpha == parameter(t.alpha)) or t.gamma != false)>;
+		using T = sqlpp::make_parameter_list_t<decltype((t.beta.like("%") and t.alpha == parameter(t.alpha)) or t.gamma != false)>;
-		static_assert(std::is_same<T, std::tuple<decltype(parameter(t.alpha))>>::value, "type requirement");
+		static_assert(T::size::value == 1, "type requirement");
+		auto t = T{};
+		t.alpha = 7;
 	}
 
 	// three parameters in expression
 	{
 		using T = sqlpp::parameters_of<decltype((t.beta.like(parameter(t.beta)) and t.alpha == parameter(t.alpha)) or t.gamma != parameter(t.gamma))>;
-		static_assert(std::tuple_size<T>::value == 3, "type requirement");
+		// FIXME: make some test, that does not depend on detail namespace, but still checks the correct order of the parameters
-		static_assert(std::is_same<T, std::tuple<decltype(parameter(t.beta)), decltype(parameter(t.alpha)),decltype(parameter(t.gamma))>>::value, "type requirement");
+		static_assert(std::is_same<T, sqlpp::detail::type_vector<decltype(parameter(t.beta)), decltype(parameter(t.alpha)),decltype(parameter(t.gamma))>>::value, "type requirement");
 	}
 
 	// OK, fine, now create a named parameter list from an expression