diff --git a/include/sqlpp11/core/basic/parameter.h b/include/sqlpp11/core/basic/parameter.h
index e8753391..00b45605 100644
--- a/include/sqlpp11/core/basic/parameter.h
+++ b/include/sqlpp11/core/basic/parameter.h
@@ -81,7 +81,7 @@ namespace sqlpp
       -> parameter_t<value_type_of_t<ValueType>, NameTagProvider>
   {
     static_assert(has_value_type<ValueType>::value, "first argument is not a value type");
-    static_assert(has_name<NameTagProvider>::value, "second argument does not have a name");
+    static_assert(has_name_tag<NameTagProvider>::value, "second argument does not have a name");
     return {};
   }
 }  // namespace sqlpp
diff --git a/include/sqlpp11/core/name/name_tag.h b/include/sqlpp11/core/name/name_tag.h
index 770220a6..293ae1a6 100644
--- a/include/sqlpp11/core/name/name_tag.h
+++ b/include/sqlpp11/core/name/name_tag.h
@@ -54,9 +54,8 @@ namespace sqlpp
   template <typename T>
   using name_tag_of_t = typename name_tag_of<T>::type;
 
-#warning: rename to has_name_tag
   // Override this for other classes like columns or tables.
   template<typename T>
-  struct has_name : public std::integral_constant<bool, not std::is_same<name_tag_of_t<T>, no_name_t>::value> {};
+  struct has_name_tag : public std::integral_constant<bool, not std::is_same<name_tag_of_t<T>, no_name_t>::value> {};
 
 }  // namespace sqlpp
diff --git a/include/sqlpp11/core/operator/expression_as.h b/include/sqlpp11/core/operator/expression_as.h
index 000eb957..ad7701d6 100644
--- a/include/sqlpp11/core/operator/expression_as.h
+++ b/include/sqlpp11/core/operator/expression_as.h
@@ -84,7 +84,7 @@ namespace sqlpp
 
   template <typename Expr, typename NameTagProvider>
   using check_as_args = ::sqlpp::enable_if_t<
-  has_value_type<Expr>::value and not is_alias_t<Expr>::value and has_name<NameTagProvider>::value
+  has_value_type<Expr>::value and not is_alias_t<Expr>::value and has_name_tag<NameTagProvider>::value
   >;
 
   template <typename Expr, typename NameTagProvider, typename = check_as_args<Expr, NameTagProvider>>
diff --git a/include/sqlpp11/core/tuple_to_sql_string.h b/include/sqlpp11/core/tuple_to_sql_string.h
index 2d7e2033..7ef7bbf1 100644
--- a/include/sqlpp11/core/tuple_to_sql_string.h
+++ b/include/sqlpp11/core/tuple_to_sql_string.h
@@ -100,7 +100,7 @@ namespace sqlpp
       {
         return operator()(context, t._expr, index);
       }
-      static_assert(has_name<T>::value, "select columns have to have a name");
+      static_assert(has_name_tag<T>::value, "select columns have to have a name");
       return operator()(context, as(sqlpp::nullopt, t._expr), index);
     }
 
diff --git a/tests/core/types/aggregate_function/avg.cpp b/tests/core/types/aggregate_function/avg.cpp
index 2fb69887..165283dc 100644
--- a/tests/core/types/aggregate_function/avg.cpp
+++ b/tests/core/types/aggregate_function/avg.cpp
@@ -56,8 +56,8 @@ void test_avg(Value v)
   static_assert(sqlpp::has_enabled_as<decltype(avg(sqlpp::distinct, v_not_null))>::value, "");
 
   // avg has a name
-  static_assert(sqlpp::has_name<decltype(avg(v_not_null))>::value, "");
-  static_assert(sqlpp::has_name<decltype(avg(sqlpp::distinct, v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(avg(v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(avg(sqlpp::distinct, v_not_null))>::value, "");
 
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(avg(v_not_null))>, sqlpp::alias::_avg_t::_sqlpp_name_tag>::value, "");
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(avg(sqlpp::distinct, v_not_null))>, sqlpp::alias::_avg_t::_sqlpp_name_tag>::value, "");
diff --git a/tests/core/types/aggregate_function/count.cpp b/tests/core/types/aggregate_function/count.cpp
index 8aff7c02..a42403c5 100644
--- a/tests/core/types/aggregate_function/count.cpp
+++ b/tests/core/types/aggregate_function/count.cpp
@@ -54,8 +54,8 @@ void test_count(Value v)
   static_assert(sqlpp::has_enabled_as<decltype(sqlpp::distinct, count(v_not_null))>::value, "");
 
   // count has a name
-  static_assert(sqlpp::has_name<decltype(count(v_not_null))>::value, "");
-  static_assert(sqlpp::has_name<decltype(count(sqlpp::distinct, v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(count(v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(count(sqlpp::distinct, v_not_null))>::value, "");
 
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(count(v_not_null))>, sqlpp::alias::_count_t::_sqlpp_name_tag>::value, "");
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(count(sqlpp::distinct, v_not_null))>, sqlpp::alias::_count_t::_sqlpp_name_tag>::value, "");
diff --git a/tests/core/types/aggregate_function/max.cpp b/tests/core/types/aggregate_function/max.cpp
index fd02b67a..ebe30fd8 100644
--- a/tests/core/types/aggregate_function/max.cpp
+++ b/tests/core/types/aggregate_function/max.cpp
@@ -56,8 +56,8 @@ void test_max(Value v)
   static_assert(sqlpp::has_enabled_as<decltype(sqlpp::distinct, max(v_not_null))>::value, "");
 
   // max has a name
-  static_assert(sqlpp::has_name<decltype(max(v_not_null))>::value, "");
-  static_assert(sqlpp::has_name<decltype(max(sqlpp::distinct, v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(max(v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(max(sqlpp::distinct, v_not_null))>::value, "");
 
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(max(v_not_null))>, sqlpp::alias::_max_t::_sqlpp_name_tag>::value, "");
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(max(sqlpp::distinct, v_not_null))>, sqlpp::alias::_max_t::_sqlpp_name_tag>::value, "");
diff --git a/tests/core/types/aggregate_function/min.cpp b/tests/core/types/aggregate_function/min.cpp
index e6e26d5f..fe66d5af 100644
--- a/tests/core/types/aggregate_function/min.cpp
+++ b/tests/core/types/aggregate_function/min.cpp
@@ -56,8 +56,8 @@ void test_min(Value v)
   static_assert(sqlpp::has_enabled_as<decltype(sqlpp::distinct, min(v_not_null))>::value, "");
 
   // min has a name
-  static_assert(sqlpp::has_name<decltype(min(v_not_null))>::value, "");
-  static_assert(sqlpp::has_name<decltype(min(sqlpp::distinct, v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(min(v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(min(sqlpp::distinct, v_not_null))>::value, "");
 
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(min(v_not_null))>, sqlpp::alias::_min_t::_sqlpp_name_tag>::value, "");
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(min(sqlpp::distinct, v_not_null))>, sqlpp::alias::_min_t::_sqlpp_name_tag>::value, "");
diff --git a/tests/core/types/aggregate_function/over.cpp b/tests/core/types/aggregate_function/over.cpp
index 617fde60..707cc60a 100644
--- a/tests/core/types/aggregate_function/over.cpp
+++ b/tests/core/types/aggregate_function/over.cpp
@@ -59,9 +59,9 @@ void test_aggregate_functions(Value v)
   static_assert(sqlpp::has_enabled_as<decltype(min(v_not_null).over())>::value, "");
 
   // Aggregate functions have a name
-  static_assert(sqlpp::has_name<decltype(count(v_not_null).over())>::value, "");
-  static_assert(sqlpp::has_name<decltype(max(v_not_null).over())>::value, "");
-  static_assert(sqlpp::has_name<decltype(min(v_not_null).over())>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(count(v_not_null).over())>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(max(v_not_null).over())>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(min(v_not_null).over())>::value, "");
 
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(count(v_not_null).over())>, sqlpp::alias::_count_t::_sqlpp_name_tag>::value, "");
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(min(v_not_null).over())>, sqlpp::alias::_min_t::_sqlpp_name_tag>::value, "");
@@ -107,8 +107,8 @@ void test_numeric_aggregate_functions(Value v)
   static_assert(sqlpp::has_enabled_as<decltype(avg(v_not_null).over())>::value, "");
 
   // Aggregate functions have a name
-  static_assert(sqlpp::has_name<decltype(sum(v_not_null).over())>::value, "");
-  static_assert(sqlpp::has_name<decltype(avg(v_not_null).over())>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(sum(v_not_null).over())>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(avg(v_not_null).over())>::value, "");
 
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(sum(v_not_null).over())>, sqlpp::alias::_sum_t::_sqlpp_name_tag>::value, "");
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(avg(v_not_null).over())>, sqlpp::alias::_avg_t::_sqlpp_name_tag>::value, "");
diff --git a/tests/core/types/aggregate_function/sum.cpp b/tests/core/types/aggregate_function/sum.cpp
index ad0bb0b9..77b5f647 100644
--- a/tests/core/types/aggregate_function/sum.cpp
+++ b/tests/core/types/aggregate_function/sum.cpp
@@ -57,8 +57,8 @@ void test_sum(Value v)
   static_assert(sqlpp::has_enabled_as<decltype(sum(sqlpp::distinct, v_not_null))>::value, "");
 
   // sum has a name
-  static_assert(sqlpp::has_name<decltype(sum(v_not_null))>::value, "");
-  static_assert(sqlpp::has_name<decltype(sum(sqlpp::distinct, v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(sum(v_not_null))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(sum(sqlpp::distinct, v_not_null))>::value, "");
 
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(sum(v_not_null))>, sqlpp::alias::_sum_t::_sqlpp_name_tag>::value, "");
   static_assert(std::is_same<sqlpp::name_tag_of_t<decltype(sum(sqlpp::distinct, v_not_null))>, sqlpp::alias::_sum_t::_sqlpp_name_tag>::value, "");
diff --git a/tests/core/types/clause/select_columns.cpp b/tests/core/types/clause/select_columns.cpp
index c397bc91..8a320e36 100644
--- a/tests/core/types/clause/select_columns.cpp
+++ b/tests/core/types/clause/select_columns.cpp
@@ -126,7 +126,7 @@ void test_select_columns()
   // The columns in group_by determine if aggregates are correct or not.
   {
     using T = clause_of_t<decltype(select_columns(col_int, col_txt, col_bool))>;
-    static_assert(not sqlpp::has_name<T>::value, "");
+    static_assert(not sqlpp::has_name_tag<T>::value, "");
     static_assert(not sqlpp::has_value_type<T>::value, "");
     static_assert(sqlpp::is_result_clause<T>::value, "");
     static_assert(sqlpp::has_correct_aggregates<unknown, T>::value, "");
@@ -138,7 +138,7 @@ void test_select_columns()
   // The columns in group_by determine if aggregates are correct or not.
   {
     using T = clause_of_t<decltype(select_columns(col_int, max(col_txt), declare_group_by_column(v).as(cheese)))>;
-    static_assert(not sqlpp::has_name<T>::value, "");
+    static_assert(not sqlpp::has_name_tag<T>::value, "");
     static_assert(not sqlpp::has_value_type<T>::value, "");
     static_assert(sqlpp::is_result_clause<T>::value, "");
     static_assert(not sqlpp::has_correct_aggregates<unknown, T>::value, "");
diff --git a/tests/core/types/dynamic.cpp b/tests/core/types/dynamic.cpp
index 62b9397e..c6fd9001 100644
--- a/tests/core/types/dynamic.cpp
+++ b/tests/core/types/dynamic.cpp
@@ -54,10 +54,10 @@ void test_dynamic(Value v)
   static_assert(not sqlpp::has_value_type<decltype(v_not_null_alias)>::value, "");
   static_assert(not sqlpp::has_value_type<decltype(v_maybe_null_alias)>::value, "");
 
-  static_assert(not sqlpp::has_name<decltype(v_not_null)>::value, "");
-  static_assert(not sqlpp::has_name<decltype(v_maybe_null)>::value, "");
-  static_assert(not sqlpp::has_name<decltype(v_not_null_alias)>::value, "");
-  static_assert(not sqlpp::has_name<decltype(v_maybe_null_alias)>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_not_null)>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_maybe_null)>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_not_null_alias)>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_maybe_null_alias)>::value, "");
 
   static_assert(is_select_column_value_type<decltype(v_not_null), OptValueType>::value, "");
   static_assert(is_select_column_value_type<decltype(v_maybe_null), OptValueType>::value, "");
diff --git a/tests/core/types/operator/assign_expression.cpp b/tests/core/types/operator/assign_expression.cpp
index 8288d73d..4a267f11 100644
--- a/tests/core/types/operator/assign_expression.cpp
+++ b/tests/core/types/operator/assign_expression.cpp
@@ -53,9 +53,9 @@ void test_assign_expression(const Column& col, const Value& v)
   static_assert(not sqlpp::has_value_type<decltype(col = v_maybe_null)>::value, "");
 
   // Assignments have no name
-  static_assert(not sqlpp::has_name<decltype(col = sqlpp::default_value)>::value, "");
-  static_assert(not sqlpp::has_name<decltype(col = v_not_null)>::value, "");
-  static_assert(not sqlpp::has_name<decltype(col = v_maybe_null)>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(col = sqlpp::default_value)>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(col = v_not_null)>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(col = v_maybe_null)>::value, "");
 
   // Assignment nodes
   static_assert(std::is_same<sqlpp::nodes_of_t<decltype(col = sqlpp::default_value)>,
diff --git a/tests/core/types/operator/expression_as.cpp b/tests/core/types/operator/expression_as.cpp
index 87b039b6..a9ea2f10 100644
--- a/tests/core/types/operator/expression_as.cpp
+++ b/tests/core/types/operator/expression_as.cpp
@@ -46,10 +46,10 @@ void test_as_expression(Value v)
   static_assert(not sqlpp::has_value_type<decltype(v_dynamic_not_null.as(cheese))>::value, "");
   static_assert(not sqlpp::has_value_type<decltype(v_dynamic_maybe_null.as(cheese))>::value, "");
 
-  static_assert(not sqlpp::has_name<decltype(v_not_null.as(cheese))>::value, "");
-  static_assert(not sqlpp::has_name<decltype(v_maybe_null.as(cheese))>::value, "");
-  static_assert(not sqlpp::has_name<decltype(v_dynamic_not_null.as(cheese))>::value, "");
-  static_assert(not sqlpp::has_name<decltype(v_dynamic_maybe_null.as(cheese))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_not_null.as(cheese))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_maybe_null.as(cheese))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_dynamic_not_null.as(cheese))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_dynamic_maybe_null.as(cheese))>::value, "");
 
   static_assert(is_select_column_value_type<decltype(v_not_null.as(cheese)), ValueType>::value, "");
   static_assert(is_select_column_value_type<decltype(v_maybe_null.as(cheese)), OptValueType>::value, "");
diff --git a/tests/core/types/operator/sort_order_expression.cpp b/tests/core/types/operator/sort_order_expression.cpp
index 4786b56a..60e6e258 100644
--- a/tests/core/types/operator/sort_order_expression.cpp
+++ b/tests/core/types/operator/sort_order_expression.cpp
@@ -52,10 +52,10 @@ void test_as_expression(Value v)
   static_assert(not sqlpp::has_value_type<decltype(dynamic(true, v_maybe_null.order(sqlpp::sort_type::asc)))>::value, "");
 
   // Sort order expressions have no name.
-  static_assert(not sqlpp::has_name<decltype(v_not_null.asc())>::value, "");
-  static_assert(not sqlpp::has_name<decltype(v_maybe_null.asc())>::value, "");
-  static_assert(not sqlpp::has_name<decltype(dynamic(true, v_not_null.asc()))>::value, "");
-  static_assert(not sqlpp::has_name<decltype(dynamic(true, v_maybe_null.asc()))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_not_null.asc())>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(v_maybe_null.asc())>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(dynamic(true, v_not_null.asc()))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(dynamic(true, v_maybe_null.asc()))>::value, "");
 
   // Sort order expression do not enable the `as` member function.
   static_assert(not sqlpp::has_enabled_as<decltype(v_not_null.asc())>::value, "");
diff --git a/tests/core/types/result_row.cpp b/tests/core/types/result_row.cpp
index 455687a4..02d56d60 100644
--- a/tests/core/types/result_row.cpp
+++ b/tests/core/types/result_row.cpp
@@ -124,7 +124,7 @@ int main()
   static_assert(std::is_same<sqlpp::value_type_of_t<decltype(assign(bar.intN, sqlpp::default_value))>, sqlpp::no_value_t>::value, "");
 
   // as expressions retain the value type of the real thing
-  static_assert(sqlpp::has_name<decltype(bar.intN)>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(bar.intN)>::value, "");
   sqlpp::as(bar.intN, bar.textN);
 
 #if 0
diff --git a/tests/core/types/select_as.cpp b/tests/core/types/select_as.cpp
index ab91a731..11f742da 100644
--- a/tests/core/types/select_as.cpp
+++ b/tests/core/types/select_as.cpp
@@ -58,8 +58,8 @@ void test_select_as(Value v)
   static_assert(is_same_type<decltype(select(v_maybe_null)), OptValueType>(), "");
 
   // A select of a single value can be named and used as a named value.
-  static_assert(sqlpp::has_name<decltype(select(v_not_null).as(column))>::value, "");
-  static_assert(sqlpp::has_name<decltype(select(v_maybe_null).as(column))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(select(v_not_null).as(column))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(select(v_maybe_null).as(column))>::value, "");
 
   static_assert(is_same_type<decltype(select(v_not_null).as(column)), ValueType>(), "");
   static_assert(is_same_type<decltype(select(v_maybe_null).as(column)), OptValueType>(), "");
@@ -69,15 +69,15 @@ void test_select_as(Value v)
   static_assert(sqlpp::is_table<decltype(select(v_maybe_null).as(column))>::value, "");
 
   // The column of a single-value pseudo table can be used as named value
-  static_assert(sqlpp::has_name<decltype(select(v_not_null).as(column).always)>::value, "");
-  static_assert(sqlpp::has_name<decltype(select(v_maybe_null).as(column).sometimes)>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(select(v_not_null).as(column).always)>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(select(v_maybe_null).as(column).sometimes)>::value, "");
 
   static_assert(is_same_type<decltype(select(v_not_null).as(column).always), ValueType>(), "");
   static_assert(is_same_type<decltype(select(v_maybe_null).as(column).sometimes), OptValueType>(), "");
 
   // The column of a single-value pseudo table can be renamed and used as named value
-  static_assert(not sqlpp::has_name<decltype(select(v_not_null).as(column).always.as(foo))>::value, "");
-  static_assert(not sqlpp::has_name<decltype(select(v_maybe_null).as(column).sometimes.as(foo))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(select(v_not_null).as(column).always.as(foo))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(select(v_maybe_null).as(column).sometimes.as(foo))>::value, "");
 
   static_assert(sqlpp::select_column_has_name<decltype(select(v_not_null).as(column).always.as(foo))>::value, "");
   static_assert(sqlpp::select_column_has_name<decltype(select(v_maybe_null).as(column).sometimes.as(foo))>::value, "");
@@ -91,22 +91,22 @@ void test_select_as(Value v)
   static_assert(not sqlpp::has_value_type<decltype(select(v_not_null, v_maybe_null))>::value, "");
 
   // A select of multiple values can be named and used as a named value.
-  static_assert(sqlpp::has_name<decltype(select(v_not_null, v_maybe_null).as(column))>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(select(v_not_null, v_maybe_null).as(column))>::value, "");
   static_assert(not sqlpp::has_value_type<decltype(select(v_not_null, v_maybe_null).as(column))>::value, "");
 
   // A select of multiple values can be named and used as a pseudo table
   static_assert(sqlpp::is_table<decltype(select(v_not_null, v_maybe_null).as(table))>::value, "");
 
   // The column of a multi-value pseudo table can be used as named value
-  static_assert(sqlpp::has_name<decltype(select(v_not_null, v_maybe_null).as(table).always)>::value, "");
-  static_assert(sqlpp::has_name<decltype(select(v_not_null, v_maybe_null).as(table).sometimes)>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(select(v_not_null, v_maybe_null).as(table).always)>::value, "");
+  static_assert(sqlpp::has_name_tag<decltype(select(v_not_null, v_maybe_null).as(table).sometimes)>::value, "");
 
   static_assert(is_same_type<decltype(select(v_not_null, v_maybe_null).as(table).always), ValueType>(), "");
   static_assert(is_same_type<decltype(select(v_not_null, v_maybe_null).as(table).sometimes), OptValueType>(), "");
 
   // The column of a multi-value pseudo table can be renamed and used as named value
-  static_assert(not sqlpp::has_name<decltype(select(v_not_null, v_maybe_null).as(table).always.as(foo))>::value, "");
-  static_assert(not sqlpp::has_name<decltype(select(v_not_null, v_maybe_null).as(table).sometimes.as(foo))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(select(v_not_null, v_maybe_null).as(table).always.as(foo))>::value, "");
+  static_assert(not sqlpp::has_name_tag<decltype(select(v_not_null, v_maybe_null).as(table).sometimes.as(foo))>::value, "");
 
   static_assert(sqlpp::select_column_has_name<decltype(select(v_not_null, v_maybe_null).as(table).always.as(foo))>::value, "");
   static_assert(sqlpp::select_column_has_name<decltype(select(v_not_null, v_maybe_null).as(table).sometimes.as(foo))>::value, "");