Added support for UNION and UNION ALL

docs/README.md

@@ -29,6 +29,7 @@ Welcome to the sqlgen documentation. This guide provides detailed information ab
 - [sqlgen::inner_join, sqlgen::left_join, sqlgen::right_join, sqlgen::full_join](joins.md) - How to join different tables
 - [sqlgen::insert](insert.md) - How to insert data within transactions
 - [sqlgen::select_from](select_from.md) - How to read data from a database using more complex queries
+- [sqlgen::unite and sqlgen::unite_all](unite.md) - How to combine results from multiple SELECT statements
 - [sqlgen::update](update.md) - How to update data in a table
 
 ## Other Operations

docs/unite.md

@@ -0,0 +1,80 @@
+# `unite` and `unite_all`
+
+The `unite` and `unite_all` functions allow you to combine the results of multiple `SELECT` statements into a single result set.
+
+## `unite`
+
+The `unite` function corresponds to the SQL `UNION` operator. It combines the result sets of two or more `SELECT` statements and removes duplicate rows.
+
+### Example
+
+```cpp
+struct User1 {
+  std::string name;
+  int age;
+};
+
+struct User2 {
+  std::string name;
+  int age;
+};
+
+const auto s1 = sqlgen::select_from<User1>("name"_c, "age"_c);
+const auto s2 = sqlgen::select_from<User2>("name"_c, "age"_c);
+
+const auto united = sqlgen::unite<std::vector<User1>>(s1, s2);
+```
+
+## `unite_all`
+
+The `unite_all` function corresponds to the SQL `UNION ALL` operator. It combines the result sets of two or more `SELECT` statements, including all duplicate rows.
+
+### Example
+
+```cpp
+struct User1 {
+  std::string name;
+  int age;
+};
+
+struct User2 {
+  std::string name;
+  int age;
+};
+
+const auto s1 = sqlgen::select_from<User1>("name"_c, "age"_c);
+const auto s2 = sqlgen::select_from<User2>("name"_c, "age"_c);
+
+const auto united = sqlgen::unite_all<std::vector<User1>>(s1, s2);
+```
+
+## Nesting in `SELECT` statements
+
+You can use the result of a `unite` or `unite_all` operation as a subquery in a `SELECT` statement.
+
+### Example
+
+```cpp
+const auto united = sqlgen::unite<std::vector<User1>>(s1, s2);
+
+const auto sel = sqlgen::select_from(united.as("u"), "name"_c, "age"_c);
+```
+
+## Nesting in `JOIN` statements
+
+You can also use the result of a `unite` or `unite_all` operation as a subquery in a `JOIN` statement.
+
+### Example
+
+```cpp
+struct Login {
+  int id;
+  std::string username;
+};
+
+const auto united = sqlgen::unite<std::vector<User1>>(s1, s2);
+
+const auto sel = select_from<Login, "t1">("id"_t1, "username"_t1) |
+                 inner_join<"t2">(united, "username"_t1 == "name"_t2) |
+                 where("id"_t1 == 1) | to<std::vector<Login>>;
+```

include/sqlgen.hpp

@@ -45,6 +45,7 @@
 #include "sqlgen/select_from.hpp"
 #include "sqlgen/sqlgen_api.hpp"
 #include "sqlgen/to.hpp"
+#include "sqlgen/unite.hpp"
 #include "sqlgen/update.hpp"
 #include "sqlgen/where.hpp"
 #include "sqlgen/write.hpp"

include/sqlgen/duckdb/Connection.hpp

@@ -72,10 +72,11 @@ class SQLGEN_API Connection {
   }
 
   template <class ContainerType>
-  auto read(const dynamic::SelectFrom &_query) {
+  auto read(const rfl::Variant<dynamic::SelectFrom, dynamic::Union> &_query) {
     using ValueType = transpilation::value_t<ContainerType>;
+    const auto sql = _query.visit([&](const auto &_q) { return to_sql(_q); });
     return internal::to_container<ContainerType, Iterator<ValueType>>(
-        Iterator<ValueType>(to_sql(_query), conn_));
+        Iterator<ValueType>(sql, conn_));
   }
 
   Result<Nothing> rollback() noexcept;

include/sqlgen/dynamic/SelectFrom.hpp

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

include/sqlgen/dynamic/Statement.hpp

@@ -10,14 +10,15 @@
 #include "Drop.hpp"
 #include "Insert.hpp"
 #include "SelectFrom.hpp"
+#include "Union.hpp"
 #include "Update.hpp"
 #include "Write.hpp"
 
 namespace sqlgen::dynamic {
 
 using Statement =
     rfl::TaggedUnion<"stmt", CreateAs, CreateIndex, CreateTable, DeleteFrom,
-                     Drop, Insert, SelectFrom, Update, Write>;
+                     Drop, Insert, SelectFrom, Union, Update, Write>;
 
 }  // namespace sqlgen::dynamic
 

include/sqlgen/dynamic/Union.hpp

@@ -0,0 +1,12 @@
+#ifndef SQLGEN_DYNAMIC_UNION_HPP_
+#define SQLGEN_DYNAMIC_UNION_HPP_
+
+#include "SelectFrom.hpp"
+
+namespace sqlgen::dynamic {
+
+using Union = SelectFrom::Union;
+
+}  // namespace sqlgen::dynamic
+
+#endif

include/sqlgen/internal/GetColType.hpp

@@ -17,12 +17,18 @@ struct GetColType {
   static Type get_value(const T& _t) { return _t; }
 };
 
-template <rfl::internal::StringLiteral _name>
-struct GetColType<Col<_name>> {
-  using Type = transpilation::Col<_name>;
-  static Type get_value(const auto&) { return transpilation::Col<_name>{}; }
+template <rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias>
+struct GetColType<Col<_name, _alias>> {
+  using Type = transpilation::Col<_name, _alias>;
+  static Type get_value(const auto&) {
+    return transpilation::Col<_name, _alias>{};
+  }
 };
 
+template <class T>
+using get_col_type_t = typename GetColType<T>::Type;
+
 }  // namespace sqlgen::internal
 
 #endif

include/sqlgen/internal/all_same_v.hpp

@@ -0,0 +1,23 @@
+#include <rfl.hpp>
+#include <tuple>
+#include <type_traits>
+
+namespace sqlgen::internal {
+
+template <class TupleT>
+struct AllSame;
+
+template <class Head, class... Tail>
+struct AllSame<std::tuple<Head, Tail...>> {
+  static constexpr bool value = std::conjunction_v<std::is_same<Head, Tail>...>;
+};
+
+template <class Head, class... Tail>
+struct AllSame<rfl::Tuple<Head, Tail...>> {
+  static constexpr bool value = std::conjunction_v<std::is_same<Head, Tail>...>;
+};
+
+template <class TupleT>
+constexpr bool all_same_v = AllSame<std::remove_cvref_t<TupleT>>::value;
+
+}  // namespace sqlgen::internal

include/sqlgen/mysql/Connection.hpp

@@ -13,7 +13,10 @@
 #include "../Result.hpp"
 #include "../Transaction.hpp"
 #include "../dynamic/Column.hpp"
+#include "../dynamic/Insert.hpp"
+#include "../dynamic/SelectFrom.hpp"
 #include "../dynamic/Statement.hpp"
+#include "../dynamic/Union.hpp"
 #include "../dynamic/Write.hpp"
 #include "../internal/to_container.hpp"
 #include "../internal/write_or_insert.hpp"
@@ -54,7 +57,7 @@ class SQLGEN_API Connection {
   }
 
   template <class ContainerType>
-  auto read(const dynamic::SelectFrom& _query) {
+  auto read(const rfl::Variant<dynamic::SelectFrom, dynamic::Union>& _query) {
     using ValueType = transpilation::value_t<ContainerType>;
     return internal::to_container<ContainerType>(
         read_impl(_query).transform([](auto&& _it) {
@@ -94,7 +97,8 @@ class SQLGEN_API Connection {
       const std::variant<dynamic::Insert, dynamic::Write>& _stmt)
       const noexcept;
 
-  Result<Ref<Iterator>> read_impl(const dynamic::SelectFrom& _query);
+  Result<Ref<Iterator>> read_impl(
+      const rfl::Variant<dynamic::SelectFrom, dynamic::Union>& _query);
 
   Result<Nothing> write_impl(
       const std::vector<std::vector<std::optional<std::string>>>& _data);

include/sqlgen/postgres/Connection.hpp

@@ -4,16 +4,21 @@
 #include <libpq-fe.h>
 
 #include <memory>
+#include <optional>
 #include <rfl.hpp>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 #include "../Iterator.hpp"
 #include "../Ref.hpp"
 #include "../Result.hpp"
 #include "../Transaction.hpp"
 #include "../dynamic/Column.hpp"
+#include "../dynamic/Insert.hpp"
+#include "../dynamic/SelectFrom.hpp"
 #include "../dynamic/Statement.hpp"
+#include "../dynamic/Union.hpp"
 #include "../dynamic/Write.hpp"
 #include "../internal/iterator_t.hpp"
 #include "../internal/to_container.hpp"
@@ -57,7 +62,7 @@ class SQLGEN_API Connection {
   }
 
   template <class ContainerType>
-  auto read(const dynamic::SelectFrom& _query) {
+  auto read(const rfl::Variant<dynamic::SelectFrom, dynamic::Union>& _query) {
     using ValueType = transpilation::value_t<ContainerType>;
     return internal::to_container<ContainerType>(
         read_impl(_query).transform([](auto&& _it) {
@@ -86,7 +91,8 @@ class SQLGEN_API Connection {
       const std::vector<std::vector<std::optional<std::string>>>&
           _data) noexcept;
 
-  Result<Ref<Iterator>> read_impl(const dynamic::SelectFrom& _query);
+  Result<Ref<Iterator>> read_impl(
+      const rfl::Variant<dynamic::SelectFrom, dynamic::Union>& _query);
 
   std::string to_buffer(
       const std::vector<std::optional<std::string>>& _line) const noexcept;