Fixed UNION DISTINCT to not serialize DISTINCT

sqlite3 does not support the keyword in UNION, and for others DISTINCT is the default
anywy

include/sqlpp11/type_traits.h

@@ -83,6 +83,7 @@ namespace sqlpp
 	SQLPP_VALUE_TRAIT_GENERATOR(is_multi_expression)
 	SQLPP_VALUE_TRAIT_GENERATOR(is_alias)
 	SQLPP_VALUE_TRAIT_GENERATOR(is_select_flag)
+	SQLPP_VALUE_TRAIT_GENERATOR(is_union_flag)
 	SQLPP_VALUE_TRAIT_GENERATOR(is_result_field)
 
 	SQLPP_VALUE_TRAIT_GENERATOR(must_not_insert)

include/sqlpp11/union.h

@@ -28,7 +28,7 @@
 #define SQLPP_UNION_H
 
 #include <sqlpp11/union_data.h>
-#include <sqlpp11/select_flags.h>
+#include <sqlpp11/union_flags.h>
 #include <sqlpp11/statement_fwd.h>
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/parameter_list.h>
@@ -154,7 +154,7 @@ namespace sqlpp
 
 				template<typename Rhs>
 					auto union_distinct(Rhs rhs) const
-					-> _new_statement_t<_check<Rhs>, union_t<void, distinct_t, derived_statement_t<Policies>, Rhs>>
+					-> _new_statement_t<_check<Rhs>, union_t<void, union_distinct_t, derived_statement_t<Policies>, Rhs>>
 					{
 						static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
 						static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@@ -165,12 +165,12 @@ namespace sqlpp
 						static_assert(std::is_same<get_result_row_t<derived_statement_t<Policies>>, _result_row_t>::value, "both arguments in a union have to have the same result columns (type and name)");
 						static_assert(is_static_result_row_t<_result_row_t>::value, "unions must not have dynamically added columns");
 
-						return _union_impl<void, distinct_t>(_check<derived_statement_t<Policies>, Rhs>{}, rhs);
+						return _union_impl<void, union_distinct_t>(_check<derived_statement_t<Policies>, Rhs>{}, rhs);
 					}
 
 				template<typename Rhs>
 					auto union_all(Rhs rhs) const
-					-> _new_statement_t<_check<Rhs>, union_t<void, all_t, derived_statement_t<Policies>, Rhs>>
+					-> _new_statement_t<_check<Rhs>, union_t<void, union_all_t, derived_statement_t<Policies>, Rhs>>
 					{
 						static_assert(is_statement_t<Rhs>::value, "argument of union call has to be a statement");
 						static_assert(has_policy_t<Rhs, is_select_t>::value, "argument of union call has to be a select");
@@ -181,7 +181,7 @@ namespace sqlpp
 						static_assert(std::is_same<get_result_row_t<derived_statement_t<Policies>>, _result_row_t>::value, "both arguments in a union have to have the same result columns (type and name)");
 						static_assert(is_static_result_row_t<_result_row_t>::value, "unions must not have dynamically added columns");
 
-						return _union_impl<void, all_t>(_check<derived_statement_t<Policies>, Rhs>{}, rhs);
+						return _union_impl<void, union_all_t>(_check<derived_statement_t<Policies>, Rhs>{}, rhs);
 					}
 
 			private:

include/sqlpp11/union_data.h

@@ -58,13 +58,11 @@ namespace sqlpp
 
 			static Context& _(const T& t, Context& context)
 			{
-				context << '(';
 				serialize(t._lhs, context);
-				context << ") UNION ";
+				context << " UNION ";
 				serialize(Flag{}, context);
-				context << " (";
+				context << " ";
 				serialize(t._rhs, context);
-				context << ')';
 				return context;
 			}
 		};

include/sqlpp11/union_flags.h

@@ -0,0 +1,75 @@
+/*
+ * 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_UNION_FLAGS_H
+#define SQLPP_UNION_FLAGS_H
+
+#include <sqlpp11/type_traits.h>
+#include <sqlpp11/detail/type_set.h>
+#include <sqlpp11/interpret_tuple.h>
+#include <tuple>
+
+namespace sqlpp
+{
+	// standard select flags
+	struct union_all_t
+	{
+		using _traits = make_traits<no_value_t, tag::is_union_flag>;
+		using _nodes = detail::type_vector<>;
+	};
+
+	template<typename Context>
+		struct serializer_t<Context, union_all_t>
+		{
+			using _serialize_check = consistent_t;
+
+			static Context& _(const union_all_t&, Context& context)
+			{
+				context << "ALL";
+				return context;
+			}
+		};
+
+	struct union_distinct_t
+	{
+		using _traits = make_traits<no_value_t, tag::is_union_flag>;
+		using _nodes = detail::type_vector<>;
+	};
+
+	template<typename Context>
+		struct serializer_t<Context, union_distinct_t>
+		{
+			using _serialize_check = consistent_t;
+
+			static Context& _(const union_distinct_t&, Context& context)
+			{
+				return context;
+			}
+		};
+
+}
+
+#endif