Moved where-methods to where-classes.

include/sqlpp11/select.h

@@ -51,6 +51,54 @@
 
 namespace sqlpp
 {
+	template<typename Database = void,
+			typename FlagList = vendor::no_select_flag_list_t, 
+			typename ColumnList = vendor::no_select_column_list_t, 
+			typename From = vendor::no_from_t,
+			typename Where = vendor::no_where_t, 
+			typename GroupBy = vendor::no_group_by_t, 
+			typename Having = vendor::no_having_t,
+			typename OrderBy = vendor::no_order_by_t, 
+			typename Limit = vendor::no_limit_t, 
+			typename Offset = vendor::no_offset_t
+				>
+		struct select_t;
+	namespace detail
+	{
+		template<typename Db,
+				typename FlagList, 
+				typename ColumnList, 
+				typename From,
+				typename Where, 
+				typename GroupBy, 
+				typename Having,
+				typename OrderBy, 
+				typename Limit, 
+				typename Offset
+					>
+			struct select_policies_t
+			{
+				using _database_t = Db;
+				using _select_t = select_t<Db, FlagList, ColumnList, From, Where, GroupBy, Having, OrderBy, Limit, Offset>;
+				template<typename Needle, typename Replacement, typename... Policies>
+					struct _policies_update_impl
+					{
+						using type =  select_t<Db, vendor::policy_update_t<Policies, Needle, Replacement>...>;
+					};
+
+				template<typename Needle, typename Replacement>
+					using _policies_update_t = typename _policies_update_impl<Needle, Replacement, FlagList, ColumnList, From, Where, GroupBy, Having, OrderBy, Limit, Offset>::type;
+
+					static_assert(is_noop_t<ColumnList>::value or sqlpp::is_select_column_list_t<ColumnList>::value, "column list of select is neither naught nor a valid column list");
+					static_assert(is_noop_t<From>::value or sqlpp::is_from_t<From>::value, "from() part of select is neither naught nor a valid from()");
+					using _value_type = typename std::conditional<
+						sqlpp::is_from_t<From>::value,
+						typename ColumnList::_value_type,
+						no_value_t // If there is no from, the select is not complete (this logic is a bit simple, but better than nothing)
+							>::type;
+			};
+	}
+
 	namespace detail
 	{
 		template<
@@ -70,18 +118,19 @@ namespace sqlpp
 	}
 
 	// SELECT
-	template<typename Database = void,
-			typename FlagList = vendor::no_select_flag_list_t, 
-			typename ColumnList = vendor::no_select_column_list_t, 
-			typename From = vendor::no_from_t,
-			typename Where = vendor::no_where_t, 
-			typename GroupBy = vendor::no_group_by_t, 
-			typename Having = vendor::no_having_t,
-			typename OrderBy = vendor::no_order_by_t, 
-			typename Limit = vendor::no_limit_t, 
-			typename Offset = vendor::no_offset_t
+	template<typename Database,
+			typename FlagList, 
+			typename ColumnList, 
+			typename From,
+			typename Where, 
+			typename GroupBy, 
+			typename Having,
+			typename OrderBy, 
+			typename Limit, 
+			typename Offset
 				>
-		struct select_t: public detail::select_helper_t<ColumnList, From>::_value_type::template expression_operators<select_t<Database, FlagList, ColumnList, From, Where, GroupBy, Having, OrderBy, Limit, Offset>>
+		struct select_t: public detail::select_helper_t<ColumnList, From>::_value_type::template expression_operators<select_t<Database, FlagList, ColumnList, From, Where, GroupBy, Having, OrderBy, Limit, Offset>>,
+		Where::template _methods_t<detail::select_policies_t<Database, FlagList, ColumnList, From, Where, GroupBy, Having, OrderBy, Limit, Offset>>
 		{
 			using _database_t = Database;
 			using _is_dynamic = typename std::conditional<std::is_same<Database, void>::value, std::false_type, std::true_type>::type;
@@ -183,23 +232,6 @@ namespace sqlpp
 					return { *this, vendor::from_t<_database_t, Args...>{args...} };
 				}
 
-			template<typename... Args>
-				auto where(Args... args)
-				-> _policies_update_t<vendor::no_where_t, vendor::where_t<void, Args...>>
-				{
-					static_assert(is_noop_t<Where>::value, "cannot call where()/dynamic_where() twice");
-					return { *this, vendor::where_t<void, Args...>{args...} };
-				}
-
-			template<typename... Args>
-				auto dynamic_where(Args... args)
-				-> _policies_update_t<vendor::no_where_t, vendor::where_t<_database_t, Args...>>
-				{
-					static_assert(is_noop_t<Where>::value, "cannot call where()/dynamic_where() twice");
-					static_assert(not std::is_same<_database_t, void>::value, "dynamic_where must not be called in a static statement");
-					return { *this, vendor::where_t<_database_t, Args...>{args...} };
-				}
-
 			template<typename... Args>
 				auto group_by(Args... args)
 				-> _policies_update_t<vendor::no_group_by_t, vendor::group_by_t<void, Args...>>
@@ -308,14 +340,6 @@ namespace sqlpp
 					return _from.add_from(*this, args...);
 				}
 
-			template<typename... Args>
-				void add_where(Args... args)
-				{
-					static_assert(is_where_t<Where>::value, "cannot call add_where() before dynamic_where()");
-					static_assert(is_dynamic_t<Where>::value, "cannot call add_where() before dynamic_where()");
-					return _where.add_where(*this, args...);
-				}
-
 			template<typename... Args>
 				void add_group_by(Args... args)
 				{

include/sqlpp11/vendor/where.h

@@ -64,13 +64,17 @@ namespace sqlpp
 				where_t& operator=(where_t&&) = default;
 				~where_t() = default;
 
-				template<typename Statement, typename Expression>
-					void add_where(const Statement&, Expression expression)
+				template<typename Policies>
+					struct _methods_t
 					{
-						static_assert(_is_dynamic::value, "add_where can only be called for dynamic_where");
-						static_assert(is_expression_t<Expression>::value, "invalid expression argument in add_where()");
-						_dynamic_expressions.emplace_back(expression);
-					}
+						template<typename Expression>
+							void add_where(Expression expression)
+							{
+								static_assert(is_expression_t<Expression>::value, "invalid expression argument in add_where()");
+#warning: Need to dispatch to actual add method to prevent error messages from being generated
+								return static_cast<typename Policies::_select_t*>(this)->_where._dynamic_expressions.emplace_back(expression);
+							}
+					};
 
 				_parameter_tuple_t _expressions;
 				vendor::interpretable_list_t<Database> _dynamic_expressions;
@@ -93,6 +97,11 @@ namespace sqlpp
 				where_t& operator=(where_t&&) = default;
 				~where_t() = default;
 
+				template<typename Policies>
+					struct _methods_t
+					{
+					};
+
 				bool _condition;
 			};
 
@@ -100,6 +109,29 @@ namespace sqlpp
 		{
 			using _is_noop = std::true_type;
 			using _table_set = ::sqlpp::detail::type_set<>;
+
+			template<typename Policies>
+				struct _methods_t
+				{
+					using _database_t = typename Policies::_database_t;
+					template<typename T>
+					using _new_select_t = typename Policies::template _policies_update_t<no_where_t, T>;
+					template<typename... Args>
+						auto where(Args... args)
+						-> _new_select_t<where_t<void, Args...>>
+						{
+							return { *static_cast<typename Policies::_select_t*>(this), where_t<void, Args...>{args...} };
+						}
+
+					template<typename... Args>
+						auto dynamic_where(Args... args)
+						-> _new_select_t<where_t<_database_t, Args...>>
+						{
+							static_assert(not std::is_same<_database_t, void>::value, "dynamic_where must not be called in a static statement");
+							return { *static_cast<typename Policies::_select_t*>(this), vendor::where_t<_database_t, Args...>{args...} };
+						}
+
+				};
 		};
 
 		// Interpreters