Added support for unions inside SELECT FROM

Author: liuzicheng1987

include/sqlgen/dynamic/SelectFrom.hpp

@@ -18,7 +18,12 @@
 namespace sqlgen::dynamic {
 
 struct SelectFrom {
-  using TableOrQueryType = rfl::Variant<Table, Ref<SelectFrom>>;
+  struct Union {
+    std::vector<std::string> columns;
+    Ref<std::vector<SelectFrom>> selects;
+  };
+
+  using TableOrQueryType = rfl::Variant<Table, Ref<SelectFrom>, Ref<Union>>;
 
   struct Field {
     Operation val;

include/sqlgen/dynamic/Union.hpp

@@ -1,17 +1,11 @@
 #ifndef SQLGEN_DYNAMIC_UNION_HPP_
 #define SQLGEN_DYNAMIC_UNION_HPP_
 
-#include <string>
-#include <vector>
-
 #include "SelectFrom.hpp"
 
 namespace sqlgen::dynamic {
 
-struct Union {
-  std::vector<std::string> columns;
-  Ref<std::vector<SelectFrom>> selects;
-};
+using Union = SelectFrom::Union;
 
 }  // namespace sqlgen::dynamic
 

include/sqlgen/transpilation/fields_to_named_tuple_t.hpp

@@ -4,7 +4,9 @@
 #include <rfl.hpp>
 
 #include "../Literal.hpp"
+#include "../internal/all_same_v.hpp"
 #include "make_field.hpp"
+#include "table_tuple_t.hpp"
 
 namespace sqlgen::transpilation {
 
@@ -38,6 +40,19 @@ struct FieldsToNamedTupleType<StructType, rfl::Tuple<FieldTypes...>> {
   using Type = typename FieldsToNamedTupleType<StructType, FieldTypes...>::Type;
 };
 
+template <class... SelectTs>
+struct FieldsToNamedTupleType<rfl::Tuple<SelectTs...>> {
+  using NamedTupleTypes = rfl::Tuple<typename FieldsToNamedTupleType<
+      table_tuple_t<typename SelectTs::TableOrQueryType,
+                    typename SelectTs::AliasType, typename SelectTs::JoinsType>,
+      typename SelectTs::FieldsType>::Type...>;
+  static_assert(
+      sqlgen::internal::all_same_v<NamedTupleTypes>,
+      "All SELECT statements in a UNION must return the same columns with "
+      "the same types.");
+  using Type = rfl::tuple_element_t<0, NamedTupleTypes>;
+};
+
 template <class StructType, class... FieldTypes>
 using fields_to_named_tuple_t =
     typename FieldsToNamedTupleType<StructType, FieldTypes...>::Type;

include/sqlgen/transpilation/to_union.hpp

@@ -14,8 +14,8 @@
 
 namespace sqlgen::transpilation {
 
-template <class ContainerType, class... Selects>
-dynamic::Union to_union(const rfl::Tuple<Selects...>& _selects) noexcept {
+template <class ContainerType, class... SelectTs>
+dynamic::Union to_union(const rfl::Tuple<SelectTs...>& _selects) noexcept {
   using ValueType = value_t<ContainerType>;
   using NamedTupleType = rfl::named_tuple_t<ValueType>;
 
@@ -25,14 +25,15 @@ dynamic::Union to_union(const rfl::Tuple<Selects...>& _selects) noexcept {
       [](const auto... _s) {
         return Ref<std::vector<dynamic::SelectFrom>>::make(
             std::vector<dynamic::SelectFrom>({to_select_from<
-                table_tuple_t<typename Selects::TableOrQueryType,
-                              typename Selects::AliasType,
-                              typename Selects::JoinsType>,
-                typename Selects::AliasType, typename Selects::FieldsType,
-                typename Selects::TableOrQueryType, typename Selects::JoinsType,
-                typename Selects::WhereType, typename Selects::GroupByType,
-                typename Selects::OrderByType, typename Selects::LimitType>(
-                _s.fields_, _s.from_, _s.joins_, _s.where_, _s.limit_)...}));
+                table_tuple_t<typename SelectTs::TableOrQueryType,
+                              typename SelectTs::AliasType,
+                              typename SelectTs::JoinsType>,
+                typename SelectTs::AliasType, typename SelectTs::FieldsType,
+                typename SelectTs::TableOrQueryType,
+                typename SelectTs::JoinsType, typename SelectTs::WhereType,
+                typename SelectTs::GroupByType, typename SelectTs::OrderByType,
+                typename SelectTs::LimitType>(_s.fields_, _s.from_, _s.joins_,
+                                              _s.where_, _s.limit_)...}));
       },
       _selects);
 

include/sqlgen/unite.hpp

@@ -8,21 +8,19 @@
 #include "Ref.hpp"
 #include "Result.hpp"
 #include "dynamic/Union.hpp"
-#include "internal/all_same_v.hpp"
 #include "internal/is_range.hpp"
 #include "internal/iterator_t.hpp"
 #include "is_connection.hpp"
 #include "transpilation/fields_to_named_tuple_t.hpp"
-#include "transpilation/table_tuple_t.hpp"
 #include "transpilation/to_union.hpp"
 #include "transpilation/value_t.hpp"
 
 namespace sqlgen {
 
-template <class ContainerType, class Connection, class... Selects>
+template <class ContainerType, class Connection, class... SelectTs>
   requires is_connection<Connection>
 auto unite_impl(const Ref<Connection>& _conn,
-                const rfl::Tuple<Selects...>& _selects) {
+                const rfl::Tuple<SelectTs...>& _selects) {
   if constexpr (internal::is_range_v<ContainerType>) {
     const auto query = transpilation::to_union<ContainerType>(_selects);
     return _conn->template read<ContainerType>(query);
@@ -42,32 +40,28 @@ auto unite_impl(const Ref<Connection>& _conn,
       return container;
     };
 
-    using NamedTupleTypes = rfl::Tuple<transpilation::fields_to_named_tuple_t<
-        transpilation::table_tuple_t<typename Selects::TableOrQueryType,
-                                     typename Selects::AliasType,
-                                     typename Selects::JoinsType>,
-        typename Selects::FieldsType>...>;
-
-    static_assert(
-        internal::all_same_v<NamedTupleTypes>,
-        "All SELECT statements in a UNION must return the same columns with "
-        "the same types.");
-
-    using IteratorType =
-        internal::iterator_t<rfl::tuple_element_t<0, NamedTupleTypes>,
-                             decltype(_conn)>;
+    using IteratorType = internal::iterator_t<
+        transpilation::fields_to_named_tuple_t<rfl::Tuple<SelectTs...>>,
+        decltype(_conn)>;
 
     using RangeType = Range<IteratorType>;
 
     return unite_impl<RangeType>(_conn, _selects).and_then(to_container);
   }
 }
 
-template <class ContainerType, class... Selects>
+template <class _ContainerType, class... SelectTs>
 struct Union {
   template <class Connection>
     requires is_connection<Connection>
   auto operator()(const Ref<Connection>& _conn) const {
+    using ContainerType = std::conditional_t<
+        std::is_same_v<std::remove_cvref_t<_ContainerType>, Nothing>,
+        Range<internal::iterator_t<
+            transpilation::fields_to_named_tuple_t<rfl::Tuple<SelectTs...>>,
+            Connection>>,
+        _ContainerType>;
+
     return unite_impl<ContainerType>(_conn, selects_);
   }
 
@@ -77,12 +71,37 @@ struct Union {
     return _res.and_then([&](const auto& _conn) { return (*this)(_conn); });
   }
 
-  rfl::Tuple<Selects...> selects_;
+  rfl::Tuple<SelectTs...> selects_;
+};
+
+namespace transpilation {
+
+template <class ContainerType, class... SelectTs>
+struct ExtractTable<Union<ContainerType, SelectTs...>, false> {
+  using Type = std::conditional_t<
+      std::is_same_v<std::remove_cvref_t<ContainerType>, Nothing>,
+      transpilation::fields_to_named_tuple_t<rfl::Tuple<SelectTs...>>,
+      transpilation::value_t<ContainerType>>;
 };
 
-template <class ContainerType, class... Selects>
-auto unite(const Selects&... _selects) {
-  return Union<ContainerType, Selects...>{rfl::Tuple<Selects...>(_selects...)};
+template <class ContainerType, class... SelectTs>
+struct ToTableOrQuery<Union<ContainerType, SelectTs...>> {
+  dynamic::SelectFrom::TableOrQueryType operator()(const auto& _query) {
+    return transpilation::to_union<ContainerType>(_query.selects_);
+  }
+};
+
+}  // namespace transpilation
+
+template <class ContainerType, class... SelectTs>
+auto unite(const SelectTs&... _selects) {
+  return Union<ContainerType, SelectTs...>{
+      rfl::Tuple<SelectTs...>(_selects...)};
+}
+
+template <class... SelectTs>
+auto unite(const SelectTs&... _selects) {
+  return unite<Nothing>(_selects...);
 }
 
 }  // namespace sqlgen

src/sqlgen/sqlite/to_sql.cpp

@@ -722,6 +722,10 @@ std::string table_or_query_to_sql(
         return wrap_in_quotes(*_t.schema) + "." + wrap_in_quotes(_t.name);
       }
       return wrap_in_quotes(_t.name);
+
+    } else if constexpr (std::is_same_v<Type, Ref<dynamic::Union>>) {
+      return "(" + union_to_sql(*_t) + ")";
+
     } else {
       return "(" + select_from_to_sql(*_t) + ")";
     }

tests/sqlite/test_union.cpp

@@ -29,7 +29,7 @@ TEST(sqlite, test_union) {
   using namespace sqlgen::literals;
 
   // Connect to SQLite database
-  const auto conn = sqlgen::sqlite::connect("test.db");
+  const auto conn = sqlgen::sqlite::connect();
 
   // Create and insert a user
   const auto user1 = User1{.name = "John", .age = 30};

tests/sqlite/test_union_in_select_from.cpp

@@ -0,0 +1,15 @@
+#include <gtest/gtest.h>
+
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/sqlite.hpp>
+#include <vector>
+
+#include "sqlgen/sqlite/to_sql.hpp"
+
+namespace test_union_in_select_from {
+
+TEST(sqlite, test_union_in_select_from) {}
+
+}  // namespace test_union_in_select_from