diff --git a/docs/README.md b/docs/README.md
index 3f99bab..fa03d0e 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -25,6 +25,7 @@ Welcome to the sqlgen documentation. This guide provides detailed information ab
 - [sqlgen::exec](exec.md) - How to execute raw SQL statements
 - [sqlgen::group_by and Aggregations](group_by_and_aggregations.md) - How generate GROUP BY queries and aggregate data
 - [sqlgen::insert](insert.md) - How to insert data within transactions
+- [Joins](joins.md) - How to join different tables
 - [sqlgen::update](update.md) - How to update data in a table
 
 ## Other Operations
diff --git a/docs/joins.md b/docs/joins.md
new file mode 100644
index 0000000..70482d7
--- /dev/null
+++ b/docs/joins.md
@@ -0,0 +1,199 @@
+# `sqlgen::inner_join`, `sqlgen::left_join`, `sqlgen::right_join`, `sqlgen::full_join`
+
+The `sqlgen` library provides a type-safe, composable interface for expressing SQL joins in C++. It supports all standard SQL join types (inner, left, right, full) and allows for both simple and nested join queries, including joining on subqueries.
+
+## Join Types
+
+The following join types are available:
+
+- `inner_join` — Returns rows when there is a match in both tables
+- `left_join` — Returns all rows from the left table, and matched rows from the right table
+- `right_join` — Returns all rows from the right table, and matched rows from the left table
+- `full_join` — Returns all rows when there is a match in one of the tables
+
+Each join type can be used with either a table or a subquery, and can be aliased for use in complex queries.
+
+## Usage
+
+### Basic Join Example
+
+```cpp
+using namespace sqlgen;
+
+struct Person {
+    sqlgen::PrimaryKey<uint32_t> id;
+    std::string first_name;
+    std::string last_name;
+    double age;
+};
+
+struct Relationship {
+    sqlgen::PrimaryKey<uint32_t> parent_id;
+    sqlgen::PrimaryKey<uint32_t> child_id;
+};
+
+// Join two tables: Relationship (as t1) and Person (as t2)
+const auto get_children =
+    select_from<Relationship, "t1">(
+        "parent_id"_t1 | as<"id">,
+        "first_name"_t2 | as<"first_name">,
+        "age"_t2 | as<"age">
+    ) |
+    left_join<Person, "t2">("id"_t2 == "child_id"_t1);
+```
+
+This produces a query equivalent to:
+
+```sql
+SELECT t1."parent_id" AS "id", t2."first_name" AS "first_name", t2."age" AS "age"
+FROM "Relationship" t1
+LEFT JOIN "Person" t2 ON t2."id" = t1."child_id"
+```
+
+### Chaining Multiple Joins
+
+You can chain multiple joins to build more complex queries:
+
+```cpp
+const auto get_people =
+    select_from<Person, "t1">(
+        "last_name"_t1 | as<"last_name">,
+        "first_name"_t3 | as<"first_name_child">,
+        avg("age"_t1 - "age"_t3) | as<"avg_parent_age_at_birth">
+    ) |
+    inner_join<Relationship, "t2">("id"_t1 == "parent_id"_t2) |
+    left_join<Person, "t3">("id"_t3 == "child_id"_t2) |
+    group_by("last_name"_t1, "first_name"_t3) |
+    order_by("last_name"_t1, "first_name"_t3) |
+    to<std::vector<ParentAndChild>>;
+```
+
+This produces a query with both an inner and a left join, grouping and ordering the results.
+
+### Nested Joins and Subqueries
+
+`sqlgen` allows you to join on subqueries, enabling nested join patterns:
+
+```cpp
+const auto get_children =
+    select_from<Relationship, "t1">(
+        "parent_id"_t1 | as<"id">,
+        "first_name"_t2 | as<"first_name">,
+        "age"_t2 | as<"age">
+    ) |
+    left_join<Person, "t2">("id"_t2 == "child_id"_t1);
+
+const auto get_people =
+    select_from<Person, "t1">(
+        "last_name"_t1 | as<"last_name">,
+        "first_name"_t2 | as<"first_name_child">,
+        avg("age"_t1 - "age"_t2) | as<"avg_parent_age_at_birth">
+    ) |
+    inner_join<"t2">(get_children, "id"_t1 == "id"_t2) |
+    group_by("last_name"_t1, "first_name"_t2) |
+    order_by("first_name"_t2) |
+    to<std::vector<ParentAndChild>>;
+```
+
+This produces a query with a subquery in the join clause:
+
+```sql
+SELECT t1."last_name" AS "last_name", t2."first_name" AS "first_name_child", AVG((t1."age") - (t2."age")) AS "avg_parent_age_at_birth"
+FROM "Person" t1
+INNER JOIN (
+    SELECT t1."parent_id" AS "id", t2."first_name" AS "first_name", t2."age" AS "age"
+    FROM "Relationship" t1
+    LEFT JOIN "Person" t2 ON t2."id" = t1."child_id"
+) t2 ON t1."id" = t2."id"
+GROUP BY t1."last_name", t2."first_name"
+ORDER BY t2."first_name"
+```
+
+## Join Syntax
+
+- `inner_join<Table, Alias>(condition)` — Inner join with a table
+- `left_join<Table, Alias>(condition)` — Left join with a table
+- `right_join<Table, Alias>(condition)` — Right join with a table
+- `full_join<Table, Alias>(condition)` — Full join with a table
+- `inner_join<Alias>(subquery, condition)` — Inner join with a subquery
+- `left_join<Alias>(subquery, condition)` — Left join with a subquery
+- `right_join<Alias>(subquery, condition)` — Right join with a subquery
+- `full_join<Alias>(subquery, condition)` — Full join with a subquery
+
+Where:
+- `Table` is the C++ struct representing the table
+- `Alias` is a string literal alias for the table or subquery
+- `condition` is a boolean expression relating columns from the joined tables
+- `subquery` is a previously constructed query expression
+
+## Aliasing and Column References
+
+When joining tables or subqueries, you must use aliases to disambiguate columns. Use the `_t1`, `_t2`, etc. suffixes to refer to columns from different tables or subqueries:
+
+```cpp
+"id"_t1, "first_name"_t2, "age"_t3
+```
+
+The library includes predefined suffixes from `_t1` to `_t99`.
+
+If you want to use your own alias, you can use this syntax instead:
+
+```cpp
+col<"id", "your_alias">, col<"first_name", "your_alias">, col<"age", "your_alias">
+```
+
+## Advanced: Nested and Grouped Joins
+
+You can nest joins and combine them with grouping and aggregation:
+
+```cpp
+const auto get_people =
+    select_from<Person, "t1">(
+        "last_name"_t1 | as<"last_name">,
+        "first_name"_t2 | as<"first_name_child">,
+        avg("age"_t1 - "age"_t2) | as<"avg_parent_age_at_birth">
+    ) |
+    inner_join<"t2">(get_children, "id"_t1 == "id"_t2) |
+    group_by("last_name"_t1, "first_name"_t2) |
+    order_by("first_name"_t2) |
+    to<std::vector<ParentAndChild>>;
+```
+
+## Notes
+
+- Joins can be chained and nested arbitrarily
+- Aliases are required for all joined tables and subqueries
+- Join conditions must use the correct aliases for columns
+- You can join on subqueries, enabling powerful query composition
+- Joins can be combined with `group_by`, `order_by`, and aggregation functions
+- The result type must match the structure of your select statement, with field names matching the aliases used in the query
+
+## Example: Full Nested Join Query
+
+```cpp
+struct ParentAndChild {
+    std::string last_name;
+    std::string first_name_child;
+    double avg_parent_age_at_birth;
+};
+
+const auto get_children =
+    select_from<Relationship, "t1">("parent_id"_t1 | as<"id">,
+                                    "first_name"_t2 | as<"first_name">,
+                                    "age"_t2 | as<"age">) |
+    left_join<Person, "t2">("id"_t2 == "child_id"_t1);
+
+const auto get_people =
+    select_from<Person, "t1">(
+        "last_name"_t1 | as<"last_name">,
+        "first_name"_t2 | as<"first_name_child">,
+        avg("age"_t1 - "age"_t2) | as<"avg_parent_age_at_birth">
+    ) |
+    inner_join<"t2">(get_children, "id"_t1 == "id"_t2) |
+    group_by("last_name"_t1, "first_name"_t2) |
+    order_by("first_name"_t2) |
+    to<std::vector<ParentAndChild>>;
+```
+
+This query joins a table to a subquery, groups by two columns, and computes an aggregate over the join.
+
diff --git a/include/sqlgen.hpp b/include/sqlgen.hpp
index ed75e19..60f21cb 100644
--- a/include/sqlgen.hpp
+++ b/include/sqlgen.hpp
@@ -29,6 +29,7 @@
 #include "sqlgen/if_not_exists.hpp"
 #include "sqlgen/insert.hpp"
 #include "sqlgen/is_connection.hpp"
+#include "sqlgen/joins.hpp"
 #include "sqlgen/limit.hpp"
 #include "sqlgen/operations.hpp"
 #include "sqlgen/order_by.hpp"
diff --git a/include/sqlgen/col.hpp b/include/sqlgen/col.hpp
index e2ad471..67d63fd 100644
--- a/include/sqlgen/col.hpp
+++ b/include/sqlgen/col.hpp
@@ -19,20 +19,22 @@
 
 namespace sqlgen {
 
-template <rfl::internal::StringLiteral _name>
+template <rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias = "">
 struct Col {
-  using ColType = transpilation::Col<_name>;
+  using ColType = transpilation::Col<_name, _alias>;
   using Name = rfl::Literal<_name>;
+  using Alias = rfl::Literal<_alias>;
 
   template <rfl::internal::StringLiteral _new_name>
   auto as() const noexcept {
-    return transpilation::As<transpilation::Col<_name>, _new_name>{
-        .val = transpilation::Col<_name>{}};
+    return transpilation::As<transpilation::Col<_name, _alias>, _new_name>{
+        .val = transpilation::Col<_name, _alias>{}};
   }
 
   /// Signals to order_by that this column is to be sorted in descending order.
   auto desc() const noexcept {
-    return transpilation::Desc<transpilation::Col<_name>>{};
+    return transpilation::Desc<transpilation::Col<_name, _alias>>{};
   }
 
   /// Returns the column name.
@@ -40,72 +42,76 @@ struct Col {
 
   /// Returns an IS NULL condition.
   auto is_null() const noexcept {
-    return transpilation::make_condition(
-        transpilation::conditions::is_null(transpilation::Col<_name>{}));
+    return transpilation::make_condition(transpilation::conditions::is_null(
+        transpilation::Col<_name, _alias>{}));
   }
 
   /// Returns a IS NOT NULL condition.
   auto is_not_null() const noexcept {
-    return transpilation::make_condition(
-        transpilation::conditions::is_not_null(transpilation::Col<_name>{}));
+    return transpilation::make_condition(transpilation::conditions::is_not_null(
+        transpilation::Col<_name, _alias>{}));
   }
 
   /// Returns a LIKE condition.
   auto like(const std::string& _pattern) const noexcept {
-    return transpilation::make_condition(
-        transpilation::conditions::like(transpilation::Col<_name>{}, _pattern));
+    return transpilation::make_condition(transpilation::conditions::like(
+        transpilation::Col<_name, _alias>{}, _pattern));
   }
 
   /// Returns a NOT LIKE condition.
   auto not_like(const std::string& _pattern) const noexcept {
     return transpilation::make_condition(transpilation::conditions::not_like(
-        transpilation::Col<_name>{}, _pattern));
+        transpilation::Col<_name, _alias>{}, _pattern));
   }
 
   /// Returns a SET clause in an UPDATE statement.
   template <class T>
   auto set(const T& _to) const noexcept {
-    return transpilation::Set<transpilation::Col<_name>,
+    return transpilation::Set<transpilation::Col<_name, _alias>,
                               std::remove_cvref_t<T>>{.to = _to};
   }
 
   /// Returns a SET clause in an UPDATE statement.
-  template <rfl::internal::StringLiteral _other_name>
-  auto set(const Col<_other_name>& _to) const noexcept {
-    return transpilation::Set<transpilation::Col<_name>,
-                              transpilation::Col<_other_name>>{
-        .to = transpilation::Col<_other_name>{}};
+  template <rfl::internal::StringLiteral _other_name,
+            rfl::internal::StringLiteral _other_alias>
+  auto set(const Col<_other_name, _other_alias>& _to) const noexcept {
+    return transpilation::Set<transpilation::Col<_name, _alias>,
+                              transpilation::Col<_other_name, _other_alias>>{
+        .to = transpilation::Col<_other_name, _other_alias>{}};
   }
 
   /// Returns a SET clause in an UPDATE statement.
   auto set(const char* _to) const noexcept {
-    return transpilation::Set<transpilation::Col<_name>, std::string>{.to =
-                                                                          _to};
+    return transpilation::Set<transpilation::Col<_name, _alias>, std::string>{
+        .to = _to};
   }
 
   template <class T>
   friend auto operator==(const Col&, const T& _t) {
     return transpilation::make_condition(transpilation::conditions::equal(
-        transpilation::Col<_name>{}, transpilation::to_transpilation_type(_t)));
+        transpilation::Col<_name, _alias>{},
+        transpilation::to_transpilation_type(_t)));
   }
 
   template <class T>
   friend auto operator!=(const Col&, const T& _t) {
     return transpilation::make_condition(transpilation::conditions::not_equal(
-        transpilation::Col<_name>{}, transpilation::to_transpilation_type(_t)));
+        transpilation::Col<_name, _alias>{},
+        transpilation::to_transpilation_type(_t)));
   }
 
   template <class T>
   friend auto operator<(const Col&, const T& _t) {
     return transpilation::make_condition(transpilation::conditions::lesser_than(
-        transpilation::Col<_name>{}, transpilation::to_transpilation_type(_t)));
+        transpilation::Col<_name, _alias>{},
+        transpilation::to_transpilation_type(_t)));
   }
 
   template <class T>
   friend auto operator<=(const Col&, const T& _t) {
     return transpilation::make_condition(
         transpilation::conditions::lesser_equal(
-            transpilation::Col<_name>{},
+            transpilation::Col<_name, _alias>{},
             transpilation::to_transpilation_type(_t)));
   }
 
@@ -113,7 +119,7 @@ struct Col {
   friend auto operator>(const Col&, const T& _t) {
     return transpilation::make_condition(
         transpilation::conditions::greater_than(
-            transpilation::Col<_name>{},
+            transpilation::Col<_name, _alias>{},
             transpilation::to_transpilation_type(_t)));
   }
 
@@ -121,7 +127,7 @@ struct Col {
   friend auto operator>=(const Col&, const T& _t) {
     return transpilation::make_condition(
         transpilation::conditions::greater_equal(
-            transpilation::Col<_name>{},
+            transpilation::Col<_name, _alias>{},
             transpilation::to_transpilation_type(_t)));
   }
 
@@ -131,8 +137,9 @@ struct Col {
         std::remove_cvref_t<T>>::Type;
 
     return transpilation::Operation<transpilation::Operator::divides,
-                                    transpilation::Col<_name>, OtherType>{
-        .operand1 = transpilation::Col<_name>{},
+                                    transpilation::Col<_name, _alias>,
+                                    OtherType>{
+        .operand1 = transpilation::Col<_name, _alias>{},
         .operand2 = transpilation::to_transpilation_type(_op2)};
   }
 
@@ -147,8 +154,9 @@ struct Col {
           std::remove_cvref_t<T>>::Type;
 
       return transpilation::Operation<transpilation::Operator::minus,
-                                      transpilation::Col<_name>, OtherType>{
-          .operand1 = transpilation::Col<_name>{},
+                                      transpilation::Col<_name, _alias>,
+                                      OtherType>{
+          .operand1 = transpilation::Col<_name, _alias>{},
           .operand2 = transpilation::to_transpilation_type(_op2)};
     }
   }
@@ -159,8 +167,9 @@ struct Col {
         std::remove_cvref_t<T>>::Type;
 
     return transpilation::Operation<transpilation::Operator::mod,
-                                    transpilation::Col<_name>, OtherType>{
-        .operand1 = transpilation::Col<_name>{},
+                                    transpilation::Col<_name, _alias>,
+                                    OtherType>{
+        .operand1 = transpilation::Col<_name, _alias>{},
         .operand2 = transpilation::to_transpilation_type(_op2)};
   }
 
@@ -170,8 +179,9 @@ struct Col {
         std::remove_cvref_t<T>>::Type;
 
     return transpilation::Operation<transpilation::Operator::multiplies,
-                                    transpilation::Col<_name>, OtherType>{
-        .operand1 = transpilation::Col<_name>{},
+                                    transpilation::Col<_name, _alias>,
+                                    OtherType>{
+        .operand1 = transpilation::Col<_name, _alias>{},
         .operand2 = transpilation::to_transpilation_type(_op2)};
   }
 
@@ -181,8 +191,8 @@ struct Col {
       using DurationType = std::remove_cvref_t<T>;
       return transpilation::Operation<
           transpilation::Operator::date_plus_duration,
-          transpilation::Col<_name>, rfl::Tuple<DurationType>>{
-          .operand1 = transpilation::Col<_name>{},
+          transpilation::Col<_name, _alias>, rfl::Tuple<DurationType>>{
+          .operand1 = transpilation::Col<_name, _alias>{},
           .operand2 = rfl::Tuple<DurationType>(_op2)};
 
     } else {
@@ -190,33 +200,141 @@ struct Col {
           std::remove_cvref_t<T>>::Type;
 
       return transpilation::Operation<transpilation::Operator::plus,
-                                      transpilation::Col<_name>, OtherType>{
-          .operand1 = transpilation::Col<_name>{},
+                                      transpilation::Col<_name, _alias>,
+                                      OtherType>{
+          .operand1 = transpilation::Col<_name, _alias>{},
           .operand2 = transpilation::to_transpilation_type(_op2)};
     }
   }
 };
 
-template <rfl::internal::StringLiteral _name>
-const auto col = Col<_name>{};
+template <rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias = "">
+const auto col = Col<_name, _alias>{};
+
+namespace transpilation {
+
+template <rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias>
+struct ToTranspilationType<sqlgen::Col<_name, _alias>> {
+  using Type = transpilation::Col<_name, _alias>;
+
+  Type operator()(const auto&) const noexcept {
+    return transpilation::Col<_name, _alias>{};
+  }
+};
+}  // namespace transpilation
 
 template <rfl::internal::StringLiteral _name>
 auto operator"" _c() {
   return Col<_name>{};
 }
 
-namespace transpilation {
-
-template <rfl::internal::StringLiteral _name>
-struct ToTranspilationType<sqlgen::Col<_name>> {
-  using Type = transpilation::Col<_name>;
-
-  Type operator()(const auto&) const noexcept {
-    return transpilation::Col<_name>{};
+#define SQLGEN_TABLE_ALIAS_LITERAL(N)           \
+  template <rfl::internal::StringLiteral _name> \
+  auto operator""_t##N() {                      \
+    return Col<_name, "t" #N>{};                \
   }
-};
 
-}  // namespace transpilation
+SQLGEN_TABLE_ALIAS_LITERAL(1)
+SQLGEN_TABLE_ALIAS_LITERAL(2)
+SQLGEN_TABLE_ALIAS_LITERAL(3)
+SQLGEN_TABLE_ALIAS_LITERAL(4)
+SQLGEN_TABLE_ALIAS_LITERAL(5)
+SQLGEN_TABLE_ALIAS_LITERAL(6)
+SQLGEN_TABLE_ALIAS_LITERAL(7)
+SQLGEN_TABLE_ALIAS_LITERAL(8)
+SQLGEN_TABLE_ALIAS_LITERAL(9)
+SQLGEN_TABLE_ALIAS_LITERAL(10)
+SQLGEN_TABLE_ALIAS_LITERAL(11)
+SQLGEN_TABLE_ALIAS_LITERAL(12)
+SQLGEN_TABLE_ALIAS_LITERAL(13)
+SQLGEN_TABLE_ALIAS_LITERAL(14)
+SQLGEN_TABLE_ALIAS_LITERAL(15)
+SQLGEN_TABLE_ALIAS_LITERAL(16)
+SQLGEN_TABLE_ALIAS_LITERAL(17)
+SQLGEN_TABLE_ALIAS_LITERAL(18)
+SQLGEN_TABLE_ALIAS_LITERAL(19)
+SQLGEN_TABLE_ALIAS_LITERAL(20)
+SQLGEN_TABLE_ALIAS_LITERAL(21)
+SQLGEN_TABLE_ALIAS_LITERAL(22)
+SQLGEN_TABLE_ALIAS_LITERAL(23)
+SQLGEN_TABLE_ALIAS_LITERAL(24)
+SQLGEN_TABLE_ALIAS_LITERAL(25)
+SQLGEN_TABLE_ALIAS_LITERAL(26)
+SQLGEN_TABLE_ALIAS_LITERAL(27)
+SQLGEN_TABLE_ALIAS_LITERAL(28)
+SQLGEN_TABLE_ALIAS_LITERAL(29)
+SQLGEN_TABLE_ALIAS_LITERAL(30)
+SQLGEN_TABLE_ALIAS_LITERAL(31)
+SQLGEN_TABLE_ALIAS_LITERAL(32)
+SQLGEN_TABLE_ALIAS_LITERAL(33)
+SQLGEN_TABLE_ALIAS_LITERAL(34)
+SQLGEN_TABLE_ALIAS_LITERAL(35)
+SQLGEN_TABLE_ALIAS_LITERAL(36)
+SQLGEN_TABLE_ALIAS_LITERAL(37)
+SQLGEN_TABLE_ALIAS_LITERAL(38)
+SQLGEN_TABLE_ALIAS_LITERAL(39)
+SQLGEN_TABLE_ALIAS_LITERAL(40)
+SQLGEN_TABLE_ALIAS_LITERAL(41)
+SQLGEN_TABLE_ALIAS_LITERAL(42)
+SQLGEN_TABLE_ALIAS_LITERAL(43)
+SQLGEN_TABLE_ALIAS_LITERAL(44)
+SQLGEN_TABLE_ALIAS_LITERAL(45)
+SQLGEN_TABLE_ALIAS_LITERAL(46)
+SQLGEN_TABLE_ALIAS_LITERAL(47)
+SQLGEN_TABLE_ALIAS_LITERAL(48)
+SQLGEN_TABLE_ALIAS_LITERAL(49)
+SQLGEN_TABLE_ALIAS_LITERAL(50)
+SQLGEN_TABLE_ALIAS_LITERAL(51)
+SQLGEN_TABLE_ALIAS_LITERAL(52)
+SQLGEN_TABLE_ALIAS_LITERAL(53)
+SQLGEN_TABLE_ALIAS_LITERAL(54)
+SQLGEN_TABLE_ALIAS_LITERAL(55)
+SQLGEN_TABLE_ALIAS_LITERAL(56)
+SQLGEN_TABLE_ALIAS_LITERAL(57)
+SQLGEN_TABLE_ALIAS_LITERAL(58)
+SQLGEN_TABLE_ALIAS_LITERAL(59)
+SQLGEN_TABLE_ALIAS_LITERAL(60)
+SQLGEN_TABLE_ALIAS_LITERAL(61)
+SQLGEN_TABLE_ALIAS_LITERAL(62)
+SQLGEN_TABLE_ALIAS_LITERAL(63)
+SQLGEN_TABLE_ALIAS_LITERAL(64)
+SQLGEN_TABLE_ALIAS_LITERAL(65)
+SQLGEN_TABLE_ALIAS_LITERAL(66)
+SQLGEN_TABLE_ALIAS_LITERAL(67)
+SQLGEN_TABLE_ALIAS_LITERAL(68)
+SQLGEN_TABLE_ALIAS_LITERAL(69)
+SQLGEN_TABLE_ALIAS_LITERAL(70)
+SQLGEN_TABLE_ALIAS_LITERAL(71)
+SQLGEN_TABLE_ALIAS_LITERAL(72)
+SQLGEN_TABLE_ALIAS_LITERAL(73)
+SQLGEN_TABLE_ALIAS_LITERAL(74)
+SQLGEN_TABLE_ALIAS_LITERAL(75)
+SQLGEN_TABLE_ALIAS_LITERAL(76)
+SQLGEN_TABLE_ALIAS_LITERAL(77)
+SQLGEN_TABLE_ALIAS_LITERAL(78)
+SQLGEN_TABLE_ALIAS_LITERAL(79)
+SQLGEN_TABLE_ALIAS_LITERAL(80)
+SQLGEN_TABLE_ALIAS_LITERAL(81)
+SQLGEN_TABLE_ALIAS_LITERAL(82)
+SQLGEN_TABLE_ALIAS_LITERAL(83)
+SQLGEN_TABLE_ALIAS_LITERAL(84)
+SQLGEN_TABLE_ALIAS_LITERAL(85)
+SQLGEN_TABLE_ALIAS_LITERAL(86)
+SQLGEN_TABLE_ALIAS_LITERAL(87)
+SQLGEN_TABLE_ALIAS_LITERAL(88)
+SQLGEN_TABLE_ALIAS_LITERAL(89)
+SQLGEN_TABLE_ALIAS_LITERAL(90)
+SQLGEN_TABLE_ALIAS_LITERAL(91)
+SQLGEN_TABLE_ALIAS_LITERAL(92)
+SQLGEN_TABLE_ALIAS_LITERAL(93)
+SQLGEN_TABLE_ALIAS_LITERAL(94)
+SQLGEN_TABLE_ALIAS_LITERAL(95)
+SQLGEN_TABLE_ALIAS_LITERAL(96)
+SQLGEN_TABLE_ALIAS_LITERAL(97)
+SQLGEN_TABLE_ALIAS_LITERAL(98)
+SQLGEN_TABLE_ALIAS_LITERAL(99)
 
 }  // namespace sqlgen
 
diff --git a/include/sqlgen/dynamic/Join.hpp b/include/sqlgen/dynamic/Join.hpp
new file mode 100644
index 0000000..fd94bc4
--- /dev/null
+++ b/include/sqlgen/dynamic/Join.hpp
@@ -0,0 +1,12 @@
+#ifndef SQLGEN_DYNAMIC_JOIN_HPP_
+#define SQLGEN_DYNAMIC_JOIN_HPP_
+
+#include "SelectFrom.hpp"
+
+namespace sqlgen::dynamic {
+
+using Join = SelectFrom::Join;
+
+}  // namespace sqlgen::dynamic
+
+#endif
diff --git a/include/sqlgen/dynamic/JoinType.hpp b/include/sqlgen/dynamic/JoinType.hpp
new file mode 100644
index 0000000..a82f55e
--- /dev/null
+++ b/include/sqlgen/dynamic/JoinType.hpp
@@ -0,0 +1,10 @@
+#ifndef SQLGEN_DYNAMIC_JOINTYPE_HPP_
+#define SQLGEN_DYNAMIC_JOINTYPE_HPP_
+
+namespace sqlgen::dynamic {
+
+enum class JoinType { inner_join, left_join, right_join, full_join };
+
+}  // namespace sqlgen::dynamic
+
+#endif
diff --git a/include/sqlgen/dynamic/SelectFrom.hpp b/include/sqlgen/dynamic/SelectFrom.hpp
index 6876a96..7ec8537 100644
--- a/include/sqlgen/dynamic/SelectFrom.hpp
+++ b/include/sqlgen/dynamic/SelectFrom.hpp
@@ -6,8 +6,10 @@
 #include <string>
 #include <vector>
 
+#include "../Ref.hpp"
 #include "Condition.hpp"
 #include "GroupBy.hpp"
+#include "JoinType.hpp"
 #include "Limit.hpp"
 #include "Operation.hpp"
 #include "OrderBy.hpp"
@@ -21,8 +23,17 @@ struct SelectFrom {
     std::optional<std::string> as;
   };
 
+  struct Join {
+    JoinType how;
+    rfl::Variant<Table, Ref<SelectFrom>> table_or_query;
+    std::string alias;
+    std::optional<Condition> on;
+  };
+
   Table table;
   std::vector<Field> fields;
+  std::optional<std::string> alias = std::nullopt;
+  std::optional<std::vector<Join>> joins = std::nullopt;
   std::optional<Condition> where = std::nullopt;
   std::optional<GroupBy> group_by = std::nullopt;
   std::optional<OrderBy> order_by = std::nullopt;
diff --git a/include/sqlgen/internal/strings/strings.hpp b/include/sqlgen/internal/strings/strings.hpp
index 9d45571..ea290f5 100644
--- a/include/sqlgen/internal/strings/strings.hpp
+++ b/include/sqlgen/internal/strings/strings.hpp
@@ -8,8 +8,12 @@ namespace sqlgen::internal::strings {
 
 char to_lower(const char ch);
 
+std::string to_lower(const std::string& _str);
+
 char to_upper(const char ch);
 
+std::string to_upper(const std::string& _str);
+
 std::string join(const std::string& _delimiter,
                  const std::vector<std::string>& _strings);
 
diff --git a/include/sqlgen/joins.hpp b/include/sqlgen/joins.hpp
new file mode 100644
index 0000000..5164fd2
--- /dev/null
+++ b/include/sqlgen/joins.hpp
@@ -0,0 +1,72 @@
+#ifndef SQLGEN_JOINS_HPP_
+#define SQLGEN_JOINS_HPP_
+
+#include <rfl.hpp>
+
+#include "transpilation/Join.hpp"
+
+namespace sqlgen {
+
+template <rfl::internal::StringLiteral _alias, class TableOrQueryType,
+          class ConditionType>
+auto join(const transpilation::JoinType _how,
+          const TableOrQueryType& _table_or_query, const ConditionType& _on) {
+  return transpilation::Join<TableOrQueryType, ConditionType, _alias>{
+      .how = _how, .table_or_query = _table_or_query, .on = _on};
+};
+
+template <rfl::internal::StringLiteral _alias, class QueryType,
+          class ConditionType>
+auto full_join(const QueryType& _query, const ConditionType& _on) {
+  return join<_alias>(transpilation::JoinType::full_join, _query, _on);
+}
+
+template <class TableType, rfl::internal::StringLiteral _alias,
+          class ConditionType>
+auto full_join(const ConditionType& _on) {
+  return join<_alias>(transpilation::JoinType::full_join,
+                      transpilation::TableWrapper<TableType>{}, _on);
+}
+
+template <rfl::internal::StringLiteral _alias, class QueryType,
+          class ConditionType>
+auto inner_join(const QueryType& _query, const ConditionType& _on) {
+  return join<_alias>(transpilation::JoinType::inner_join, _query, _on);
+}
+
+template <class TableType, rfl::internal::StringLiteral _alias,
+          class ConditionType>
+auto inner_join(const ConditionType& _on) {
+  return join<_alias>(transpilation::JoinType::inner_join,
+                      transpilation::TableWrapper<TableType>{}, _on);
+}
+
+template <rfl::internal::StringLiteral _alias, class QueryType,
+          class ConditionType>
+auto left_join(const QueryType& _query, const ConditionType& _on) {
+  return join<_alias>(transpilation::JoinType::left_join, _query, _on);
+}
+
+template <class TableType, rfl::internal::StringLiteral _alias,
+          class ConditionType>
+auto left_join(const ConditionType& _on) {
+  return join<_alias>(transpilation::JoinType::left_join,
+                      transpilation::TableWrapper<TableType>{}, _on);
+}
+
+template <rfl::internal::StringLiteral _alias, class QueryType,
+          class ConditionType>
+auto right_join(const QueryType& _query, const ConditionType& _on) {
+  return join<_alias>(transpilation::JoinType::right_join, _query, _on);
+}
+
+template <class TableType, rfl::internal::StringLiteral _alias,
+          class ConditionType>
+auto right_join(const ConditionType& _on) {
+  return join<_alias>(transpilation::JoinType::right_join,
+                      transpilation::TableWrapper<TableType>{}, _on);
+}
+
+}  // namespace sqlgen
+
+#endif
diff --git a/include/sqlgen/select_from.hpp b/include/sqlgen/select_from.hpp
index 4ad8946..af4f1a6 100644
--- a/include/sqlgen/select_from.hpp
+++ b/include/sqlgen/select_from.hpp
@@ -9,6 +9,8 @@
 #include "Ref.hpp"
 #include "Result.hpp"
 #include "col.hpp"
+#include "dynamic/Join.hpp"
+#include "dynamic/SelectFrom.hpp"
 #include "group_by.hpp"
 #include "internal/GetColType.hpp"
 #include "internal/is_range.hpp"
@@ -16,26 +18,32 @@
 #include "limit.hpp"
 #include "order_by.hpp"
 #include "to.hpp"
+#include "transpilation/Join.hpp"
 #include "transpilation/fields_to_named_tuple_t.hpp"
 #include "transpilation/group_by_t.hpp"
 #include "transpilation/order_by_t.hpp"
+#include "transpilation/table_tuple_t.hpp"
+#include "transpilation/to_joins.hpp"
 #include "transpilation/to_select_from.hpp"
 #include "transpilation/value_t.hpp"
 #include "where.hpp"
 
 namespace sqlgen {
 
-template <class StructType, class FieldsType, class WhereType,
-          class GroupByType, class OrderByType, class LimitType,
-          class ContainerType, class Connection>
+template <class TableTupleType, class AliasType, class FieldsType,
+          class JoinsType, class WhereType, class GroupByType,
+          class OrderByType, class LimitType, class ContainerType,
+          class Connection>
   requires is_connection<Connection>
 auto select_from_impl(const Ref<Connection>& _conn, const FieldsType& _fields,
-                      const WhereType& _where, const LimitType& _limit) {
+                      const JoinsType& _joins, const WhereType& _where,
+                      const LimitType& _limit) {
   if constexpr (internal::is_range_v<ContainerType>) {
     const auto query =
-        transpilation::to_select_from<StructType, FieldsType, WhereType,
-                                      GroupByType, OrderByType, LimitType>(
-            _fields, _where, _limit);
+        transpilation::to_select_from<TableTupleType, AliasType, FieldsType,
+                                      JoinsType, WhereType, GroupByType,
+                                      OrderByType, LimitType>(_fields, _joins,
+                                                              _where, _limit);
     return _conn->read(query).transform(
         [](auto&& _it) { return ContainerType(_it); });
 
@@ -54,44 +62,51 @@ auto select_from_impl(const Ref<Connection>& _conn, const FieldsType& _fields,
       return container;
     };
 
-    using RangeType =
-        Range<transpilation::fields_to_named_tuple_t<StructType, FieldsType>>;
+    using RangeType = Range<
+        transpilation::fields_to_named_tuple_t<TableTupleType, FieldsType>>;
 
-    return select_from_impl<StructType, FieldsType, WhereType, GroupByType,
-                            OrderByType, LimitType, RangeType>(_conn, _fields,
-                                                               _where, _limit)
+    return select_from_impl<TableTupleType, AliasType, FieldsType, JoinsType,
+                            WhereType, GroupByType, OrderByType, LimitType,
+                            RangeType>(_conn, _fields, _joins, _where, _limit)
         .and_then(to_container);
   }
 }
 
-template <class StructType, class FieldsType, class WhereType,
-          class GroupByType, class OrderByType, class LimitType,
-          class ContainerType, class Connection>
+template <class TableTupleType, class AliasType, class FieldsType,
+          class JoinsType, class WhereType, class GroupByType,
+          class OrderByType, class LimitType, class ContainerType,
+          class Connection>
   requires is_connection<Connection>
 auto select_from_impl(const Result<Ref<Connection>>& _res,
-                      const FieldsType& _fields, const WhereType& _where,
-                      const LimitType& _limit) {
+                      const FieldsType& _fields, const JoinsType& _joins,
+                      const WhereType& _where, const LimitType& _limit) {
   return _res.and_then([&](const auto& _conn) {
-    return select_from_impl<StructType, FieldsType, WhereType, GroupByType,
-                            OrderByType, LimitType, ContainerType>(
-        _conn, _where, _limit);
+    return select_from_impl<TableTupleType, AliasType, FieldsType, JoinsType,
+                            WhereType, GroupByType, OrderByType, LimitType,
+                            ContainerType>(_conn, _joins, _where, _limit);
   });
 }
 
-template <class StructType, class FieldsType, class WhereType = Nothing,
+template <class StructType, class AliasType, class FieldsType,
+          class JoinsType = Nothing, class WhereType = Nothing,
           class GroupByType = Nothing, class OrderByType = Nothing,
           class LimitType = Nothing, class ToType = Nothing>
 struct SelectFrom {
   auto operator()(const auto& _conn) const {
+    using TableTupleType =
+        transpilation::table_tuple_t<StructType, AliasType, JoinsType>;
+
     if constexpr (std::is_same_v<ToType, Nothing> ||
                   std::ranges::input_range<std::remove_cvref_t<ToType>>) {
-      using ContainerType = std::conditional_t<
-          std::is_same_v<ToType, Nothing>,
-          Range<transpilation::fields_to_named_tuple_t<StructType, FieldsType>>,
-          ToType>;
-      return select_from_impl<StructType, FieldsType, WhereType, GroupByType,
-                              OrderByType, LimitType, ContainerType>(
-          _conn, fields_, where_, limit_);
+      using ContainerType =
+          std::conditional_t<std::is_same_v<ToType, Nothing>,
+                             Range<transpilation::fields_to_named_tuple_t<
+                                 TableTupleType, FieldsType>>,
+                             ToType>;
+      return select_from_impl<TableTupleType, AliasType, FieldsType, JoinsType,
+                              WhereType, GroupByType, OrderByType, LimitType,
+                              ContainerType>(_conn, fields_, joins_, where_,
+                                             limit_);
 
     } else {
       const auto extract_result = [](auto&& _vec) -> Result<ToType> {
@@ -104,14 +119,42 @@ struct SelectFrom {
         return std::move(_vec[0]);
       };
 
-      return select_from_impl<StructType, FieldsType, WhereType, GroupByType,
-                              OrderByType, LimitType,
+      return select_from_impl<TableTupleType, AliasType, FieldsType, JoinsType,
+                              WhereType, GroupByType, OrderByType, LimitType,
                               std::vector<std::remove_cvref_t<ToType>>>(
-                 _conn, fields_, where_, limit_)
+                 _conn, fields_, joins_, where_, limit_)
           .and_then(extract_result);
     }
   }
 
+  template <class TableOrQueryType, class ConditionType,
+            rfl::internal::StringLiteral _alias>
+  friend auto operator|(
+      const SelectFrom& _s,
+      const transpilation::Join<TableOrQueryType, ConditionType, _alias>&
+          _join) {
+    if constexpr (std::is_same_v<JoinsType, Nothing>) {
+      using NewJoinsType = rfl::Tuple<
+          transpilation::Join<TableOrQueryType, ConditionType, _alias>>;
+
+      return SelectFrom<StructType, AliasType, FieldsType, NewJoinsType,
+                        WhereType, GroupByType, OrderByType, LimitType, ToType>{
+          .fields_ = _s.fields_, .joins_ = NewJoinsType(_join)};
+
+    } else {
+      using TupleType = rfl::Tuple<
+          transpilation::Join<TableOrQueryType, ConditionType, _alias>>;
+
+      const auto joins = rfl::tuple_cat(_s.joins_, TupleType(_join));
+
+      using NewJoinsType = std::remove_cvref_t<decltype(joins)>;
+
+      return SelectFrom<StructType, AliasType, FieldsType, NewJoinsType,
+                        WhereType, GroupByType, OrderByType, LimitType, ToType>{
+          .fields_ = _s.fields_, .joins_ = joins};
+    }
+  }
+
   template <class ConditionType>
   friend auto operator|(const SelectFrom& _s,
                         const Where<ConditionType>& _where) {
@@ -124,9 +167,10 @@ struct SelectFrom {
                   "You cannot call limit(...) before where(...).");
     static_assert(std::is_same_v<ToType, Nothing>,
                   "You cannot call to<...> before where(...).");
-    return SelectFrom<StructType, FieldsType, ConditionType, GroupByType,
-                      OrderByType, LimitType, ToType>{
-        .fields_ = _s.fields_, .where_ = _where.condition};
+    return SelectFrom<StructType, AliasType, FieldsType, JoinsType,
+                      ConditionType, GroupByType, OrderByType, LimitType,
+                      ToType>{
+        .fields_ = _s.fields_, .joins_ = _s.joins_, .where_ = _where.condition};
   }
 
   template <class... ColTypes>
@@ -144,10 +188,10 @@ struct SelectFrom {
     static_assert(sizeof...(ColTypes) != 0,
                   "You must assign at least one column to group_by.");
     return SelectFrom<
-        StructType, FieldsType, WhereType,
+        StructType, AliasType, FieldsType, JoinsType, WhereType,
         transpilation::group_by_t<StructType, typename ColTypes::ColType...>,
-        OrderByType, LimitType, ToType>{.fields_ = _s.fields_,
-                                        .where_ = _s.where_};
+        OrderByType, LimitType, ToType>{
+        .fields_ = _s.fields_, .joins_ = _s.joins_, .where_ = _s.where_};
   }
 
   template <class... ColTypes>
@@ -163,41 +207,101 @@ struct SelectFrom {
     static_assert(sizeof...(ColTypes) != 0,
                   "You must assign at least one column to order_by.");
     return SelectFrom<
-        StructType, FieldsType, WhereType, GroupByType,
+        StructType, AliasType, FieldsType, JoinsType, WhereType, GroupByType,
         transpilation::order_by_t<
             StructType, typename std::remove_cvref_t<ColTypes>::ColType...>,
-        LimitType, ToType>{.fields_ = _s.fields_, .where_ = _s.where_};
+        LimitType, ToType>{
+        .fields_ = _s.fields_, .joins_ = _s.joins_, .where_ = _s.where_};
   }
 
   friend auto operator|(const SelectFrom& _s, const Limit& _limit) {
     static_assert(std::is_same_v<LimitType, Nothing>,
                   "You cannot call limit twice.");
-    return SelectFrom<StructType, FieldsType, WhereType, GroupByType,
-                      OrderByType, Limit, ToType>{
-        .fields_ = _s.fields_, .where_ = _s.where_, .limit_ = _limit};
+    return SelectFrom<StructType, AliasType, FieldsType, JoinsType, WhereType,
+                      GroupByType, OrderByType, Limit, ToType>{
+        .fields_ = _s.fields_,
+        .joins_ = _s.joins_,
+        .where_ = _s.where_,
+        .limit_ = _limit};
   }
 
   template <class NewToType>
   friend auto operator|(const SelectFrom& _s, const To<NewToType>&) {
     static_assert(std::is_same_v<ToType, Nothing>,
                   "You cannot call to<...> twice.");
-    return SelectFrom<StructType, FieldsType, WhereType, GroupByType,
-                      OrderByType, LimitType, NewToType>{
-        .fields_ = _s.fields_, .where_ = _s.where_, .limit_ = _s.limit_};
+    return SelectFrom<StructType, AliasType, FieldsType, JoinsType, WhereType,
+                      GroupByType, OrderByType, LimitType, NewToType>{
+        .fields_ = _s.fields_,
+        .joins_ = _s.joins_,
+        .where_ = _s.where_,
+        .limit_ = _s.limit_};
   }
 
   FieldsType fields_;
 
+  JoinsType joins_;
+
   WhereType where_;
 
   LimitType limit_;
 };
 
+namespace transpilation {
+
+template <class StructType, class AliasType, class FieldsType, class JoinsType,
+          class... Args>
+struct ExtractTable<
+    SelectFrom<StructType, AliasType, FieldsType, JoinsType, Args...>> {
+  using TableTupleType = table_tuple_t<StructType, AliasType, JoinsType>;
+  using Type = fields_to_named_tuple_t<TableTupleType, FieldsType>;
+};
+
+template <class TableTupleType, class StructType, class AliasType,
+          class FieldsType, class JoinsType, class WhereType, class GroupByType,
+          class OrderByType, class LimitType, class ToType>
+struct ToJoin<TableTupleType, SelectFrom<StructType, AliasType, FieldsType,
+                                         JoinsType, WhereType, GroupByType,
+                                         OrderByType, LimitType, ToType>> {
+  template <class ConditionType, rfl::internal::StringLiteral _alias>
+  dynamic::Join operator()(
+      const transpilation::Join<
+          SelectFrom<StructType, AliasType, FieldsType, JoinsType, WhereType,
+                     GroupByType, OrderByType, LimitType, ToType>,
+          ConditionType, _alias>& _join) {
+    const auto& query = _join.table_or_query;
+
+    using NestedTableTupleType =
+        table_tuple_t<StructType, AliasType, JoinsType>;
+
+    return dynamic::Join{
+        .how = _join.how,
+        .table_or_query = Ref<dynamic::SelectFrom>::make(
+            transpilation::to_select_from<NestedTableTupleType, AliasType,
+                                          FieldsType, JoinsType, WhereType,
+                                          GroupByType, OrderByType, LimitType>(
+                query.fields_, query.joins_, query.where_, query.limit_)),
+        .alias = Literal<_alias>().str(),
+        .on = to_condition<TableTupleType>(_join.on)};
+  }
+};
+
+}  // namespace transpilation
+
 template <class StructType, class... FieldTypes>
 inline auto select_from(const FieldTypes&... _fields) {
   using FieldsType =
       rfl::Tuple<typename internal::GetColType<FieldTypes>::Type...>;
-  return SelectFrom<StructType, FieldsType>{
+  return SelectFrom<StructType, Nothing, FieldsType>{
+      .fields_ =
+          FieldsType(internal::GetColType<FieldTypes>::get_value(_fields)...)};
+}
+
+template <class StructType, rfl::internal::StringLiteral _alias,
+          class... FieldTypes>
+inline auto select_from(const FieldTypes&... _fields) {
+  using FieldsType =
+      rfl::Tuple<typename internal::GetColType<FieldTypes>::Type...>;
+  return SelectFrom<StructType, Literal<_alias>, FieldsType>{
       .fields_ =
           FieldsType(internal::GetColType<FieldTypes>::get_value(_fields)...)};
 }
diff --git a/include/sqlgen/transpilation/Col.hpp b/include/sqlgen/transpilation/Col.hpp
index e100054..4673933 100644
--- a/include/sqlgen/transpilation/Col.hpp
+++ b/include/sqlgen/transpilation/Col.hpp
@@ -6,10 +6,15 @@
 
 namespace sqlgen::transpilation {
 
-template <rfl::internal::StringLiteral _name>
+template <rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias = "">
 struct Col {
-  using ColType = Col<_name>;
+  using ColType = Col<_name, _alias>;
   using Name = rfl::Literal<_name>;
+  using Alias = rfl::Literal<_alias>;
+
+  /// Returns the column alias.
+  std::string alias() const noexcept { return Alias().str(); }
 
   /// Returns the column name.
   std::string name() const noexcept { return Name().str(); }
diff --git a/include/sqlgen/transpilation/Join.hpp b/include/sqlgen/transpilation/Join.hpp
new file mode 100644
index 0000000..bd9a020
--- /dev/null
+++ b/include/sqlgen/transpilation/Join.hpp
@@ -0,0 +1,27 @@
+#ifndef SQLGEN_TRANSPILATION_JOIN_HPP_
+#define SQLGEN_TRANSPILATION_JOIN_HPP_
+
+#include <rfl.hpp>
+
+#include "../Literal.hpp"
+#include "../dynamic/JoinType.hpp"
+#include "TableWrapper.hpp"
+
+namespace sqlgen::transpilation {
+
+using JoinType = dynamic::JoinType;
+
+template <class _TableOrQueryType, class ConditionType,
+          rfl::internal::StringLiteral _alias>
+struct Join {
+  using TableOrQueryType = _TableOrQueryType;
+  using Alias = Literal<_alias>;
+
+  JoinType how;
+  TableOrQueryType table_or_query;
+  ConditionType on;
+};
+
+}  // namespace sqlgen::transpilation
+
+#endif
diff --git a/include/sqlgen/transpilation/TableWrapper.hpp b/include/sqlgen/transpilation/TableWrapper.hpp
new file mode 100644
index 0000000..12b92c0
--- /dev/null
+++ b/include/sqlgen/transpilation/TableWrapper.hpp
@@ -0,0 +1,13 @@
+#ifndef SQLGEN_TRANSPILATION_TABLEWRAPPER_HPP_
+#define SQLGEN_TRANSPILATION_TABLEWRAPPER_HPP_
+
+namespace sqlgen::transpilation {
+
+template <class _TableType>
+struct TableWrapper {
+  using TableType = _TableType;
+};
+
+}  // namespace sqlgen::transpilation
+
+#endif
diff --git a/include/sqlgen/transpilation/all_columns_exist.hpp b/include/sqlgen/transpilation/all_columns_exist.hpp
index b176928..b9f4b1c 100644
--- a/include/sqlgen/transpilation/all_columns_exist.hpp
+++ b/include/sqlgen/transpilation/all_columns_exist.hpp
@@ -6,26 +6,32 @@
 
 #include "../Literal.hpp"
 #include "Col.hpp"
+#include "get_table_t.hpp"
 
 namespace sqlgen::transpilation {
 
-template <class Names, class ColType>
+template <class TableType, class Names, class ColType>
 struct ColumnExists;
 
-template <rfl::internal::StringLiteral _col_name,
+template <class TableType, rfl::internal::StringLiteral _col_name,
+          rfl::internal::StringLiteral _alias,
           rfl::internal::StringLiteral... _field_names>
-struct ColumnExists<Literal<_field_names...>, transpilation::Col<_col_name>> {
+struct ColumnExists<TableType, Literal<_field_names...>,
+                    transpilation::Col<_col_name, _alias>> {
   static constexpr bool value = (false || ... || (_col_name == _field_names));
   static_assert(value, "Column does not exist.");
 };
 
-template <class Names, class ColType>
-constexpr bool column_exists_v = ColumnExists<Names, ColType>::value;
+template <class TableType, class Names, class ColType>
+constexpr bool column_exists_v = ColumnExists<TableType, Names, ColType>::value;
 
-template <class T, class... ColTypes>
+template <class TableTupleType, class... ColTypes>
 consteval bool all_columns_exist() {
-  using Names = typename rfl::named_tuple_t<std::remove_cvref_t<T>>::Names;
-  return (true && ... && column_exists_v<Names, ColTypes>);
+  return (true && ... &&
+          column_exists_v<get_table_t<typename ColTypes::Alias, TableTupleType>,
+                          typename rfl::named_tuple_t<get_table_t<
+                              typename ColTypes::Alias, TableTupleType>>::Names,
+                          ColTypes>);
 }
 
 }  // namespace sqlgen::transpilation
diff --git a/include/sqlgen/transpilation/extract_table_t.hpp b/include/sqlgen/transpilation/extract_table_t.hpp
new file mode 100644
index 0000000..4fa6ee6
--- /dev/null
+++ b/include/sqlgen/transpilation/extract_table_t.hpp
@@ -0,0 +1,28 @@
+#ifndef SQLGEN_TRANSPILATION_EXTRACTTABLET_HPP_
+#define SQLGEN_TRANSPILATION_EXTRACTTABLET_HPP_
+
+#include <type_traits>
+
+#include "TableWrapper.hpp"
+
+namespace sqlgen::transpilation {
+
+template <class T>
+struct ExtractTable;
+
+template <class T>
+struct ExtractTable {
+  using Type = T;
+};
+
+template <class T>
+struct ExtractTable<TableWrapper<T>> {
+  using Type = typename ExtractTable<std::remove_cvref_t<T>>::Type;
+};
+
+template <class T>
+using extract_table_t = typename ExtractTable<std::remove_cvref_t<T>>::Type;
+
+}  // namespace sqlgen::transpilation
+
+#endif
diff --git a/include/sqlgen/transpilation/get_table_t.hpp b/include/sqlgen/transpilation/get_table_t.hpp
new file mode 100644
index 0000000..306034f
--- /dev/null
+++ b/include/sqlgen/transpilation/get_table_t.hpp
@@ -0,0 +1,74 @@
+#ifndef SQLGEN_TRANSPILATION_GETTABLET_HPP_
+#define SQLGEN_TRANSPILATION_GETTABLET_HPP_
+
+#include <rfl.hpp>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "../Literal.hpp"
+#include "../dynamic/JoinType.hpp"
+
+namespace sqlgen::transpilation {
+
+template <class Alias, class _TableType, class _AliasType>
+struct PairWrapper {
+  using TableType = _TableType;
+  using AliasType = _AliasType;
+
+  template <class OtherTableType, class OtherAliasType>
+  friend consteval auto operator||(
+      const PairWrapper&,
+      const PairWrapper<Alias, OtherTableType, OtherAliasType>&) noexcept {
+    if constexpr (std::is_same_v<Alias, std::remove_cvref_t<OtherAliasType>>) {
+      return PairWrapper<Alias, OtherTableType, OtherAliasType>{};
+    } else {
+      return PairWrapper{};
+    }
+  }
+};
+
+template <class Alias, class T>
+struct GetTableType;
+
+template <rfl::internal::StringLiteral _alias, class... TableTypes,
+          class... AliasTypes>
+struct GetTableType<Literal<_alias>,
+                    rfl::Tuple<std::pair<TableTypes, AliasTypes>...>> {
+  static constexpr auto wrapper =
+      (PairWrapper<Literal<_alias>, Nothing, Nothing>{} || ... ||
+       PairWrapper<Literal<_alias>, TableTypes, AliasTypes>{});
+
+  using TableType = std::remove_cvref_t<typename decltype(wrapper)::TableType>;
+
+  static_assert(!std::is_same_v<TableType, Nothing>,
+                "Alias could not be identified.");
+};
+
+template <rfl::internal::StringLiteral _alias, class T>
+struct GetTableType<Literal<_alias>, T> {
+  using TableType = T;
+};
+
+template <size_t _i, class... TableTypes, class... AliasTypes>
+struct GetTableType<std::integral_constant<size_t, _i>,
+                    rfl::Tuple<std::pair<TableTypes, AliasTypes>...>> {
+  using TableType = typename rfl::tuple_element_t<
+      _i, rfl::Tuple<std::pair<TableTypes, AliasTypes>...>>::first_type;
+
+  static_assert(!std::is_same_v<TableType, Nothing>,
+                "Alias could not be identified.");
+};
+
+template <size_t _i, class T>
+struct GetTableType<std::integral_constant<size_t, _i>, T> {
+  using TableType = T;
+};
+
+template <class Alias, class T>
+using get_table_t = typename GetTableType<std::remove_cvref_t<Alias>,
+                                          std::remove_cvref_t<T>>::TableType;
+
+}  // namespace sqlgen::transpilation
+
+#endif
diff --git a/include/sqlgen/transpilation/make_field.hpp b/include/sqlgen/transpilation/make_field.hpp
index a7d5dbe..92d8cb0 100644
--- a/include/sqlgen/transpilation/make_field.hpp
+++ b/include/sqlgen/transpilation/make_field.hpp
@@ -20,19 +20,21 @@
 #include "all_columns_exist.hpp"
 #include "dynamic_aggregation_t.hpp"
 #include "dynamic_operator_t.hpp"
+#include "get_table_t.hpp"
 #include "is_timestamp.hpp"
 #include "remove_as_t.hpp"
 #include "remove_nullable_t.hpp"
+#include "to_alias.hpp"
 #include "to_duration.hpp"
 #include "to_value.hpp"
 #include "underlying_t.hpp"
 
 namespace sqlgen::transpilation {
 
-template <class StructType, class FieldType>
+template <class TableTupleType, class FieldType>
 struct MakeField;
 
-template <class StructType, class T>
+template <class TableTupleType, class T>
 struct MakeField {
   static constexpr bool is_aggregation = false;
   static constexpr bool is_column = false;
@@ -47,26 +49,31 @@ struct MakeField {
   }
 };
 
-template <class StructType, rfl::internal::StringLiteral _name>
-struct MakeField<StructType, Col<_name>> {
-  static_assert(all_columns_exist<StructType, Col<_name>>(),
+template <class TableTupleType, rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias>
+struct MakeField<TableTupleType, Col<_name, _alias>> {
+  static_assert(all_columns_exist<TableTupleType, Col<_name, _alias>>(),
                 "A required column does not exist.");
 
   static constexpr bool is_aggregation = false;
   static constexpr bool is_column = true;
   static constexpr bool is_operation = false;
 
+  using TableType =
+      get_table_t<typename Col<_name, _alias>::Alias, TableTupleType>;
+
   using Name = Literal<_name>;
-  using Type = rfl::field_type_t<_name, StructType>;
+  using Type = rfl::field_type_t<_name, TableType>;
 
   dynamic::SelectFrom::Field operator()(const auto&) const {
-    return dynamic::SelectFrom::Field{
-        dynamic::Operation{.val = dynamic::Column{.name = _name.str()}}};
+    return dynamic::SelectFrom::Field{dynamic::Operation{
+        .val = dynamic::Column{.alias = to_alias<Literal<_alias>>(),
+                               .name = _name.str()}}};
   }
 };
 
-template <class StructType, class T>
-struct MakeField<StructType, Value<T>> {
+template <class TableTupleType, class T>
+struct MakeField<TableTupleType, Value<T>> {
   static constexpr bool is_aggregation = false;
   static constexpr bool is_column = false;
   static constexpr bool is_operation = false;
@@ -80,37 +87,40 @@ struct MakeField<StructType, Value<T>> {
   }
 };
 
-template <class StructType, class ValueType,
+template <class TableTupleType, class ValueType,
           rfl::internal::StringLiteral _new_name>
-struct MakeField<StructType, As<ValueType, _new_name>> {
+struct MakeField<TableTupleType, As<ValueType, _new_name>> {
   static constexpr bool is_aggregation =
-      MakeField<StructType, ValueType>::is_aggregation;
-  static constexpr bool is_column = MakeField<StructType, ValueType>::is_column;
+      MakeField<TableTupleType, ValueType>::is_aggregation;
+  static constexpr bool is_column =
+      MakeField<TableTupleType, ValueType>::is_column;
   static constexpr bool is_operation =
-      MakeField<StructType, ValueType>::is_operation;
+      MakeField<TableTupleType, ValueType>::is_operation;
 
   using Name = Literal<_new_name>;
   using Type =
-      typename MakeField<StructType, std::remove_cvref_t<ValueType>>::Type;
+      typename MakeField<TableTupleType, std::remove_cvref_t<ValueType>>::Type;
 
   dynamic::SelectFrom::Field operator()(const auto& _as) const {
     return dynamic::SelectFrom::Field{
         .val =
             dynamic::Operation{
-                .val = MakeField<StructType, std::remove_cvref_t<ValueType>>{}(
-                           _as.val)
-                           .val.val},
+                .val =
+                    MakeField<TableTupleType, std::remove_cvref_t<ValueType>>{}(
+                        _as.val)
+                        .val.val},
         .as = _new_name.str()};
   }
 };
 
-template <class StructType, AggregationOp _agg, class ValueType>
-struct MakeField<StructType, Aggregation<_agg, ValueType>> {
-  static_assert(std::is_integral_v<
-                    remove_nullable_t<underlying_t<StructType, ValueType>>> ||
-                    std::is_floating_point_v<
-                        remove_nullable_t<underlying_t<StructType, ValueType>>>,
-                "Values inside the aggregation must be numerical.");
+template <class TableTupleType, AggregationOp _agg, class ValueType>
+struct MakeField<TableTupleType, Aggregation<_agg, ValueType>> {
+  static_assert(
+      std::is_integral_v<
+          remove_nullable_t<underlying_t<TableTupleType, ValueType>>> ||
+          std::is_floating_point_v<
+              remove_nullable_t<underlying_t<TableTupleType, ValueType>>>,
+      "Values inside the aggregation must be numerical.");
 
   // Recursively checks if a type contains any aggregations.
   template <class T>
@@ -118,18 +128,18 @@ struct MakeField<StructType, Aggregation<_agg, ValueType>> {
 
   // Case: No operation.
   template <class T>
-    requires(!MakeField<StructType, remove_as_t<T>>::is_operation)
+    requires(!MakeField<TableTupleType, remove_as_t<T>>::is_operation)
   struct HasAggregations<T> {
     static constexpr bool value =
-        MakeField<StructType, remove_as_t<T>>::is_aggregation;
+        MakeField<TableTupleType, remove_as_t<T>>::is_aggregation;
   };
 
   // Case: Is operations: Check all operands.
   template <class T>
-    requires(MakeField<StructType, remove_as_t<T>>::is_operation)
+    requires(MakeField<TableTupleType, remove_as_t<T>>::is_operation)
   struct HasAggregations<T> {
     static constexpr bool value = HasAggregations<
-        typename MakeField<StructType, remove_as_t<T>>::Operands>::value;
+        typename MakeField<TableTupleType, remove_as_t<T>>::Operands>::value;
   };
 
   // Case: Is a set of operands from an operation..
@@ -149,22 +159,24 @@ struct MakeField<StructType, Aggregation<_agg, ValueType>> {
 
   using Name = Nothing;
   using Type =
-      typename MakeField<StructType, std::remove_cvref_t<ValueType>>::Type;
+      typename MakeField<TableTupleType, std::remove_cvref_t<ValueType>>::Type;
 
   dynamic::SelectFrom::Field operator()(const auto& _val) const {
     using DynamicAggregationType = dynamic_aggregation_t<_agg>;
     return dynamic::SelectFrom::Field{dynamic::Operation{
         .val = dynamic::Aggregation{DynamicAggregationType{
             .val = Ref<dynamic::Operation>::make(
-                MakeField<StructType, std::remove_cvref_t<ValueType>>{}(
+                MakeField<TableTupleType, std::remove_cvref_t<ValueType>>{}(
                     _val.val)
                     .val)}}}};
   }
 };
 
-template <class StructType, rfl::internal::StringLiteral _name>
-struct MakeField<StructType, Aggregation<AggregationOp::count, Col<_name>>> {
-  static_assert(all_columns_exist<StructType, Col<_name>>(),
+template <class TableTupleType, rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias>
+struct MakeField<TableTupleType,
+                 Aggregation<AggregationOp::count, Col<_name, _alias>>> {
+  static_assert(all_columns_exist<TableTupleType, Col<_name, _alias>>(),
                 "A column required in the COUNT or COUNT_DISTINCT aggregation "
                 "does not exist.");
 
@@ -178,13 +190,14 @@ struct MakeField<StructType, Aggregation<AggregationOp::count, Col<_name>>> {
   dynamic::SelectFrom::Field operator()(const auto& _agg) const {
     return dynamic::SelectFrom::Field{dynamic::Operation{
         .val = dynamic::Aggregation{dynamic::Aggregation::Count{
-            .val = dynamic::Column{.name = _name.str()},
+            .val = dynamic::Column{.alias = to_alias<Literal<_alias>>(),
+                                   .name = _name.str()},
             .distinct = _agg.distinct}}}};
   }
 };
 
-template <class StructType>
-struct MakeField<StructType, Aggregation<AggregationOp::count, All>> {
+template <class TableTupleType>
+struct MakeField<TableTupleType, Aggregation<AggregationOp::count, All>> {
   static constexpr bool is_aggregation = true;
   static constexpr bool is_column = true;
   static constexpr bool is_operation = false;
@@ -200,9 +213,9 @@ struct MakeField<StructType, Aggregation<AggregationOp::count, All>> {
   }
 };
 
-template <class StructType, class Operand1Type, class TargetType>
-struct MakeField<StructType, Operation<Operator::cast, Operand1Type,
-                                       TypeHolder<TargetType>>> {
+template <class TableTupleType, class Operand1Type, class TargetType>
+struct MakeField<TableTupleType, Operation<Operator::cast, Operand1Type,
+                                           TypeHolder<TargetType>>> {
   static constexpr bool is_aggregation = false;
   static constexpr bool is_column = false;
   static constexpr bool is_operation = true;
@@ -215,7 +228,7 @@ struct MakeField<StructType, Operation<Operator::cast, Operand1Type,
     return dynamic::SelectFrom::Field{
         dynamic::Operation{dynamic::Operation::Cast{
             .op1 = Ref<dynamic::Operation>::make(
-                MakeField<StructType, std::remove_cvref_t<Operand1Type>>{}(
+                MakeField<TableTupleType, std::remove_cvref_t<Operand1Type>>{}(
                     _o.operand1)
                     .val),
             .target_type =
@@ -223,8 +236,8 @@ struct MakeField<StructType, Operation<Operator::cast, Operand1Type,
   }
 };
 
-template <class StructType, class Operand1Type, class... DurationTypes>
-struct MakeField<StructType,
+template <class TableTupleType, class Operand1Type, class... DurationTypes>
+struct MakeField<TableTupleType,
                  Operation<Operator::date_plus_duration, Operand1Type,
                            rfl::Tuple<DurationTypes...>>> {
   static constexpr bool is_aggregation = false;
@@ -232,7 +245,7 @@ struct MakeField<StructType,
   static constexpr bool is_operation = true;
 
   using Name = Nothing;
-  using Type = underlying_t<StructType, std::remove_cvref_t<Operand1Type>>;
+  using Type = underlying_t<TableTupleType, std::remove_cvref_t<Operand1Type>>;
   using Operands = rfl::Tuple<Operand1Type, DurationTypes...>;
 
   static_assert(is_timestamp_v<remove_nullable_t<Type>>,
@@ -242,7 +255,7 @@ struct MakeField<StructType,
     return dynamic::SelectFrom::Field{
         dynamic::Operation{dynamic::Operation::DatePlusDuration{
             .date = Ref<dynamic::Operation>::make(
-                MakeField<StructType, std::remove_cvref_t<Operand1Type>>{}(
+                MakeField<TableTupleType, std::remove_cvref_t<Operand1Type>>{}(
                     _o.operand1)
                     .val),
             .durations = rfl::apply(
@@ -253,58 +266,58 @@ struct MakeField<StructType,
   }
 };
 
-template <class StructType, Operator _op, class Operand1Type>
+template <class TableTupleType, Operator _op, class Operand1Type>
   requires((num_operands_v<_op>) == 1)
-struct MakeField<StructType, Operation<_op, Operand1Type>> {
+struct MakeField<TableTupleType, Operation<_op, Operand1Type>> {
   static constexpr bool is_aggregation = false;
   static constexpr bool is_column = false;
   static constexpr bool is_operation = true;
 
   using Name = Nothing;
-  using Type = underlying_t<StructType, Operation<_op, Operand1Type>>;
+  using Type = underlying_t<TableTupleType, Operation<_op, Operand1Type>>;
   using Operands = rfl::Tuple<Operand1Type>;
 
   dynamic::SelectFrom::Field operator()(const auto& _o) const {
     using DynamicOperatorType = dynamic_operator_t<_op>;
     return dynamic::SelectFrom::Field{dynamic::Operation{DynamicOperatorType{
         .op1 = Ref<dynamic::Operation>::make(
-            MakeField<StructType, std::remove_cvref_t<Operand1Type>>{}(
+            MakeField<TableTupleType, std::remove_cvref_t<Operand1Type>>{}(
                 _o.operand1)
                 .val)}}};
   }
 };
 
-template <class StructType, Operator _op, class Operand1Type,
+template <class TableTupleType, Operator _op, class Operand1Type,
           class Operand2Type>
   requires((num_operands_v<_op>) == 2)
-struct MakeField<StructType, Operation<_op, Operand1Type, Operand2Type>> {
+struct MakeField<TableTupleType, Operation<_op, Operand1Type, Operand2Type>> {
   static constexpr bool is_aggregation = false;
   static constexpr bool is_column = false;
   static constexpr bool is_operation = true;
 
   using Name = Nothing;
   using Type =
-      underlying_t<StructType, Operation<_op, Operand1Type, Operand2Type>>;
+      underlying_t<TableTupleType, Operation<_op, Operand1Type, Operand2Type>>;
   using Operands = rfl::Tuple<Operand1Type, Operand2Type>;
 
   dynamic::SelectFrom::Field operator()(const auto& _o) const {
     using DynamicOperatorType = dynamic_operator_t<_op>;
     return dynamic::SelectFrom::Field{dynamic::Operation{DynamicOperatorType{
         .op1 = Ref<dynamic::Operation>::make(
-            MakeField<StructType, std::remove_cvref_t<Operand1Type>>{}(
+            MakeField<TableTupleType, std::remove_cvref_t<Operand1Type>>{}(
                 _o.operand1)
                 .val),
         .op2 = Ref<dynamic::Operation>::make(
-            MakeField<StructType, std::remove_cvref_t<Operand2Type>>{}(
+            MakeField<TableTupleType, std::remove_cvref_t<Operand2Type>>{}(
                 _o.operand2)
                 .val)}}};
   }
 };
 
-template <class StructType, Operator _op, class Operand1Type,
+template <class TableTupleType, Operator _op, class Operand1Type,
           class Operand2Type, class Operand3Type>
   requires((num_operands_v<_op>) == 3)
-struct MakeField<StructType,
+struct MakeField<TableTupleType,
                  Operation<_op, Operand1Type, Operand2Type, Operand3Type>> {
   static constexpr bool is_aggregation = false;
   static constexpr bool is_column = false;
@@ -312,38 +325,38 @@ struct MakeField<StructType,
 
   using Name = Nothing;
   using Type =
-      underlying_t<StructType, Operation<Operator::replace, Operand1Type,
-                                         Operand2Type, Operand3Type>>;
+      underlying_t<TableTupleType, Operation<Operator::replace, Operand1Type,
+                                             Operand2Type, Operand3Type>>;
   using Operands = rfl::Tuple<Operand1Type, Operand2Type, Operand3Type>;
 
   dynamic::SelectFrom::Field operator()(const auto& _o) const {
     return dynamic::SelectFrom::Field{
         dynamic::Operation{dynamic::Operation::Replace{
             .op1 = Ref<dynamic::Operation>::make(
-                MakeField<StructType, std::remove_cvref_t<Operand1Type>>{}(
+                MakeField<TableTupleType, std::remove_cvref_t<Operand1Type>>{}(
                     _o.operand1)
                     .val),
             .op2 = Ref<dynamic::Operation>::make(
-                MakeField<StructType, std::remove_cvref_t<Operand2Type>>{}(
+                MakeField<TableTupleType, std::remove_cvref_t<Operand2Type>>{}(
                     _o.operand2)
                     .val),
             .op3 = Ref<dynamic::Operation>::make(
-                MakeField<StructType, std::remove_cvref_t<Operand3Type>>{}(
+                MakeField<TableTupleType, std::remove_cvref_t<Operand3Type>>{}(
                     _o.operand3)
                     .val)}}};
   }
 };
 
-template <class StructType, Operator _op, class... OperandTypes>
+template <class TableTupleType, Operator _op, class... OperandTypes>
   requires((num_operands_v<_op>) == std::numeric_limits<size_t>::max())
-struct MakeField<StructType, Operation<_op, rfl::Tuple<OperandTypes...>>> {
+struct MakeField<TableTupleType, Operation<_op, rfl::Tuple<OperandTypes...>>> {
   static constexpr bool is_aggregation = false;
   static constexpr bool is_column = false;
   static constexpr bool is_operation = true;
 
   using Name = Nothing;
   using Type =
-      underlying_t<StructType, Operation<_op, rfl::Tuple<OperandTypes...>>>;
+      underlying_t<TableTupleType, Operation<_op, rfl::Tuple<OperandTypes...>>>;
   using Operands = rfl::Tuple<OperandTypes...>;
 
   dynamic::SelectFrom::Field operator()(const auto& _o) const {
@@ -353,7 +366,7 @@ struct MakeField<StructType, Operation<_op, rfl::Tuple<OperandTypes...>>> {
             [](const auto&... _ops) {
               return std::vector<Ref<dynamic::Operation>>(
                   {Ref<dynamic::Operation>::make(
-                      MakeField<StructType,
+                      MakeField<TableTupleType,
                                 std::remove_cvref_t<OperandTypes>>{}(_ops)
                           .val)...});
             },
@@ -361,9 +374,9 @@ struct MakeField<StructType, Operation<_op, rfl::Tuple<OperandTypes...>>> {
   }
 };
 
-template <class StructType, class ValueType>
+template <class TableTupleType, class ValueType>
 inline dynamic::SelectFrom::Field make_field(const ValueType& _val) {
-  return MakeField<std::remove_cvref_t<StructType>,
+  return MakeField<std::remove_cvref_t<TableTupleType>,
                    std::remove_cvref_t<ValueType>>{}(_val);
 }
 
diff --git a/include/sqlgen/transpilation/make_fields.hpp b/include/sqlgen/transpilation/make_fields.hpp
index 47c0f04..1ef5e64 100644
--- a/include/sqlgen/transpilation/make_fields.hpp
+++ b/include/sqlgen/transpilation/make_fields.hpp
@@ -10,11 +10,11 @@
 
 namespace sqlgen::transpilation {
 
-template <class StructType, class Fields, int... _is>
+template <class TableTupleType, class Fields, int... _is>
 std::vector<dynamic::SelectFrom::Field> make_fields(
     const Fields& _fields, std::integer_sequence<int, _is...>) {
   return std::vector<dynamic::SelectFrom::Field>(
-      {make_field<StructType>(rfl::get<_is>(_fields))...});
+      {make_field<TableTupleType>(rfl::get<_is>(_fields))...});
 }
 
 }  // namespace sqlgen::transpilation
diff --git a/include/sqlgen/transpilation/order_by_t.hpp b/include/sqlgen/transpilation/order_by_t.hpp
index bcd67dd..92709f3 100644
--- a/include/sqlgen/transpilation/order_by_t.hpp
+++ b/include/sqlgen/transpilation/order_by_t.hpp
@@ -14,15 +14,17 @@ namespace sqlgen::transpilation {
 template <class _ColType>
 struct OrderByWrapper;
 
-template <rfl::internal::StringLiteral _name>
-struct OrderByWrapper<transpilation::Col<_name>> {
-  using ColType = transpilation::Col<_name>;
+template <rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias>
+struct OrderByWrapper<transpilation::Col<_name, _alias>> {
+  using ColType = transpilation::Col<_name, _alias>;
   constexpr static bool desc = false;
 };
 
-template <rfl::internal::StringLiteral _name>
-struct OrderByWrapper<Desc<transpilation::Col<_name>>> {
-  using ColType = transpilation::Col<_name>;
+template <rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias>
+struct OrderByWrapper<Desc<transpilation::Col<_name, _alias>>> {
+  using ColType = transpilation::Col<_name, _alias>;
   constexpr static bool desc = true;
 };
 
diff --git a/include/sqlgen/transpilation/table_tuple_t.hpp b/include/sqlgen/transpilation/table_tuple_t.hpp
new file mode 100644
index 0000000..46d5464
--- /dev/null
+++ b/include/sqlgen/transpilation/table_tuple_t.hpp
@@ -0,0 +1,38 @@
+#ifndef SQLGEN_TRANSPILATION_TABLETUPLET_HPP_
+#define SQLGEN_TRANSPILATION_TABLETUPLET_HPP_
+
+#include <rfl.hpp>
+#include <type_traits>
+#include <utility>
+
+#include "../Literal.hpp"
+#include "../Result.hpp"
+#include "extract_table_t.hpp"
+
+namespace sqlgen::transpilation {
+
+template <class StructType, class AliasType, class JoinsType>
+struct TableTupleType;
+
+template <class StructType, class AliasType>
+struct TableTupleType<StructType, AliasType, Nothing> {
+  using Type = StructType;
+};
+
+template <class StructType, class AliasType, class... JoinTypes>
+struct TableTupleType<StructType, AliasType, rfl::Tuple<JoinTypes...>> {
+  using Type = rfl::Tuple<
+      std::pair<extract_table_t<StructType>, AliasType>,
+      std::pair<extract_table_t<typename JoinTypes::TableOrQueryType>,
+                typename JoinTypes::Alias>...>;
+};
+
+template <class StructType, class AliasType, class JoinsType>
+using table_tuple_t =
+    typename TableTupleType<std::remove_cvref_t<StructType>,
+                            std::remove_cvref_t<AliasType>,
+                            std::remove_cvref_t<JoinsType>>::Type;
+
+}  // namespace sqlgen::transpilation
+
+#endif
diff --git a/include/sqlgen/transpilation/to_alias.hpp b/include/sqlgen/transpilation/to_alias.hpp
new file mode 100644
index 0000000..bd4f480
--- /dev/null
+++ b/include/sqlgen/transpilation/to_alias.hpp
@@ -0,0 +1,41 @@
+#ifndef SQLGEN_TRANSPILATION_TO_ALIAS_HPP_
+#define SQLGEN_TRANSPILATION_TO_ALIAS_HPP_
+
+#include <optional>
+#include <rfl.hpp>
+#include <string>
+#include <type_traits>
+
+#include "../Literal.hpp"
+#include "../Result.hpp"
+
+namespace sqlgen::transpilation {
+
+template <class T>
+struct ToAlias;
+
+template <>
+struct ToAlias<Nothing> {
+  std::optional<std::string> operator()() const { return std::nullopt; }
+};
+
+template <>
+struct ToAlias<Literal<"">> {
+  std::optional<std::string> operator()() const { return std::nullopt; }
+};
+
+template <rfl::internal::StringLiteral _alias>
+struct ToAlias<Literal<_alias>> {
+  std::optional<std::string> operator()() const {
+    return Literal<_alias>().str();
+  }
+};
+
+template <class T>
+std::optional<std::string> to_alias() {
+  return ToAlias<std::remove_cvref_t<T>>{}();
+}
+
+}  // namespace sqlgen::transpilation
+
+#endif
diff --git a/include/sqlgen/transpilation/to_group_by.hpp b/include/sqlgen/transpilation/to_group_by.hpp
index e9f3b39..7e8ffa9 100644
--- a/include/sqlgen/transpilation/to_group_by.hpp
+++ b/include/sqlgen/transpilation/to_group_by.hpp
@@ -8,6 +8,7 @@
 #include "../dynamic/Column.hpp"
 #include "../dynamic/GroupBy.hpp"
 #include "group_by_t.hpp"
+#include "to_alias.hpp"
 
 namespace sqlgen::transpilation {
 
@@ -23,7 +24,8 @@ template <class... ColTypes>
 struct ToGroupBy<GroupBy<ColTypes...>> {
   std::optional<dynamic::GroupBy> operator()() const {
     const auto columns = std::vector<dynamic::Column>(
-        {dynamic::Column{.name = ColTypes().name()}...});
+        {dynamic::Column{.alias = to_alias<typename ColTypes::Alias>(),
+                         .name = ColTypes().name()}...});
     return dynamic::GroupBy{.columns = columns};
   }
 };
diff --git a/include/sqlgen/transpilation/to_joins.hpp b/include/sqlgen/transpilation/to_joins.hpp
new file mode 100644
index 0000000..0085338
--- /dev/null
+++ b/include/sqlgen/transpilation/to_joins.hpp
@@ -0,0 +1,63 @@
+#ifndef SQLGEN_TRANSPILATION_TO_JOIN_HPP_
+#define SQLGEN_TRANSPILATION_TO_JOIN_HPP_
+
+#include <optional>
+#include <rfl.hpp>
+#include <type_traits>
+#include <vector>
+
+#include "../dynamic/Join.hpp"
+#include "../dynamic/Table.hpp"
+#include "Join.hpp"
+#include "TableWrapper.hpp"
+#include "get_schema.hpp"
+#include "get_tablename.hpp"
+#include "to_condition.hpp"
+
+namespace sqlgen::transpilation {
+
+template <class TableTupleType, class T>
+struct ToJoin;
+
+template <class TableTupleType, class TableType>
+struct ToJoin<TableTupleType, TableWrapper<TableType>> {
+  template <class ConditionType, rfl::internal::StringLiteral _alias>
+  dynamic::Join operator()(
+      const Join<TableWrapper<TableType>, ConditionType, _alias>& _join) {
+    using T = std::remove_cvref_t<TableType>;
+    using Alias =
+        typename Join<TableWrapper<TableType>, ConditionType, _alias>::Alias;
+
+    return dynamic::Join{
+        .how = _join.how,
+        .table_or_query = dynamic::Table{.name = get_tablename<T>(),
+                                         .schema = get_schema<T>()},
+        .alias = Alias().str(),
+        .on = to_condition<TableTupleType>(_join.on)};
+  }
+};
+
+template <class TableTupleType, class T, class ConditionType,
+          rfl::internal::StringLiteral _alias>
+dynamic::Join to_join(const Join<T, ConditionType, _alias>& _join) {
+  return ToJoin<TableTupleType, T>{}(_join);
+}
+
+template <class TableTupleType, class... JoinTypes>
+std::optional<std::vector<dynamic::Join>> to_joins(
+    const rfl::Tuple<JoinTypes...>& _joins) {
+  return rfl::apply(
+      [](const auto&... _js) {
+        return std::vector<dynamic::Join>({to_join<TableTupleType>(_js)...});
+      },
+      _joins);
+}
+
+template <class TableTupleType>
+inline std::optional<std::vector<dynamic::Join>> to_joins(const Nothing&) {
+  return std::nullopt;
+}
+
+}  // namespace sqlgen::transpilation
+
+#endif
diff --git a/include/sqlgen/transpilation/to_order_by.hpp b/include/sqlgen/transpilation/to_order_by.hpp
index af483b2..cf54898 100644
--- a/include/sqlgen/transpilation/to_order_by.hpp
+++ b/include/sqlgen/transpilation/to_order_by.hpp
@@ -6,6 +6,7 @@
 #include "../Result.hpp"
 #include "../dynamic/OrderBy.hpp"
 #include "order_by_t.hpp"
+#include "to_alias.hpp"
 
 namespace sqlgen::transpilation {
 
@@ -21,8 +22,9 @@ template <class... Wrappers>
 struct ToOrderBy<OrderBy<Wrappers...>> {
   template <class W>
   dynamic::Wrapper to_wrapper() const {
+    using Alias = typename W::ColType::Alias;
     using Name = typename W::ColType::Name;
-    const auto column = dynamic::Column{.alias = std::nullopt,
+    const auto column = dynamic::Column{.alias = to_alias<Alias>(),
                                         .name = Name().str(),
                                         .type = dynamic::types::Unknown{}};
     return dynamic::Wrapper{.column = column, .desc = W::desc};
diff --git a/include/sqlgen/transpilation/to_select_from.hpp b/include/sqlgen/transpilation/to_select_from.hpp
index b0bf6b2..62df16d 100644
--- a/include/sqlgen/transpilation/to_select_from.hpp
+++ b/include/sqlgen/transpilation/to_select_from.hpp
@@ -10,43 +10,54 @@
 
 #include "../Result.hpp"
 #include "../dynamic/ColumnOrAggregation.hpp"
+#include "../dynamic/Join.hpp"
 #include "../dynamic/SelectFrom.hpp"
 #include "../dynamic/Table.hpp"
 #include "../internal/collect/vector.hpp"
+#include "Join.hpp"
 #include "check_aggregations.hpp"
 #include "flatten_fields_t.hpp"
 #include "get_schema.hpp"
+#include "get_table_t.hpp"
 #include "get_tablename.hpp"
 #include "make_fields.hpp"
+#include "to_alias.hpp"
 #include "to_condition.hpp"
 #include "to_group_by.hpp"
+#include "to_joins.hpp"
 #include "to_limit.hpp"
 #include "to_order_by.hpp"
 
 namespace sqlgen::transpilation {
 
-template <class StructType, class FieldsType, class WhereType,
-          class GroupByType, class OrderByType, class LimitType>
-  requires std::is_class_v<std::remove_cvref_t<StructType>> &&
-           std::is_aggregate_v<std::remove_cvref_t<StructType>>
+template <class TableTupleType, class AliasType, class FieldsType,
+          class JoinsType, class WhereType, class GroupByType,
+          class OrderByType, class LimitType>
 dynamic::SelectFrom to_select_from(const FieldsType& _fields,
+                                   const JoinsType& _joins,
                                    const WhereType& _where,
                                    const LimitType& _limit) {
-  static_assert(
-      check_aggregations<StructType, flatten_fields_t<StructType, FieldsType>,
-                         GroupByType>(),
-      "The aggregations were not set up correctly. Please check the "
-      "trace for a more detailed error message.");
+  static_assert(check_aggregations<TableTupleType,
+                                   flatten_fields_t<TableTupleType, FieldsType>,
+                                   GroupByType>(),
+                "The aggregations were not set up correctly. Please check the "
+                "trace for a more detailed error message.");
 
-  const auto fields = make_fields<StructType, FieldsType>(
+  using StructType =
+      get_table_t<std::integral_constant<size_t, 0>, TableTupleType>;
+
+  const auto fields = make_fields<TableTupleType, FieldsType>(
       _fields,
       std::make_integer_sequence<int, rfl::tuple_size_v<FieldsType>>());
 
   return dynamic::SelectFrom{
-      .table = dynamic::Table{.name = get_tablename<StructType>(),
+      .table = dynamic::Table{.alias = to_alias<AliasType>(),
+                              .name = get_tablename<StructType>(),
                               .schema = get_schema<StructType>()},
       .fields = fields,
-      .where = to_condition<std::remove_cvref_t<StructType>>(_where),
+      .alias = to_alias<AliasType>(),
+      .joins = to_joins<TableTupleType>(_joins),
+      .where = to_condition<std::remove_cvref_t<TableTupleType>>(_where),
       .group_by = to_group_by<GroupByType>(),
       .order_by = to_order_by<OrderByType>(),
       .limit = to_limit(_limit)};
diff --git a/include/sqlgen/transpilation/to_sql.hpp b/include/sqlgen/transpilation/to_sql.hpp
index a84309d..adb0146 100644
--- a/include/sqlgen/transpilation/to_sql.hpp
+++ b/include/sqlgen/transpilation/to_sql.hpp
@@ -14,6 +14,7 @@
 #include "../update.hpp"
 #include "columns_t.hpp"
 #include "read_to_select_from.hpp"
+#include "table_tuple_t.hpp"
 #include "to_create_index.hpp"
 #include "to_create_table.hpp"
 #include "to_delete_from.hpp"
@@ -76,14 +77,17 @@ struct ToSQL<Read<ContainerType, WhereType, OrderByType, LimitType>> {
   }
 };
 
-template <class StructType, class FieldsType, class WhereType,
-          class GroupByType, class OrderByType, class LimitType, class ToType>
-struct ToSQL<SelectFrom<StructType, FieldsType, WhereType, GroupByType,
-                        OrderByType, LimitType, ToType>> {
+template <class StructType, class AliasType, class FieldsType, class JoinsType,
+          class WhereType, class GroupByType, class OrderByType,
+          class LimitType, class ToType>
+struct ToSQL<SelectFrom<StructType, AliasType, FieldsType, JoinsType, WhereType,
+                        GroupByType, OrderByType, LimitType, ToType>> {
   dynamic::Statement operator()(const auto& _select_from) const {
-    return to_select_from<StructType, FieldsType, WhereType, GroupByType,
-                          OrderByType, LimitType>(
-        _select_from.fields_, _select_from.where_, _select_from.limit_);
+    using TableTupleType = table_tuple_t<StructType, AliasType, JoinsType>;
+    return to_select_from<TableTupleType, AliasType, FieldsType, JoinsType,
+                          WhereType, GroupByType, OrderByType, LimitType>(
+        _select_from.fields_, _select_from.joins_, _select_from.where_,
+        _select_from.limit_);
   }
 };
 
diff --git a/include/sqlgen/transpilation/underlying_t.hpp b/include/sqlgen/transpilation/underlying_t.hpp
index 213c3e9..910a9bb 100644
--- a/include/sqlgen/transpilation/underlying_t.hpp
+++ b/include/sqlgen/transpilation/underlying_t.hpp
@@ -13,6 +13,7 @@
 #include "Value.hpp"
 #include "all_columns_exist.hpp"
 #include "dynamic_operator_t.hpp"
+#include "get_table_t.hpp"
 #include "is_nullable.hpp"
 #include "is_timestamp.hpp"
 #include "remove_nullable_t.hpp"
@@ -20,72 +21,85 @@
 
 namespace sqlgen::transpilation {
 
-template <class T, class _Type>
+template <class TableTupleType, class _Type>
 struct Underlying;
 
-template <class T, AggregationOp _op, class ValueType>
-struct Underlying<T, Aggregation<_op, ValueType>> {
-  using Type = typename Underlying<T, std::remove_cvref_t<ValueType>>::Type;
-};
-
-template <class T, rfl::internal::StringLiteral _name>
-struct Underlying<T, Col<_name>> {
-  static_assert(all_columns_exist<T, Col<_name>>(), "All columns must exist.");
-  using Type = remove_reflection_t<rfl::field_type_t<_name, T>>;
-};
-
-template <class T, rfl::internal::StringLiteral _name>
-struct Underlying<T, Desc<Col<_name>>> {
-  using Type = remove_reflection_t<rfl::field_type_t<_name, T>>;
-};
-
-template <class T, class Operand1Type, class TargetType>
-struct Underlying<
-    T, Operation<Operator::cast, Operand1Type, TypeHolder<TargetType>>> {
+template <class TableTupleType, AggregationOp _op, class ValueType>
+struct Underlying<TableTupleType, Aggregation<_op, ValueType>> {
   using Type =
-      std::conditional_t<is_nullable_v<typename Underlying<
-                             T, std::remove_cvref_t<Operand1Type>>::Type>,
-                         std::optional<std::remove_cvref_t<TargetType>>,
-                         std::remove_cvref_t<TargetType>>;
+      typename Underlying<TableTupleType, std::remove_cvref_t<ValueType>>::Type;
 };
 
-template <class T, class Head, class... Tail>
-struct Underlying<T, Operation<Operator::coalesce, rfl::Tuple<Head, Tail...>>> {
-  using Operand1Type = typename Underlying<T, std::remove_cvref_t<Head>>::Type;
+template <class TableTupleType, rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias>
+struct Underlying<TableTupleType, Col<_name, _alias>> {
+  static_assert(all_columns_exist<TableTupleType, Col<_name, _alias>>(),
+                "All columns must exist.");
+  using Type = remove_reflection_t<
+      rfl::field_type_t<_name, get_table_t<Literal<_alias>, TableTupleType>>>;
+};
 
-  static_assert((true && ... &&
-                 std::is_same_v<remove_nullable_t<Operand1Type>,
-                                remove_nullable_t<typename Underlying<
-                                    T, std::remove_cvref_t<Tail>>::Type>>),
-                "All inputs into coalesce(...) must have the same type.");
+template <class TableTupleType, rfl::internal::StringLiteral _name,
+          rfl::internal::StringLiteral _alias>
+struct Underlying<TableTupleType, Desc<Col<_name, _alias>>> {
+  using Type = remove_reflection_t<
+      rfl::field_type_t<_name, get_table_t<Literal<_alias>, TableTupleType>>>;
+};
+
+template <class TableTupleType, class Operand1Type, class TargetType>
+struct Underlying<TableTupleType, Operation<Operator::cast, Operand1Type,
+                                            TypeHolder<TargetType>>> {
+  using Type = std::conditional_t<
+      is_nullable_v<typename Underlying<
+          TableTupleType, std::remove_cvref_t<Operand1Type>>::Type>,
+      std::optional<std::remove_cvref_t<TargetType>>,
+      std::remove_cvref_t<TargetType>>;
+};
+
+template <class TableTupleType, class Head, class... Tail>
+struct Underlying<TableTupleType,
+                  Operation<Operator::coalesce, rfl::Tuple<Head, Tail...>>> {
+  using Operand1Type =
+      typename Underlying<TableTupleType, std::remove_cvref_t<Head>>::Type;
+
+  static_assert(
+      (true && ... &&
+       std::is_same_v<remove_nullable_t<Operand1Type>,
+                      remove_nullable_t<typename Underlying<
+                          TableTupleType, std::remove_cvref_t<Tail>>::Type>>),
+      "All inputs into coalesce(...) must have the same type.");
 
   using Type = std::conditional_t<
       (is_nullable_v<Operand1Type> && ... &&
-       is_nullable_v<typename Underlying<T, std::remove_cvref_t<Tail>>::Type>),
+       is_nullable_v<typename Underlying<TableTupleType,
+                                         std::remove_cvref_t<Tail>>::Type>),
       std::optional<remove_nullable_t<Operand1Type>>,
       remove_nullable_t<Operand1Type>>;
 };
 
-template <class T, class... OperandTypes>
-struct Underlying<T, Operation<Operator::concat, rfl::Tuple<OperandTypes...>>> {
+template <class TableTupleType, class... OperandTypes>
+struct Underlying<TableTupleType,
+                  Operation<Operator::concat, rfl::Tuple<OperandTypes...>>> {
   static_assert(
       (true && ... &&
-       std::is_same_v<remove_nullable_t<typename Underlying<
-                          T, std::remove_cvref_t<OperandTypes>>::Type>,
-                      std::string>),
+       std::is_same_v<
+           remove_nullable_t<typename Underlying<
+               TableTupleType, std::remove_cvref_t<OperandTypes>>::Type>,
+           std::string>),
       "Must be a string");
 
-  using Type =
-      std::conditional_t<(false || ... ||
-                          is_nullable_v<typename Underlying<
-                              T, std::remove_cvref_t<OperandTypes>>::Type>),
-                         std::optional<std::string>, std::string>;
+  using Type = std::conditional_t<
+      (false || ... ||
+       is_nullable_v<typename Underlying<
+           TableTupleType, std::remove_cvref_t<OperandTypes>>::Type>),
+      std::optional<std::string>, std::string>;
 };
 
-template <class T, class Operand1Type, class... DurationTypes>
-struct Underlying<T, Operation<Operator::date_plus_duration, Operand1Type,
-                               rfl::Tuple<DurationTypes...>>> {
-  using Underlying1 = typename Underlying<T, Operand1Type>::Type;
+template <class TableTupleType, class Operand1Type, class... DurationTypes>
+struct Underlying<TableTupleType,
+                  Operation<Operator::date_plus_duration, Operand1Type,
+                            rfl::Tuple<DurationTypes...>>> {
+  using Underlying1 = typename Underlying<TableTupleType, Operand1Type>::Type;
 
   static_assert(is_timestamp_v<remove_nullable_t<Underlying1>>,
                 "Must be a timestamp");
@@ -95,11 +109,11 @@ struct Underlying<T, Operation<Operator::date_plus_duration, Operand1Type,
                                   Underlying1>;
 };
 
-template <class T, class Operand1Type, class Operand2Type>
-struct Underlying<
-    T, Operation<Operator::days_between, Operand1Type, Operand2Type>> {
-  using Underlying1 = typename Underlying<T, Operand1Type>::Type;
-  using Underlying2 = typename Underlying<T, Operand2Type>::Type;
+template <class TableTupleType, class Operand1Type, class Operand2Type>
+struct Underlying<TableTupleType, Operation<Operator::days_between,
+                                            Operand1Type, Operand2Type>> {
+  using Underlying1 = typename Underlying<TableTupleType, Operand1Type>::Type;
+  using Underlying2 = typename Underlying<TableTupleType, Operand2Type>::Type;
 
   static_assert(is_timestamp_v<remove_nullable_t<Underlying1>>,
                 "Must be a timestamp");
@@ -111,15 +125,19 @@ struct Underlying<
                                   std::optional<double>, double>;
 };
 
-template <class T, class Operand1Type, class Operand2Type, class Operand3Type>
-struct Underlying<
-    T, Operation<Operator::replace, Operand1Type, Operand2Type, Operand3Type>> {
+template <class TableTupleType, class Operand1Type, class Operand2Type,
+          class Operand3Type>
+struct Underlying<TableTupleType, Operation<Operator::replace, Operand1Type,
+                                            Operand2Type, Operand3Type>> {
   using Underlying1 =
-      typename Underlying<T, std::remove_cvref_t<Operand1Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand1Type>>::Type;
   using Underlying2 =
-      typename Underlying<T, std::remove_cvref_t<Operand2Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand2Type>>::Type;
   using Underlying3 =
-      typename Underlying<T, std::remove_cvref_t<Operand3Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand3Type>>::Type;
 
   static_assert(std::is_same_v<remove_nullable_t<Underlying1>, std::string>,
                 "Must be a string");
@@ -134,12 +152,15 @@ struct Underlying<
                                   std::optional<std::string>, std::string>;
 };
 
-template <class T, class Operand1Type, class Operand2Type>
-struct Underlying<T, Operation<Operator::round, Operand1Type, Operand2Type>> {
+template <class TableTupleType, class Operand1Type, class Operand2Type>
+struct Underlying<TableTupleType,
+                  Operation<Operator::round, Operand1Type, Operand2Type>> {
   using Underlying1 =
-      typename Underlying<T, std::remove_cvref_t<Operand1Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand1Type>>::Type;
   using Underlying2 =
-      typename Underlying<T, std::remove_cvref_t<Operand2Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand2Type>>::Type;
 
   static_assert(std::is_integral_v<remove_nullable_t<Underlying1>> ||
                     std::is_floating_point_v<remove_nullable_t<Underlying1>>,
@@ -149,9 +170,10 @@ struct Underlying<T, Operation<Operator::round, Operand1Type, Operand2Type>> {
   using Type = Underlying1;
 };
 
-template <class T, class Operand1Type>
-struct Underlying<T, Operation<Operator::unixepoch, Operand1Type>> {
-  using Underlying1 = typename Underlying<T, Operand1Type>::Type;
+template <class TableTupleType, class Operand1Type>
+struct Underlying<TableTupleType,
+                  Operation<Operator::unixepoch, Operand1Type>> {
+  using Underlying1 = typename Underlying<TableTupleType, Operand1Type>::Type;
 
   static_assert(is_timestamp_v<remove_nullable_t<Underlying1>>,
                 "Must be a timestamp");
@@ -160,12 +182,13 @@ struct Underlying<T, Operation<Operator::unixepoch, Operand1Type>> {
                                   std::optional<time_t>, time_t>;
 };
 
-template <class T, Operator _op, class Operand1Type>
+template <class TableTupleType, Operator _op, class Operand1Type>
   requires((num_operands_v<_op>) == 1 &&
            (operator_category_v<_op>) == OperatorCategory::date_part)
-struct Underlying<T, Operation<_op, Operand1Type>> {
+struct Underlying<TableTupleType, Operation<_op, Operand1Type>> {
   using Underlying1 =
-      typename Underlying<T, std::remove_cvref_t<Operand1Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand1Type>>::Type;
 
   static_assert(is_timestamp_v<remove_nullable_t<Underlying1>>,
                 "Must be a timestamp");
@@ -174,12 +197,13 @@ struct Underlying<T, Operation<_op, Operand1Type>> {
       std::conditional_t<is_nullable_v<Underlying1>, std::optional<int>, int>;
 };
 
-template <class T, Operator _op, class Operand1Type>
+template <class TableTupleType, Operator _op, class Operand1Type>
   requires((num_operands_v<_op>) == 1 &&
            (operator_category_v<_op>) == OperatorCategory::string)
-struct Underlying<T, Operation<_op, Operand1Type>> {
+struct Underlying<TableTupleType, Operation<_op, Operand1Type>> {
   using Underlying1 =
-      typename Underlying<T, std::remove_cvref_t<Operand1Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand1Type>>::Type;
 
   static_assert(std::is_same_v<remove_nullable_t<Underlying1>, std::string>,
                 "Must be a string");
@@ -193,14 +217,17 @@ struct Underlying<T, Operation<_op, Operand1Type>> {
       std::conditional_t<_op == Operator::length, SizeType, StringType>;
 };
 
-template <class T, Operator _op, class Operand1Type, class Operand2Type>
+template <class TableTupleType, Operator _op, class Operand1Type,
+          class Operand2Type>
   requires((num_operands_v<_op>) == 2 &&
            (operator_category_v<_op>) == OperatorCategory::string)
-struct Underlying<T, Operation<_op, Operand1Type, Operand2Type>> {
+struct Underlying<TableTupleType, Operation<_op, Operand1Type, Operand2Type>> {
   using Underlying1 =
-      typename Underlying<T, std::remove_cvref_t<Operand1Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand1Type>>::Type;
   using Underlying2 =
-      typename Underlying<T, std::remove_cvref_t<Operand2Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand2Type>>::Type;
 
   static_assert(std::is_same_v<remove_nullable_t<Underlying1>, std::string>,
                 "Must be a string");
@@ -212,12 +239,13 @@ struct Underlying<T, Operation<_op, Operand1Type, Operand2Type>> {
                                   std::optional<std::string>, std::string>;
 };
 
-template <class T, Operator _op, class Operand1Type>
+template <class TableTupleType, Operator _op, class Operand1Type>
   requires((num_operands_v<_op>) == 1 &&
            (operator_category_v<_op>) == OperatorCategory::numerical)
-struct Underlying<T, Operation<_op, Operand1Type>> {
+struct Underlying<TableTupleType, Operation<_op, Operand1Type>> {
   using Underlying1 =
-      typename Underlying<T, std::remove_cvref_t<Operand1Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand1Type>>::Type;
 
   static_assert(std::is_integral_v<remove_nullable_t<Underlying1>> ||
                     std::is_floating_point_v<remove_nullable_t<Underlying1>>,
@@ -226,14 +254,17 @@ struct Underlying<T, Operation<_op, Operand1Type>> {
   using Type = Underlying1;
 };
 
-template <class T, Operator _op, class Operand1Type, class Operand2Type>
+template <class TableTupleType, Operator _op, class Operand1Type,
+          class Operand2Type>
   requires((num_operands_v<_op>) == 2 &&
            (operator_category_v<_op>) == OperatorCategory::numerical)
-struct Underlying<T, Operation<_op, Operand1Type, Operand2Type>> {
+struct Underlying<TableTupleType, Operation<_op, Operand1Type, Operand2Type>> {
   using Underlying1 =
-      typename Underlying<T, std::remove_cvref_t<Operand1Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand1Type>>::Type;
   using Underlying2 =
-      typename Underlying<T, std::remove_cvref_t<Operand2Type>>::Type;
+      typename Underlying<TableTupleType,
+                          std::remove_cvref_t<Operand2Type>>::Type;
 
   static_assert(
       requires(remove_nullable_t<Underlying1> op1,
@@ -249,14 +280,14 @@ struct Underlying<T, Operation<_op, Operand1Type, Operand2Type>> {
                                   std::optional<ResultType>, ResultType>;
 };
 
-template <class T, class _Type>
-struct Underlying<T, Value<_Type>> {
+template <class TableTupleType, class _Type>
+struct Underlying<TableTupleType, Value<_Type>> {
   using Type = remove_reflection_t<_Type>;
 };
 
-template <class T, class U>
-using underlying_t =
-    typename Underlying<std::remove_cvref_t<T>, std::remove_cvref_t<U>>::Type;
+template <class TableTupleType, class T>
+using underlying_t = typename Underlying<std::remove_cvref_t<TableTupleType>,
+                                         std::remove_cvref_t<T>>::Type;
 
 }  // namespace sqlgen::transpilation
 
diff --git a/src/sqlgen/internal/strings/strings.cpp b/src/sqlgen/internal/strings/strings.cpp
index 20890cc..2d8b4f5 100644
--- a/src/sqlgen/internal/strings/strings.cpp
+++ b/src/sqlgen/internal/strings/strings.cpp
@@ -10,6 +10,14 @@ char to_lower(const char ch) {
   }
 }
 
+std::string to_lower(const std::string& _str) {
+  auto str = _str;
+  for (char& ch : str) {
+    ch = to_lower(ch);
+  }
+  return str;
+}
+
 char to_upper(const char ch) {
   if (ch >= 'a' && ch <= 'z') {
     return ch + ('A' - 'a');
@@ -18,6 +26,14 @@ char to_upper(const char ch) {
   }
 }
 
+std::string to_upper(const std::string& _str) {
+  auto str = _str;
+  for (char& ch : str) {
+    ch = to_upper(ch);
+  }
+  return str;
+}
+
 std::string join(const std::string& _delimiter,
                  const std::vector<std::string>& _strings) {
   if (_strings.size() == 0) {
diff --git a/src/sqlgen/postgres/to_sql.cpp b/src/sqlgen/postgres/to_sql.cpp
index 156634e..89f292b 100644
--- a/src/sqlgen/postgres/to_sql.cpp
+++ b/src/sqlgen/postgres/to_sql.cpp
@@ -6,6 +6,7 @@
 #include <stdexcept>
 #include <type_traits>
 
+#include "sqlgen/dynamic/Join.hpp"
 #include "sqlgen/dynamic/Operation.hpp"
 #include "sqlgen/internal/collect/vector.hpp"
 #include "sqlgen/internal/strings/strings.hpp"
@@ -41,6 +42,8 @@ std::vector<std::string> get_primary_keys(
 
 std::string insert_to_sql(const dynamic::Insert& _stmt) noexcept;
 
+std::string join_to_sql(const dynamic::Join& _stmt) noexcept;
+
 std::string operation_to_sql(const dynamic::Operation& _stmt) noexcept;
 
 std::string properties_to_sql(const dynamic::types::Properties& _p) noexcept;
@@ -115,7 +118,11 @@ std::string column_or_value_to_sql(
   return _col.visit([&](const auto& _c) -> std::string {
     using Type = std::remove_cvref_t<decltype(_c)>;
     if constexpr (std::is_same_v<Type, dynamic::Column>) {
-      return wrap_in_quotes(_c.name);
+      if (_c.alias) {
+        return *_c.alias + "." + wrap_in_quotes(_c.name);
+      } else {
+        return wrap_in_quotes(_c.name);
+      }
     } else {
       return _c.val.visit(handle_value);
     }
@@ -366,6 +373,35 @@ std::string insert_to_sql(const dynamic::Insert& _stmt) noexcept {
   return stream.str();
 }
 
+std::string join_to_sql(const dynamic::Join& _stmt) noexcept {
+  std::stringstream stream;
+
+  stream << internal::strings::to_upper(internal::strings::replace_all(
+                rfl::enum_to_string(_stmt.how), "_", " "))
+         << " ";
+
+  stream << _stmt.table_or_query.visit(
+                [](const auto& _table_or_query) -> std::string {
+                  using Type = std::remove_cvref_t<decltype(_table_or_query)>;
+                  if constexpr (std::is_same_v<Type, dynamic::Table>) {
+                    return wrap_in_quotes(_table_or_query.name);
+                  } else {
+                    return "(" + select_from_to_sql(*_table_or_query) + ")";
+                  }
+                })
+         << " ";
+
+  stream << _stmt.alias << " ";
+
+  if (_stmt.on) {
+    stream << "ON " << condition_to_sql(*_stmt.on);
+  } else {
+    stream << "ON 1 = 1";
+  }
+
+  return stream.str();
+}
+
 std::string operation_to_sql(const dynamic::Operation& _stmt) noexcept {
   using namespace std::ranges::views;
   return _stmt.val.visit([](const auto& _s) -> std::string {
@@ -544,7 +580,7 @@ std::string select_from_to_sql(const dynamic::SelectFrom& _stmt) noexcept {
   using namespace std::ranges::views;
 
   const auto order_by_to_str = [](const auto& _w) -> std::string {
-    return "\"" + _w.column.name + "\"" + (_w.desc ? " DESC" : "");
+    return column_or_value_to_sql(_w.column) + (_w.desc ? " DESC" : "");
   };
 
   std::stringstream stream;
@@ -559,6 +595,17 @@ std::string select_from_to_sql(const dynamic::SelectFrom& _stmt) noexcept {
   }
   stream << wrap_in_quotes(_stmt.table.name);
 
+  if (_stmt.alias) {
+    stream << " " << *_stmt.alias;
+  }
+
+  if (_stmt.joins) {
+    stream << " "
+           << internal::strings::join(
+                  " ", internal::collect::vector(*_stmt.joins |
+                                                 transform(join_to_sql)));
+  }
+
   if (_stmt.where) {
     stream << " WHERE " << condition_to_sql(*_stmt.where);
   }
@@ -582,8 +629,6 @@ std::string select_from_to_sql(const dynamic::SelectFrom& _stmt) noexcept {
     stream << " LIMIT " << _stmt.limit->val;
   }
 
-  stream << ";";
-
   return stream.str();
 }
 
diff --git a/src/sqlgen/sqlite/to_sql.cpp b/src/sqlgen/sqlite/to_sql.cpp
index 3a76fca..5b34dea 100644
--- a/src/sqlgen/sqlite/to_sql.cpp
+++ b/src/sqlgen/sqlite/to_sql.cpp
@@ -2,6 +2,7 @@
 #include <rfl.hpp>
 #include <sstream>
 
+#include "sqlgen/dynamic/Join.hpp"
 #include "sqlgen/dynamic/Operation.hpp"
 #include "sqlgen/internal/collect/vector.hpp"
 #include "sqlgen/internal/strings/strings.hpp"
@@ -37,6 +38,8 @@ std::string field_to_str(const dynamic::SelectFrom::Field& _field) noexcept;
 template <class InsertOrWrite>
 std::string insert_or_write_to_sql(const InsertOrWrite& _stmt) noexcept;
 
+std::string join_to_sql(const dynamic::Join& _stmt) noexcept;
+
 std::string operation_to_sql(const dynamic::Operation& _stmt) noexcept;
 
 std::string properties_to_sql(const dynamic::types::Properties& _p) noexcept;
@@ -47,6 +50,16 @@ std::string type_to_sql(const dynamic::Type& _type) noexcept;
 
 std::string update_to_sql(const dynamic::Update& _stmt) noexcept;
 
+// ----------------------------------------------------------------------------
+
+inline std::string get_name(const dynamic::Column& _col) { return _col.name; }
+
+inline std::string wrap_in_quotes(const std::string& _name) noexcept {
+  return "\"" + _name + "\"";
+}
+
+// ----------------------------------------------------------------------------
+
 std::string aggregation_to_sql(
     const dynamic::Aggregation& _aggregation) noexcept {
   return _aggregation.val.visit([](const auto& _agg) -> std::string {
@@ -127,7 +140,11 @@ std::string column_or_value_to_sql(
   return _col.visit([&](const auto& _c) -> std::string {
     using Type = std::remove_cvref_t<decltype(_c)>;
     if constexpr (std::is_same_v<Type, dynamic::Column>) {
-      return "\"" + _c.name + "\"";
+      if (_c.alias) {
+        return *_c.alias + "." + wrap_in_quotes(_c.name);
+      } else {
+        return wrap_in_quotes(_c.name);
+      }
     } else {
       return _c.val.visit(handle_value);
     }
@@ -360,6 +377,35 @@ std::string insert_or_write_to_sql(const InsertOrWrite& _stmt) noexcept {
   return stream.str();
 }
 
+std::string join_to_sql(const dynamic::Join& _stmt) noexcept {
+  std::stringstream stream;
+
+  stream << internal::strings::to_upper(internal::strings::replace_all(
+                rfl::enum_to_string(_stmt.how), "_", " "))
+         << " ";
+
+  stream << _stmt.table_or_query.visit(
+                [](const auto& _table_or_query) -> std::string {
+                  using Type = std::remove_cvref_t<decltype(_table_or_query)>;
+                  if constexpr (std::is_same_v<Type, dynamic::Table>) {
+                    return wrap_in_quotes(_table_or_query.name);
+                  } else {
+                    return "(" + select_from_to_sql(*_table_or_query) + ")";
+                  }
+                })
+         << " ";
+
+  stream << _stmt.alias << " ";
+
+  if (_stmt.on) {
+    stream << "ON " << condition_to_sql(*_stmt.on);
+  } else {
+    stream << "ON 1 = 1";
+  }
+
+  return stream.str();
+}
+
 std::string operation_to_sql(const dynamic::Operation& _stmt) noexcept {
   using namespace std::ranges::views;
   return _stmt.val.visit([](const auto& _s) -> std::string {
@@ -542,7 +588,7 @@ std::string select_from_to_sql(const dynamic::SelectFrom& _stmt) noexcept {
   using namespace std::ranges::views;
 
   const auto order_by_to_str = [](const auto& _w) -> std::string {
-    return "\"" + _w.column.name + "\"" + (_w.desc ? " DESC" : "");
+    return column_or_value_to_sql(_w.column) + (_w.desc ? " DESC" : "");
   };
 
   std::stringstream stream;
@@ -553,9 +599,20 @@ std::string select_from_to_sql(const dynamic::SelectFrom& _stmt) noexcept {
 
   stream << " FROM ";
   if (_stmt.table.schema) {
-    stream << "\"" << *_stmt.table.schema << "\".";
+    stream << wrap_in_quotes(*_stmt.table.schema) << ".";
+  }
+  stream << wrap_in_quotes(_stmt.table.name);
+
+  if (_stmt.alias) {
+    stream << " " << *_stmt.alias;
+  }
+
+  if (_stmt.joins) {
+    stream << " "
+           << internal::strings::join(
+                  " ", internal::collect::vector(*_stmt.joins |
+                                                 transform(join_to_sql)));
   }
-  stream << "\"" << _stmt.table.name << "\"";
 
   if (_stmt.where) {
     stream << " WHERE " << condition_to_sql(*_stmt.where);
@@ -580,8 +637,6 @@ std::string select_from_to_sql(const dynamic::SelectFrom& _stmt) noexcept {
     stream << " LIMIT " << _stmt.limit->val;
   }
 
-  stream << ";";
-
   return stream.str();
 }
 
diff --git a/tests/postgres/test_is_null_dry.cpp b/tests/postgres/test_is_null_dry.cpp
index 7acc501..d015458 100644
--- a/tests/postgres/test_is_null_dry.cpp
+++ b/tests/postgres/test_is_null_dry.cpp
@@ -23,7 +23,7 @@ TEST(postgres, test_is_null_dry) {
                                     order_by("first_name"_c.desc()));
 
   const std::string expected =
-      R"(SELECT "id", "first_name", "last_name", "age" FROM "Person" WHERE "age" IS NULL ORDER BY "first_name" DESC;)";
+      R"(SELECT "id", "first_name", "last_name", "age" FROM "Person" WHERE "age" IS NULL ORDER BY "first_name" DESC)";
 
   EXPECT_EQ(sql, expected);
 }
diff --git a/tests/postgres/test_join.cpp b/tests/postgres/test_join.cpp
new file mode 100644
index 0000000..116d37d
--- /dev/null
+++ b/tests/postgres/test_join.cpp
@@ -0,0 +1,64 @@
+#ifndef SQLGEN_BUILD_DRY_TESTS_ONLY
+
+#include <gtest/gtest.h>
+
+#include <ranges>
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/postgres.hpp>
+#include <vector>
+
+namespace test_join {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+TEST(postgres, test_join) {
+  static_assert(std::ranges::input_range<sqlgen::Range<Person>>,
+                "Must be an input range.");
+
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{.id = 1, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 2, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 3, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  const auto credentials = sqlgen::postgres::Credentials{.user = "postgres",
+                                                         .password = "password",
+                                                         .host = "localhost",
+                                                         .dbname = "postgres"};
+
+  using namespace sqlgen;
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "id"_t1 | as<"id">, "first_name"_t1 | as<"first_name">,
+          "last_name"_t2 | as<"last_name">, "age"_t2 | as<"age">) |
+      left_join<Person, "t2">("id"_t1 == "id"_t2) | order_by("id"_t1) |
+      to<std::vector<Person>>;
+
+  const auto people = postgres::connect(credentials)
+                          .and_then(drop<Person> | if_exists)
+                          .and_then(write(std::ref(people1)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."id" AS "id", t1."first_name" AS "first_name", t2."last_name" AS "last_name", t2."age" AS "age" FROM "Person" t1 LEFT JOIN "Person" t2 ON t1."id" = t2."id" ORDER BY t1."id")";
+  const std::string expected =
+      R"([{"id":0,"first_name":"Homer","last_name":"Simpson","age":45.0},{"id":1,"first_name":"Bart","last_name":"Simpson","age":10.0},{"id":2,"first_name":"Lisa","last_name":"Simpson","age":8.0},{"id":3,"first_name":"Maggie","last_name":"Simpson","age":0.0}])";
+
+  EXPECT_EQ(postgres::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_join
+
+#endif
diff --git a/tests/postgres/test_joins_nested.cpp b/tests/postgres/test_joins_nested.cpp
new file mode 100644
index 0000000..0182353
--- /dev/null
+++ b/tests/postgres/test_joins_nested.cpp
@@ -0,0 +1,94 @@
+#ifndef SQLGEN_BUILD_DRY_TESTS_ONLY
+
+#include <gtest/gtest.h>
+
+#include <ranges>
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/postgres.hpp>
+#include <vector>
+
+namespace test_joins_nested {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+struct Relationship {
+  sqlgen::PrimaryKey<uint32_t> parent_id;
+  sqlgen::PrimaryKey<uint32_t> child_id;
+};
+
+TEST(postgres, test_joins_nested) {
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{
+           .id = 1, .first_name = "Marge", .last_name = "Simpson", .age = 40},
+       Person{.id = 2, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 3, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 4, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  const auto relationships =
+      std::vector<Relationship>({Relationship{.parent_id = 0, .child_id = 2},
+                                 Relationship{.parent_id = 0, .child_id = 3},
+                                 Relationship{.parent_id = 0, .child_id = 4},
+                                 Relationship{.parent_id = 1, .child_id = 2},
+                                 Relationship{.parent_id = 1, .child_id = 3},
+                                 Relationship{.parent_id = 1, .child_id = 4}});
+
+  const auto credentials = sqlgen::postgres::Credentials{.user = "postgres",
+                                                         .password = "password",
+                                                         .host = "localhost",
+                                                         .dbname = "postgres"};
+
+  using namespace sqlgen;
+
+  struct ParentAndChild {
+    std::string last_name;
+    std::string first_name_parent;
+    std::string first_name_child;
+    double parent_age_at_birth;
+  };
+
+  const auto get_children =
+      select_from<Relationship, "t1">("parent_id"_t1 | as<"id">,
+                                      "first_name"_t2 | as<"first_name">,
+                                      "age"_t2 | as<"age">) |
+      left_join<Person, "t2">("id"_t2 == "child_id"_t1);
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "last_name"_t1 | as<"last_name">,
+          "first_name"_t1 | as<"first_name_parent">,
+          "first_name"_t2 | as<"first_name_child">,
+          ("age"_t1 - "age"_t2) | as<"parent_age_at_birth">) |
+      inner_join<"t2">(get_children, "id"_t1 == "id"_t2) |
+      order_by("id"_t1, "id"_t2) | to<std::vector<ParentAndChild>>;
+
+  const auto people = postgres::connect(credentials)
+                          .and_then(drop<Person> | if_exists)
+                          .and_then(drop<Relationship> | if_exists)
+                          .and_then(write(std::ref(people1)))
+                          .and_then(write(std::ref(relationships)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."last_name" AS "last_name", t1."first_name" AS "first_name_parent", t2."first_name" AS "first_name_child", (t1."age") - (t2."age") AS "parent_age_at_birth" FROM "Person" t1 INNER JOIN (SELECT t1."parent_id" AS "id", t2."first_name" AS "first_name", t2."age" AS "age" FROM "Relationship" t1 LEFT JOIN "Person" t2 ON t2."id" = t1."child_id") t2 ON t1."id" = t2."id" ORDER BY t1."id", t2."id")";
+
+  const std::string expected =
+      R"([{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Bart","parent_age_at_birth":35.0},{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Lisa","parent_age_at_birth":37.0},{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Maggie","parent_age_at_birth":45.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Bart","parent_age_at_birth":30.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Lisa","parent_age_at_birth":32.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Maggie","parent_age_at_birth":40.0}])";
+
+  EXPECT_EQ(postgres::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_joins_nested
+
+#endif
diff --git a/tests/postgres/test_joins_nested_grouped.cpp b/tests/postgres/test_joins_nested_grouped.cpp
new file mode 100644
index 0000000..71355a8
--- /dev/null
+++ b/tests/postgres/test_joins_nested_grouped.cpp
@@ -0,0 +1,93 @@
+#ifndef SQLGEN_BUILD_DRY_TESTS_ONLY
+
+#include <gtest/gtest.h>
+
+#include <ranges>
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/postgres.hpp>
+#include <vector>
+
+namespace test_joins_nested_grouped {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+struct Relationship {
+  sqlgen::PrimaryKey<uint32_t> parent_id;
+  sqlgen::PrimaryKey<uint32_t> child_id;
+};
+
+TEST(postgres, test_joins_nested) {
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{
+           .id = 1, .first_name = "Marge", .last_name = "Simpson", .age = 40},
+       Person{.id = 2, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 3, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 4, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  const auto relationships =
+      std::vector<Relationship>({Relationship{.parent_id = 0, .child_id = 2},
+                                 Relationship{.parent_id = 0, .child_id = 3},
+                                 Relationship{.parent_id = 0, .child_id = 4},
+                                 Relationship{.parent_id = 1, .child_id = 2},
+                                 Relationship{.parent_id = 1, .child_id = 3},
+                                 Relationship{.parent_id = 1, .child_id = 4}});
+
+  const auto credentials = sqlgen::postgres::Credentials{.user = "postgres",
+                                                         .password = "password",
+                                                         .host = "localhost",
+                                                         .dbname = "postgres"};
+
+  using namespace sqlgen;
+
+  struct ParentAndChild {
+    std::string last_name;
+    std::string first_name_child;
+    double avg_parent_age_at_birth;
+  };
+
+  const auto get_children =
+      select_from<Relationship, "t1">("parent_id"_t1 | as<"id">,
+                                      "first_name"_t2 | as<"first_name">,
+                                      "age"_t2 | as<"age">) |
+      left_join<Person, "t2">("id"_t2 == "child_id"_t1);
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "last_name"_t1 | as<"last_name">,
+          "first_name"_t2 | as<"first_name_child">,
+          avg("age"_t1 - "age"_t2) | as<"avg_parent_age_at_birth">) |
+      inner_join<"t2">(get_children, "id"_t1 == "id"_t2) |
+      group_by("last_name"_t1, "first_name"_t2) | order_by("first_name"_t2) |
+      to<std::vector<ParentAndChild>>;
+
+  const auto people = postgres::connect(credentials)
+                          .and_then(drop<Person> | if_exists)
+                          .and_then(drop<Relationship> | if_exists)
+                          .and_then(write(std::ref(people1)))
+                          .and_then(write(std::ref(relationships)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."last_name" AS "last_name", t2."first_name" AS "first_name_child", AVG((t1."age") - (t2."age")) AS "avg_parent_age_at_birth" FROM "Person" t1 INNER JOIN (SELECT t1."parent_id" AS "id", t2."first_name" AS "first_name", t2."age" AS "age" FROM "Relationship" t1 LEFT JOIN "Person" t2 ON t2."id" = t1."child_id") t2 ON t1."id" = t2."id" GROUP BY t1."last_name", t2."first_name" ORDER BY t2."first_name")";
+
+  const std::string expected =
+      R"([{"last_name":"Simpson","first_name_child":"Bart","avg_parent_age_at_birth":32.5},{"last_name":"Simpson","first_name_child":"Lisa","avg_parent_age_at_birth":34.5},{"last_name":"Simpson","first_name_child":"Maggie","avg_parent_age_at_birth":42.5}])";
+
+  EXPECT_EQ(postgres::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_joins_nested_grouped
+
+#endif
diff --git a/tests/postgres/test_joins_two_tables.cpp b/tests/postgres/test_joins_two_tables.cpp
new file mode 100644
index 0000000..7e5b917
--- /dev/null
+++ b/tests/postgres/test_joins_two_tables.cpp
@@ -0,0 +1,88 @@
+#ifndef SQLGEN_BUILD_DRY_TESTS_ONLY
+
+#include <gtest/gtest.h>
+
+#include <ranges>
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/postgres.hpp>
+#include <vector>
+
+namespace test_joins_two_tables {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+struct Relationship {
+  sqlgen::PrimaryKey<uint32_t> parent_id;
+  sqlgen::PrimaryKey<uint32_t> child_id;
+};
+
+TEST(postgres, test_joins_two_tables) {
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{
+           .id = 1, .first_name = "Marge", .last_name = "Simpson", .age = 40},
+       Person{.id = 2, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 3, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 4, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  const auto relationships =
+      std::vector<Relationship>({Relationship{.parent_id = 0, .child_id = 2},
+                                 Relationship{.parent_id = 0, .child_id = 3},
+                                 Relationship{.parent_id = 0, .child_id = 4},
+                                 Relationship{.parent_id = 1, .child_id = 2},
+                                 Relationship{.parent_id = 1, .child_id = 3},
+                                 Relationship{.parent_id = 1, .child_id = 4}});
+
+  const auto credentials = sqlgen::postgres::Credentials{.user = "postgres",
+                                                         .password = "password",
+                                                         .host = "localhost",
+                                                         .dbname = "postgres"};
+
+  using namespace sqlgen;
+
+  struct ParentAndChild {
+    std::string last_name;
+    std::string first_name_parent;
+    std::string first_name_child;
+    double parent_age_at_birth;
+  };
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "last_name"_t1 | as<"last_name">,
+          "first_name"_t1 | as<"first_name_parent">,
+          "first_name"_t3 | as<"first_name_child">,
+          ("age"_t1 - "age"_t3) | as<"parent_age_at_birth">) |
+      inner_join<Relationship, "t2">("id"_t1 == "parent_id"_t2) |
+      left_join<Person, "t3">("id"_t3 == "child_id"_t2) |
+      order_by("id"_t1, "id"_t3) | to<std::vector<ParentAndChild>>;
+
+  const auto people = postgres::connect(credentials)
+                          .and_then(drop<Person> | if_exists)
+                          .and_then(drop<Relationship> | if_exists)
+                          .and_then(write(std::ref(people1)))
+                          .and_then(write(std::ref(relationships)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."last_name" AS "last_name", t1."first_name" AS "first_name_parent", t3."first_name" AS "first_name_child", (t1."age") - (t3."age") AS "parent_age_at_birth" FROM "Person" t1 INNER JOIN "Relationship" t2 ON t1."id" = t2."parent_id" LEFT JOIN "Person" t3 ON t3."id" = t2."child_id" ORDER BY t1."id", t3."id")";
+  const std::string expected =
+      R"([{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Bart","parent_age_at_birth":35.0},{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Lisa","parent_age_at_birth":37.0},{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Maggie","parent_age_at_birth":45.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Bart","parent_age_at_birth":30.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Lisa","parent_age_at_birth":32.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Maggie","parent_age_at_birth":40.0}])";
+
+  EXPECT_EQ(postgres::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_joins_two_tables
+
+#endif
diff --git a/tests/postgres/test_joins_two_tables_grouped.cpp b/tests/postgres/test_joins_two_tables_grouped.cpp
new file mode 100644
index 0000000..90c8eec
--- /dev/null
+++ b/tests/postgres/test_joins_two_tables_grouped.cpp
@@ -0,0 +1,89 @@
+#ifndef SQLGEN_BUILD_DRY_TESTS_ONLY
+
+#include <gtest/gtest.h>
+
+#include <ranges>
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/postgres.hpp>
+#include <vector>
+
+namespace test_joins_two_tables_grouped {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+struct Relationship {
+  sqlgen::PrimaryKey<uint32_t> parent_id;
+  sqlgen::PrimaryKey<uint32_t> child_id;
+};
+
+TEST(postgres, test_joins_two_tables_grouped) {
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{
+           .id = 1, .first_name = "Marge", .last_name = "Simpson", .age = 40},
+       Person{.id = 2, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 3, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 4, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  const auto relationships =
+      std::vector<Relationship>({Relationship{.parent_id = 0, .child_id = 2},
+                                 Relationship{.parent_id = 0, .child_id = 3},
+                                 Relationship{.parent_id = 0, .child_id = 4},
+                                 Relationship{.parent_id = 1, .child_id = 2},
+                                 Relationship{.parent_id = 1, .child_id = 3},
+                                 Relationship{.parent_id = 1, .child_id = 4}});
+
+  const auto credentials = sqlgen::postgres::Credentials{.user = "postgres",
+                                                         .password = "password",
+                                                         .host = "localhost",
+                                                         .dbname = "postgres"};
+
+  using namespace sqlgen;
+
+  struct ParentAndChild {
+    std::string last_name;
+    std::string first_name_child;
+    double avg_parent_age_at_birth;
+  };
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "last_name"_t1 | as<"last_name">,
+          "first_name"_t3 | as<"first_name_child">,
+          avg("age"_t1 - "age"_t3) | as<"avg_parent_age_at_birth">) |
+      inner_join<Relationship, "t2">("id"_t1 == "parent_id"_t2) |
+      left_join<Person, "t3">("id"_t3 == "child_id"_t2) |
+      group_by("last_name"_t1, "first_name"_t3) |
+      order_by("last_name"_t1, "first_name"_t3) |
+      to<std::vector<ParentAndChild>>;
+
+  const auto people = postgres::connect(credentials)
+                          .and_then(drop<Person> | if_exists)
+                          .and_then(drop<Relationship> | if_exists)
+                          .and_then(write(std::ref(people1)))
+                          .and_then(write(std::ref(relationships)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."last_name" AS "last_name", t3."first_name" AS "first_name_child", AVG((t1."age") - (t3."age")) AS "avg_parent_age_at_birth" FROM "Person" t1 INNER JOIN "Relationship" t2 ON t1."id" = t2."parent_id" LEFT JOIN "Person" t3 ON t3."id" = t2."child_id" GROUP BY t1."last_name", t3."first_name" ORDER BY t1."last_name", t3."first_name")";
+
+  const std::string expected =
+      R"([{"last_name":"Simpson","first_name_child":"Bart","avg_parent_age_at_birth":32.5},{"last_name":"Simpson","first_name_child":"Lisa","avg_parent_age_at_birth":34.5},{"last_name":"Simpson","first_name_child":"Maggie","avg_parent_age_at_birth":42.5}])";
+
+  EXPECT_EQ(postgres::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_joins_two_tables_grouped
+
+#endif
diff --git a/tests/postgres/test_like_dry.cpp b/tests/postgres/test_like_dry.cpp
index c43aa3c..6547d2e 100644
--- a/tests/postgres/test_like_dry.cpp
+++ b/tests/postgres/test_like_dry.cpp
@@ -23,7 +23,7 @@ TEST(postgres, test_like_dry) {
                        where("first_name"_c.like("H%")) | order_by("age"_c));
 
   const std::string expected =
-      R"(SELECT "id", "first_name", "last_name", "age" FROM "Person" WHERE "first_name" LIKE 'H%' ORDER BY "age";)";
+      R"(SELECT "id", "first_name", "last_name", "age" FROM "Person" WHERE "first_name" LIKE 'H%' ORDER BY "age")";
 
   EXPECT_EQ(sql, expected);
 }
diff --git a/tests/postgres/test_select_from_with_timestamps.cpp b/tests/postgres/test_select_from_with_timestamps.cpp
index c0e168c..56a7f44 100644
--- a/tests/postgres/test_select_from_with_timestamps.cpp
+++ b/tests/postgres/test_select_from_with_timestamps.cpp
@@ -75,7 +75,7 @@ TEST(postgres, test_range_select_from_with_timestamps) {
                              .value();
 
   const std::string expected_query =
-      R"(SELECT "birthday" + INTERVAL '10 days' AS "birthday", cast((cast(extract(YEAR from "birthday") as TEXT) || '-' || cast(extract(MONTH from "birthday") as TEXT) || '-' || cast(extract(DAY from "birthday") as TEXT)) as TIMESTAMP) + INTERVAL '10 days' AS "birthday_recreated", cast('2011-01-01' as DATE) - cast("birthday" as DATE) AS "age_in_days", extract(EPOCH FROM "birthday" + INTERVAL '10 days') AS "birthday_unixepoch", extract(HOUR from "birthday") AS "hour", extract(MINUTE from "birthday") AS "minute", extract(SECOND from "birthday") AS "second", extract(DOW from "birthday") AS "weekday" FROM "Person" ORDER BY "id";)";
+      R"(SELECT "birthday" + INTERVAL '10 days' AS "birthday", cast((cast(extract(YEAR from "birthday") as TEXT) || '-' || cast(extract(MONTH from "birthday") as TEXT) || '-' || cast(extract(DAY from "birthday") as TEXT)) as TIMESTAMP) + INTERVAL '10 days' AS "birthday_recreated", cast('2011-01-01' as DATE) - cast("birthday" as DATE) AS "age_in_days", extract(EPOCH FROM "birthday" + INTERVAL '10 days') AS "birthday_unixepoch", extract(HOUR from "birthday") AS "hour", extract(MINUTE from "birthday") AS "minute", extract(SECOND from "birthday") AS "second", extract(DOW from "birthday") AS "weekday" FROM "Person" ORDER BY "id")";
 
   const std::string expected =
       R"([{"birthday":"1970-01-11","birthday_recreated":"1970-01-11","birthday_unixepoch":864000,"age_in_days":14975.0,"hour":0,"minute":0,"second":0,"weekday":4},{"birthday":"2000-01-11","birthday_recreated":"2000-01-11","birthday_unixepoch":947548800,"age_in_days":4018.0,"hour":0,"minute":0,"second":0,"weekday":6},{"birthday":"2002-01-11","birthday_recreated":"2002-01-11","birthday_unixepoch":1010707200,"age_in_days":3287.0,"hour":0,"minute":0,"second":0,"weekday":2},{"birthday":"2010-01-11","birthday_recreated":"2010-01-11","birthday_unixepoch":1263168000,"age_in_days":365.0,"hour":0,"minute":0,"second":0,"weekday":5}])";
diff --git a/tests/postgres/test_to_select_from2_dry.cpp b/tests/postgres/test_to_select_from2_dry.cpp
index 3929525..bb7e547 100644
--- a/tests/postgres/test_to_select_from2_dry.cpp
+++ b/tests/postgres/test_to_select_from2_dry.cpp
@@ -24,7 +24,7 @@ TEST(postgres, test_to_select_from2_dry) {
       order_by("field1"_c) | limit(10);
 
   const auto expected =
-      R"(SELECT "field1" AS "field", AVG("field2") AS "avg_field2", "nullable" AS "nullable_field", 1 AS "one", 'hello' AS "hello" FROM "TestTable" WHERE "id" > 0 GROUP BY "field1", "nullable" ORDER BY "field1" LIMIT 10;)";
+      R"(SELECT "field1" AS "field", AVG("field2") AS "avg_field2", "nullable" AS "nullable_field", 1 AS "one", 'hello' AS "hello" FROM "TestTable" WHERE "id" > 0 GROUP BY "field1", "nullable" ORDER BY "field1" LIMIT 10)";
 
   EXPECT_EQ(sqlgen::postgres::to_sql(query), expected);
 }
diff --git a/tests/postgres/test_to_select_from_dry.cpp b/tests/postgres/test_to_select_from_dry.cpp
index 2aeec5d..7559b8e 100644
--- a/tests/postgres/test_to_select_from_dry.cpp
+++ b/tests/postgres/test_to_select_from_dry.cpp
@@ -16,7 +16,7 @@ TEST(postgres, test_to_select_from_dry) {
   const auto query = sqlgen::read<std::vector<TestTable>>;
 
   const auto expected =
-      R"(SELECT "field1", "field2", "id", "nullable" FROM "TestTable";)";
+      R"(SELECT "field1", "field2", "id", "nullable" FROM "TestTable")";
 
   EXPECT_EQ(sqlgen::postgres::to_sql(query), expected);
 }
diff --git a/tests/postgres/test_where_dry.cpp b/tests/postgres/test_where_dry.cpp
index 284099d..6991da7 100644
--- a/tests/postgres/test_where_dry.cpp
+++ b/tests/postgres/test_where_dry.cpp
@@ -21,7 +21,7 @@ TEST(postgres, test_where_dry) {
                      order_by("age"_c);
 
   const auto expected =
-      R"(SELECT "id", "first_name", "last_name", "age" FROM "Person" WHERE ("age" < 18) AND ("first_name" != 'Hugo') ORDER BY "age";)";
+      R"(SELECT "id", "first_name", "last_name", "age" FROM "Person" WHERE ("age" < 18) AND ("first_name" != 'Hugo') ORDER BY "age")";
 
   EXPECT_EQ(sqlgen::postgres::to_sql(query), expected);
 }
diff --git a/tests/sqlite/test_join.cpp b/tests/sqlite/test_join.cpp
new file mode 100644
index 0000000..77263af
--- /dev/null
+++ b/tests/sqlite/test_join.cpp
@@ -0,0 +1,50 @@
+#include <gtest/gtest.h>
+
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/sqlite.hpp>
+#include <vector>
+
+namespace test_join {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+TEST(sqlite, test_join) {
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{.id = 1, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 2, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 3, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  using namespace sqlgen;
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "id"_t1 | as<"id">, "first_name"_t1 | as<"first_name">,
+          "last_name"_t2 | as<"last_name">, "age"_t2 | as<"age">) |
+      left_join<Person, "t2">("id"_t1 == "id"_t2) | order_by("id"_t1) |
+      to<std::vector<Person>>;
+
+  const auto people = sqlite::connect()
+                          .and_then(write(std::ref(people1)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."id" AS "id", t1."first_name" AS "first_name", t2."last_name" AS "last_name", t2."age" AS "age" FROM "Person" t1 LEFT JOIN "Person" t2 ON t1."id" = t2."id" ORDER BY t1."id")";
+  const std::string expected =
+      R"([{"id":0,"first_name":"Homer","last_name":"Simpson","age":45.0},{"id":1,"first_name":"Bart","last_name":"Simpson","age":10.0},{"id":2,"first_name":"Lisa","last_name":"Simpson","age":8.0},{"id":3,"first_name":"Maggie","last_name":"Simpson","age":0.0}])";
+
+  EXPECT_EQ(sqlite::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_join
diff --git a/tests/sqlite/test_joins_nested.cpp b/tests/sqlite/test_joins_nested.cpp
new file mode 100644
index 0000000..d794780
--- /dev/null
+++ b/tests/sqlite/test_joins_nested.cpp
@@ -0,0 +1,81 @@
+#include <gtest/gtest.h>
+
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/sqlite.hpp>
+#include <vector>
+
+namespace test_joins_nested {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+struct Relationship {
+  uint32_t parent_id;
+  uint32_t child_id;
+};
+
+TEST(sqlite, test_joins_nested) {
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{
+           .id = 1, .first_name = "Marge", .last_name = "Simpson", .age = 40},
+       Person{.id = 2, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 3, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 4, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  const auto relationships =
+      std::vector<Relationship>({Relationship{.parent_id = 0, .child_id = 2},
+                                 Relationship{.parent_id = 0, .child_id = 3},
+                                 Relationship{.parent_id = 0, .child_id = 4},
+                                 Relationship{.parent_id = 1, .child_id = 2},
+                                 Relationship{.parent_id = 1, .child_id = 3},
+                                 Relationship{.parent_id = 1, .child_id = 4}});
+
+  using namespace sqlgen;
+
+  struct ParentAndChild {
+    std::string last_name;
+    std::string first_name_parent;
+    std::string first_name_child;
+    double parent_age_at_birth;
+  };
+
+  const auto get_children =
+      select_from<Relationship, "t1">("parent_id"_t1 | as<"id">,
+                                      "first_name"_t2 | as<"first_name">,
+                                      "age"_t2 | as<"age">) |
+      left_join<Person, "t2">("id"_t2 == "child_id"_t1);
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "last_name"_t1 | as<"last_name">,
+          "first_name"_t1 | as<"first_name_parent">,
+          "first_name"_t2 | as<"first_name_child">,
+          ("age"_t1 - "age"_t2) | as<"parent_age_at_birth">) |
+      inner_join<"t2">(get_children, "id"_t1 == "id"_t2) |
+      order_by("id"_t1, "id"_t2) | to<std::vector<ParentAndChild>>;
+
+  const auto people = sqlite::connect()
+                          .and_then(write(std::ref(people1)))
+                          .and_then(write(std::ref(relationships)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."last_name" AS "last_name", t1."first_name" AS "first_name_parent", t2."first_name" AS "first_name_child", (t1."age") - (t2."age") AS "parent_age_at_birth" FROM "Person" t1 INNER JOIN (SELECT t1."parent_id" AS "id", t2."first_name" AS "first_name", t2."age" AS "age" FROM "Relationship" t1 LEFT JOIN "Person" t2 ON t2."id" = t1."child_id") t2 ON t1."id" = t2."id" ORDER BY t1."id", t2."id")";
+  const std::string expected =
+      R"([{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Bart","parent_age_at_birth":35.0},{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Lisa","parent_age_at_birth":37.0},{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Maggie","parent_age_at_birth":45.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Bart","parent_age_at_birth":30.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Lisa","parent_age_at_birth":32.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Maggie","parent_age_at_birth":40.0}])";
+
+  EXPECT_EQ(sqlite::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_joins_nested
diff --git a/tests/sqlite/test_joins_nested_grouped.cpp b/tests/sqlite/test_joins_nested_grouped.cpp
new file mode 100644
index 0000000..8f74fbd
--- /dev/null
+++ b/tests/sqlite/test_joins_nested_grouped.cpp
@@ -0,0 +1,80 @@
+#include <gtest/gtest.h>
+
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/sqlite.hpp>
+#include <vector>
+
+namespace test_joins_nested_grouped {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+struct Relationship {
+  uint32_t parent_id;
+  uint32_t child_id;
+};
+
+TEST(sqlite, test_joins_nested_grouped) {
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{
+           .id = 1, .first_name = "Marge", .last_name = "Simpson", .age = 40},
+       Person{.id = 2, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 3, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 4, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  const auto relationships =
+      std::vector<Relationship>({Relationship{.parent_id = 0, .child_id = 2},
+                                 Relationship{.parent_id = 0, .child_id = 3},
+                                 Relationship{.parent_id = 0, .child_id = 4},
+                                 Relationship{.parent_id = 1, .child_id = 2},
+                                 Relationship{.parent_id = 1, .child_id = 3},
+                                 Relationship{.parent_id = 1, .child_id = 4}});
+
+  using namespace sqlgen;
+
+  struct ParentAndChild {
+    std::string last_name;
+    std::string first_name_child;
+    double avg_parent_age_at_birth;
+  };
+
+  const auto get_children =
+      select_from<Relationship, "t1">("parent_id"_t1 | as<"id">,
+                                      "first_name"_t2 | as<"first_name">,
+                                      "age"_t2 | as<"age">) |
+      left_join<Person, "t2">("id"_t2 == "child_id"_t1);
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "last_name"_t1 | as<"last_name">,
+          "first_name"_t2 | as<"first_name_child">,
+          avg("age"_t1 - "age"_t2) | as<"avg_parent_age_at_birth">) |
+      inner_join<"t2">(get_children, "id"_t1 == "id"_t2) |
+      group_by("last_name"_t1, "first_name"_t2) | order_by("first_name"_t2) |
+      to<std::vector<ParentAndChild>>;
+
+  const auto people = sqlite::connect()
+                          .and_then(write(std::ref(people1)))
+                          .and_then(write(std::ref(relationships)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."last_name" AS "last_name", t2."first_name" AS "first_name_child", AVG((t1."age") - (t2."age")) AS "avg_parent_age_at_birth" FROM "Person" t1 INNER JOIN (SELECT t1."parent_id" AS "id", t2."first_name" AS "first_name", t2."age" AS "age" FROM "Relationship" t1 LEFT JOIN "Person" t2 ON t2."id" = t1."child_id") t2 ON t1."id" = t2."id" GROUP BY t1."last_name", t2."first_name" ORDER BY t2."first_name")";
+
+  const std::string expected =
+      R"([{"last_name":"Simpson","first_name_child":"Bart","avg_parent_age_at_birth":32.5},{"last_name":"Simpson","first_name_child":"Lisa","avg_parent_age_at_birth":34.5},{"last_name":"Simpson","first_name_child":"Maggie","avg_parent_age_at_birth":42.5}])";
+  EXPECT_EQ(sqlite::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_joins_nested_grouped
diff --git a/tests/sqlite/test_joins_two_tables.cpp b/tests/sqlite/test_joins_two_tables.cpp
new file mode 100644
index 0000000..678a59c
--- /dev/null
+++ b/tests/sqlite/test_joins_two_tables.cpp
@@ -0,0 +1,76 @@
+#include <gtest/gtest.h>
+
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/sqlite.hpp>
+#include <vector>
+
+namespace test_joins_two_tables {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+struct Relationship {
+  uint32_t parent_id;
+  uint32_t child_id;
+};
+
+TEST(sqlite, test_joins_two_tables) {
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{
+           .id = 1, .first_name = "Marge", .last_name = "Simpson", .age = 40},
+       Person{.id = 2, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 3, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 4, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  const auto relationships =
+      std::vector<Relationship>({Relationship{.parent_id = 0, .child_id = 2},
+                                 Relationship{.parent_id = 0, .child_id = 3},
+                                 Relationship{.parent_id = 0, .child_id = 4},
+                                 Relationship{.parent_id = 1, .child_id = 2},
+                                 Relationship{.parent_id = 1, .child_id = 3},
+                                 Relationship{.parent_id = 1, .child_id = 4}});
+
+  using namespace sqlgen;
+
+  struct ParentAndChild {
+    std::string last_name;
+    std::string first_name_parent;
+    std::string first_name_child;
+    double parent_age_at_birth;
+  };
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "last_name"_t1 | as<"last_name">,
+          "first_name"_t1 | as<"first_name_parent">,
+          "first_name"_t3 | as<"first_name_child">,
+          ("age"_t1 - "age"_t3) | as<"parent_age_at_birth">) |
+      inner_join<Relationship, "t2">("id"_t1 == "parent_id"_t2) |
+      left_join<Person, "t3">("id"_t3 == "child_id"_t2) |
+      order_by("id"_t1, "id"_t3) | to<std::vector<ParentAndChild>>;
+
+  const auto people = sqlite::connect()
+                          .and_then(write(std::ref(people1)))
+                          .and_then(write(std::ref(relationships)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."last_name" AS "last_name", t1."first_name" AS "first_name_parent", t3."first_name" AS "first_name_child", (t1."age") - (t3."age") AS "parent_age_at_birth" FROM "Person" t1 INNER JOIN "Relationship" t2 ON t1."id" = t2."parent_id" LEFT JOIN "Person" t3 ON t3."id" = t2."child_id" ORDER BY t1."id", t3."id")";
+  const std::string expected =
+      R"([{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Bart","parent_age_at_birth":35.0},{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Lisa","parent_age_at_birth":37.0},{"last_name":"Simpson","first_name_parent":"Homer","first_name_child":"Maggie","parent_age_at_birth":45.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Bart","parent_age_at_birth":30.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Lisa","parent_age_at_birth":32.0},{"last_name":"Simpson","first_name_parent":"Marge","first_name_child":"Maggie","parent_age_at_birth":40.0}])";
+
+  EXPECT_EQ(sqlite::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_joins_two_tables
diff --git a/tests/sqlite/test_joins_two_tables_grouped.cpp b/tests/sqlite/test_joins_two_tables_grouped.cpp
new file mode 100644
index 0000000..2dd836b
--- /dev/null
+++ b/tests/sqlite/test_joins_two_tables_grouped.cpp
@@ -0,0 +1,77 @@
+#include <gtest/gtest.h>
+
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/sqlite.hpp>
+#include <vector>
+
+namespace test_joins_two_tables_grouped {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  double age;
+};
+
+struct Relationship {
+  uint32_t parent_id;
+  uint32_t child_id;
+};
+
+TEST(sqlite, test_joins_two_tables_grouped) {
+  const auto people1 = std::vector<Person>(
+      {Person{
+           .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+       Person{
+           .id = 1, .first_name = "Marge", .last_name = "Simpson", .age = 40},
+       Person{.id = 2, .first_name = "Bart", .last_name = "Simpson", .age = 10},
+       Person{.id = 3, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
+       Person{
+           .id = 4, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+
+  const auto relationships =
+      std::vector<Relationship>({Relationship{.parent_id = 0, .child_id = 2},
+                                 Relationship{.parent_id = 0, .child_id = 3},
+                                 Relationship{.parent_id = 0, .child_id = 4},
+                                 Relationship{.parent_id = 1, .child_id = 2},
+                                 Relationship{.parent_id = 1, .child_id = 3},
+                                 Relationship{.parent_id = 1, .child_id = 4}});
+
+  using namespace sqlgen;
+
+  struct ParentAndChild {
+    std::string last_name;
+    std::string first_name_child;
+    double avg_parent_age_at_birth;
+  };
+
+  const auto get_people =
+      select_from<Person, "t1">(
+          "last_name"_t1 | as<"last_name">,
+          "first_name"_t3 | as<"first_name_child">,
+          avg("age"_t1 - "age"_t3) | as<"avg_parent_age_at_birth">) |
+      inner_join<Relationship, "t2">("id"_t1 == "parent_id"_t2) |
+      left_join<Person, "t3">("id"_t3 == "child_id"_t2) |
+      group_by("last_name"_t1, "first_name"_t3) |
+      order_by("last_name"_t1, "first_name"_t3) |
+      to<std::vector<ParentAndChild>>;
+
+  const auto people = sqlite::connect()
+                          .and_then(write(std::ref(people1)))
+                          .and_then(write(std::ref(relationships)))
+                          .and_then(get_people)
+                          .value();
+
+  const std::string expected_query =
+      R"(SELECT t1."last_name" AS "last_name", t3."first_name" AS "first_name_child", AVG((t1."age") - (t3."age")) AS "avg_parent_age_at_birth" FROM "Person" t1 INNER JOIN "Relationship" t2 ON t1."id" = t2."parent_id" LEFT JOIN "Person" t3 ON t3."id" = t2."child_id" GROUP BY t1."last_name", t3."first_name" ORDER BY t1."last_name", t3."first_name")";
+
+  const std::string expected =
+      R"([{"last_name":"Simpson","first_name_child":"Bart","avg_parent_age_at_birth":32.5},{"last_name":"Simpson","first_name_child":"Lisa","avg_parent_age_at_birth":34.5},{"last_name":"Simpson","first_name_child":"Maggie","avg_parent_age_at_birth":42.5}])";
+
+  EXPECT_EQ(sqlite::to_sql(get_people), expected_query);
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_joins_two_tables_grouped
diff --git a/tests/sqlite/test_select_from_with_timestamps.cpp b/tests/sqlite/test_select_from_with_timestamps.cpp
index c1d92cb..76a3bcf 100644
--- a/tests/sqlite/test_select_from_with_timestamps.cpp
+++ b/tests/sqlite/test_select_from_with_timestamps.cpp
@@ -66,7 +66,7 @@ TEST(sqlite, test_range_select_from_with_timestamps) {
                              .value();
 
   const std::string expected_query =
-      R"(SELECT datetime("birthday", '+10 days') AS "birthday", cast((cast(cast(strftime('%Y', "birthday") as INT) as TEXT) || '-' || cast(cast(strftime('%m', "birthday") as INT) as TEXT) || '-' || cast(cast(strftime('%d', "birthday") as INT) as TEXT)) as TEXT) AS "birthday_recreated", julianday('2011-01-01') - julianday("birthday") AS "age_in_days", unixepoch(datetime("birthday", '+10 days'), 'subsec') AS "birthday_unixepoch", cast(strftime('%H', "birthday") as INT) AS "hour", cast(strftime('%M', "birthday") as INT) AS "minute", cast(strftime('%S', "birthday") as INT) AS "second", cast(strftime('%w', "birthday") as INT) AS "weekday" FROM "Person" ORDER BY "id";)";
+      R"(SELECT datetime("birthday", '+10 days') AS "birthday", cast((cast(cast(strftime('%Y', "birthday") as INT) as TEXT) || '-' || cast(cast(strftime('%m', "birthday") as INT) as TEXT) || '-' || cast(cast(strftime('%d', "birthday") as INT) as TEXT)) as TEXT) AS "birthday_recreated", julianday('2011-01-01') - julianday("birthday") AS "age_in_days", unixepoch(datetime("birthday", '+10 days'), 'subsec') AS "birthday_unixepoch", cast(strftime('%H', "birthday") as INT) AS "hour", cast(strftime('%M', "birthday") as INT) AS "minute", cast(strftime('%S', "birthday") as INT) AS "second", cast(strftime('%w', "birthday") as INT) AS "weekday" FROM "Person" ORDER BY "id")";
   const std::string expected =
       R"([{"birthday":"1970-01-11","birthday_recreated":"1970-01-01","birthday_unixepoch":864000,"age_in_days":14975.0,"hour":0,"minute":0,"second":0,"weekday":4},{"birthday":"2000-01-11","birthday_recreated":"2000-01-01","birthday_unixepoch":947548800,"age_in_days":4018.0,"hour":0,"minute":0,"second":0,"weekday":6},{"birthday":"2002-01-11","birthday_recreated":"2002-01-01","birthday_unixepoch":1010707200,"age_in_days":3287.0,"hour":0,"minute":0,"second":0,"weekday":2},{"birthday":"2010-01-11","birthday_recreated":"2010-01-01","birthday_unixepoch":1263168000,"age_in_days":365.0,"hour":0,"minute":0,"second":0,"weekday":5}])";
 
diff --git a/tests/sqlite/test_to_select_from.cpp b/tests/sqlite/test_to_select_from.cpp
index 598072e..389ad80 100644
--- a/tests/sqlite/test_to_select_from.cpp
+++ b/tests/sqlite/test_to_select_from.cpp
@@ -17,7 +17,7 @@ TEST(sqlite, test_to_select_from) {
       sqlgen::transpilation::read_to_select_from<TestTable>();
   const auto conn = sqlgen::sqlite::connect().value();
   const auto expected =
-      R"(SELECT "field1", "field2", "id", "nullable" FROM "TestTable";)";
+      R"(SELECT "field1", "field2", "id", "nullable" FROM "TestTable")";
 
   EXPECT_EQ(conn->to_sql(select_from_stmt), expected);
 }