diff --git a/include/sqlpp11/update_list.h b/include/sqlpp11/update_list.h
index 26b6a7e7..e32b2400 100644
--- a/include/sqlpp11/update_list.h
+++ b/include/sqlpp11/update_list.h
@@ -191,33 +191,44 @@ namespace sqlpp
 			struct _methods_t
 			{
 				using _database_t = typename Policies::_database_t;
-				template<typename T>
-					using _new_statement_t = new_statement<Policies, no_update_list_t, T>;
+
+				template<typename... T>
+					using _check = detail::all_t<is_assignment_t<T>::value...>;
+
+				template<typename Check, typename T>
+					using _new_statement_t = new_statement_t<Check::value, Policies, no_update_list_t, T>;
 
 				using _consistency_check = assert_update_assignments_t;
 
 				template<typename... Assignments>
 					auto set(Assignments... assignments) const
-					-> _new_statement_t<update_list_t<void, Assignments...>>
+					-> _new_statement_t<_check<Assignments...>, update_list_t<void, Assignments...>>
 					{
 						static_assert(sizeof...(Assignments), "at least one assignment expression required in set()");
-						return _set_impl<void>(assignments...);
+						static_assert(_check<Assignments...>::value, "at least one argument is not an assignment in set()");
+
+						return _set_impl<void>(_check<Assignments...>{}, assignments...);
 					}
 
 				template<typename... Assignments>
 					auto dynamic_set(Assignments... assignments) const
-					-> _new_statement_t<update_list_t<_database_t, Assignments...>>
+					-> _new_statement_t<_check<Assignments...>, update_list_t<_database_t, Assignments...>>
 					{
 						static_assert(not std::is_same<_database_t, void>::value, "dynamic_set() must not be called in a static statement");
-						return _set_impl<_database_t>(assignments...);
+						static_assert(_check<Assignments...>::value, "at least one argument is not an assignment in set()");
+
+						return _set_impl<_database_t>(_check<Assignments...>{}, assignments...);
 					}
 
 			private:
 				template<typename Database, typename... Assignments>
-					auto _set_impl(Assignments... assignments) const
-					-> _new_statement_t<update_list_t<Database, Assignments...>>
+					auto _set_impl(const std::false_type&, Assignments... assignments) const
+					-> bad_statement;
+
+				template<typename Database, typename... Assignments>
+					auto _set_impl(const std::true_type&, Assignments... assignments) const
+					-> _new_statement_t<std::true_type, update_list_t<Database, Assignments...>>
 					{
-						static_assert(detail::all_t<is_assignment_t<Assignments>::value...>::value, "at least one argument is not an assignment in set()");
 						static_assert(not detail::has_duplicates<lhs_t<Assignments>...>::value, "at least one duplicate column detected in set()");
 						static_assert(detail::none_t<must_not_update_t<lhs_t<Assignments>>::value...>::value, "at least one assignment is prohibited by its column definition in set()");
 
diff --git a/include/sqlpp11/using.h b/include/sqlpp11/using.h
index cfc0858a..e743e0ae 100644
--- a/include/sqlpp11/using.h
+++ b/include/sqlpp11/using.h
@@ -62,12 +62,6 @@ namespace sqlpp
 
 			using _is_dynamic = is_database<Database>;
 
-			static_assert(_is_dynamic::value or sizeof...(Tables), "at least one table argument required in using()");
-
-			static_assert(not detail::has_duplicates<Tables...>::value, "at least one duplicate argument detected in using()");
-
-			static_assert(detail::all_t<is_table_t<Tables>::value...>::value, "at least one argument is not an table in using()");
-
 			// Data
 			using _data_t = using_data_t<Database, Tables...>;
 
@@ -165,25 +159,49 @@ namespace sqlpp
 			struct _methods_t
 			{
 				using _database_t = typename Policies::_database_t;
-				template<typename T>
-					using _new_statement_t = new_statement<Policies, no_using_t, T>;
+
+				template<typename... T>
+					using _check = detail::all_t<is_table_t<T>::value...>;
+
+				template<typename Check, typename T>
+					using _new_statement_t = new_statement_t<Check::value, Policies, no_using_t, T>;
 
 				using _consistency_check = consistent_t;
 
 				template<typename... Args>
 					auto using_(Args... args) const
-					-> _new_statement_t<using_t<void, Args...>>
+					-> _new_statement_t<_check<Args...>, using_t<void, Args...>>
 					{
-						return { static_cast<const derived_statement_t<Policies>&>(*this), using_data_t<void, Args...>{args...} };
+						static_assert(not detail::has_duplicates<Args...>::value, "at least one duplicate argument detected in using()");
+						static_assert(sizeof...(Args), "at least one table required in using()");
+						static_assert(_check<Args...>::value, "at least one argument is not an table in using()");
+
+						return { _using_impl<void>(_check<Args...>{}, args...) };
 					}
 
 				template<typename... Args>
 					auto dynamic_using(Args... args) const
-					-> _new_statement_t<using_t<_database_t, Args...>>
+					-> _new_statement_t<_check<Args...>, using_t<_database_t, Args...>>
 					{
 						static_assert(not std::is_same<_database_t, void>::value, "dynamic_using must not be called in a static statement");
-						return { static_cast<const derived_statement_t<Policies>&>(*this), using_data_t<_database_t, Args...>{args...} };
+						static_assert(_check<Args...>::value, "at least one argument is not an table in using()");
+
+						return { _using_impl<_database_t>(_check<Args...>{}, args...) };
 					}
+
+			private:
+				template<typename Database, typename... Args>
+					auto _using_impl(const std::false_type&, Args... args) const
+					-> bad_statement;
+
+				template<typename Database, typename... Args>
+					auto _using_impl(const std::true_type&, Args... args) const
+						-> _new_statement_t<std::true_type, using_t<_database_t, Args...>>
+						{
+							static_assert(not detail::has_duplicates<Args...>::value, "at least one duplicate argument detected in using()");
+
+							return { static_cast<const derived_statement_t<Policies>&>(*this), using_data_t<Database, Args...>{args...} };
+						};
 			};
 	};