Added table sets to several more expressions

include/sqlpp11/functions.h

@@ -47,6 +47,7 @@ namespace sqlpp
 	template<typename T>
 		auto value(T t) -> typename operand_t<T, is_value_t>::type
 		{
+			using _table_set = ::sqlpp::detail::type_set<>;
 			static_assert(not is_value_t<T>::value, "value() is to be called with non-sql-type like int, or string");
 			return { t };
 		}
@@ -55,6 +56,7 @@ namespace sqlpp
 	struct verbatim_t: public ValueType::template operators<verbatim_t<ValueType>>
 	{
 		using _value_type = ValueType;
+		using _table_set = ::sqlpp::detail::type_set<>;
 
 		verbatim_t(std::string verbatim): _verbatim(verbatim) {}
 		verbatim_t(const verbatim_t&) = default;
@@ -100,6 +102,7 @@ namespace sqlpp
 		struct value_list_t // to be used in .in() method
 		{
 			using _container_t = Container;
+			using _table_set = ::sqlpp::detail::type_set<>;// FIXME: Could it be something else?
 			using _value_type = typename operand_t<typename _container_t::value_type, is_value_t>::type::_value_type;
 
 			value_list_t(_container_t container):

include/sqlpp11/select.h

@@ -96,6 +96,7 @@ namespace sqlpp
 
 			using _parameter_tuple_t = std::tuple<FlagList, ColumnList, From, Where, GroupBy, Having, OrderBy, Limit, Offset>;
 			using _parameter_list_t = typename make_parameter_list_t<select_t>::type;
+			using _table_set = ::sqlpp::detail::type_set<>;
 			
 			using _column_list_t = ColumnList;
 			using _result_row_t = typename _column_list_t::_result_row_t;

include/sqlpp11/update.h

@@ -58,6 +58,7 @@ namespace sqlpp
 		struct update_t
 		{
 			static_assert(Table::_table_set::template is_superset_of<typename UpdateList::_table_set>::value, "updated columns do not match the table");
+			static_assert(Table::_table_set::template is_superset_of<typename Where::_table_set>::value, "where condition does not match updated table");
 
 			using _database_t = Database;
 			using _is_dynamic = typename std::conditional<std::is_same<Database, void>::value, std::false_type, std::true_type>::type;

include/sqlpp11/vendor/concat.h

@@ -40,6 +40,7 @@ namespace sqlpp
 		{
 			static_assert(sizeof...(Args) > 0, "concat requires two arguments at least");
 			static_assert(sqlpp::detail::and_t<is_text_t, First, Args...>::value, "at least one non-text argument detected in concat()");
+			using _table_set = typename ::sqlpp::detail::make_joined_set<typename First::_table_set, typename Args::_table_set...>::type;
 
 			struct _value_type: public First::_value_type::_base_value_type
 			{

include/sqlpp11/vendor/expression.h

@@ -44,6 +44,7 @@ namespace sqlpp
 		{
 			using _value_type = ::sqlpp::detail::boolean;
 			using _parameter_tuple_t = std::tuple<Lhs, Rhs>;
+			using _table_set = typename ::sqlpp::detail::make_joined_set<typename Lhs::_table_set, typename Rhs::_table_set>::type;
 
 			equal_t(Lhs lhs, Rhs rhs):
 				_lhs(lhs), 
@@ -88,6 +89,7 @@ namespace sqlpp
 		{
 			using _value_type = ::sqlpp::detail::boolean;
 			using _parameter_tuple_t = std::tuple<Lhs, Rhs>;
+			using _table_set = typename ::sqlpp::detail::make_joined_set<typename Lhs::_table_set, typename Rhs::_table_set>::type;
 
 			not_equal_t(Lhs lhs, Rhs rhs):
 				_lhs(lhs), 
@@ -132,6 +134,7 @@ namespace sqlpp
 		{
 			using _value_type = ::sqlpp::detail::boolean;
 			using _parameter_tuple_t = std::tuple<Lhs>;
+			using _table_set = typename Lhs::_table_set;
 
 			logical_not_t(Lhs l):
 				_lhs(l)
@@ -168,6 +171,7 @@ namespace sqlpp
 			using _rhs_t = Rhs;
 			using _value_type = typename O::_value_type;
 			using _parameter_tuple_t = std::tuple<_lhs_t, _rhs_t>;
+			using _table_set = typename ::sqlpp::detail::make_joined_set<typename Lhs::_table_set, typename Rhs::_table_set>::type;
 
 			binary_expression_t(_lhs_t lhs, _rhs_t rhs):
 				_lhs(lhs), 

include/sqlpp11/vendor/in.h

@@ -56,6 +56,7 @@ namespace sqlpp
 						T in;
 					};
 			};
+			using _table_set = typename ::sqlpp::detail::make_joined_set<typename Operand::_table_set, typename Args::_table_set...>::type;
 
 			in_t(Operand operand, Args... args):
 				_operand(operand),

include/sqlpp11/vendor/like.h

@@ -41,6 +41,7 @@ namespace sqlpp
 			static_assert(is_text_t<Operand>::value, "Operand for like() has to be a text");
 			static_assert(is_text_t<Pattern>::value, "Pattern for like() has to be a text");
 			using _parameter_tuple_t = std::tuple<Operand, Pattern>;
+			using _table_set = typename ::sqlpp::detail::make_joined_set<typename Operand::_table_set, typename Pattern::_table_set>::type;
 
 			struct _value_type: public boolean
 			{

include/sqlpp11/vendor/where.h

@@ -51,6 +51,8 @@ namespace sqlpp
 
 				using _parameter_list_t = typename make_parameter_list_t<_parameter_tuple_t>::type;
 
+				using _table_set = typename ::sqlpp::detail::make_joined_set<typename Expressions::_table_set...>::type;
+
 				where_t(Expressions... expressions):
 					_expressions(expressions...)
 				{}
@@ -95,6 +97,7 @@ namespace sqlpp
 		struct no_where_t
 		{
 			using _is_noop = std::true_type;
+			using _table_set = ::sqlpp::detail::type_set<>;
 		};
 
 		// Interpreters

tests/UpdateTest.cpp

@@ -59,8 +59,7 @@ int main()
 	interpret(update(t), printer).flush();
 	interpret(update(t).set(t.gamma = false), printer).flush();
 	interpret(update(t).set(t.gamma = false).where(t.beta != "transparent"), printer).flush();
-#warning make this fail
-	interpret(update(t).set(t.beta = "opaque").where(t.beta != f.delta), printer).flush();
+	interpret(update(t).set(t.beta = "opaque").where(t.beta != t.beta), printer).flush();
 	auto u = dynamic_update(db, t).dynamic_set(t.gamma = false).dynamic_where();
 	u.add_set(t.gamma = false);
 	interpret(u, printer).flush();