Add join overloads for Joins: Table (pointfreeco#136)

* Add join overloads for `Joins: Table`

Parameter packs break down when a pack generic is a single value
(instead of a tuple) and has a conformance constraint. These overloads
are to work around it.

Before 1.0 we should probably come up with a reasonable limitation of
how joins work. Some ideas to reduce the overloads:

  - Joins require no selected columns on either side. While it'd be nice
    to splat them, it just doesn't work well with parameter packs today.

  - Joins require no joined tables on the righthand side. Again: it'd be
    nice to support this, but it doesn't work well in the language
    today.

This maybe even means joins take `Table.Type` instead of `Select<Table>`.

I think if these two limitations were known and documented we could
eliminate the many of the overloads we've defined today.

* wip

* fix

Author: stephencelis

Sources/StructuredQueriesCore/Statements/Select.swift

@@ -710,6 +710,36 @@ extension Select {
     )
   }
 
+  @_disfavoredOverload
+  @_documentation(visibility: private)
+  public func join<F: Table>(
+    // TODO: Report issue to Swift team. Using 'some' crashes the compiler.
+    _ other: any SelectStatementOf<F>,
+    on constraint: (
+      (From.TableColumns, Joins.TableColumns, F.TableColumns)
+    ) -> some QueryExpression<Bool>
+  ) -> Select<(), From, (Joins, F)> where Joins: Table {
+    let other = other.asSelect()
+    let join = _JoinClause(
+      operator: .inner,
+      table: F.self,
+      constraint: constraint(
+        (From.columns, Joins.columns, F.columns)
+      )
+    )
+    return Select<(), From, (Joins, F)>(
+      isEmpty: isEmpty || other.isEmpty,
+      distinct: distinct || other.distinct,
+      columns: columns + other.columns,
+      joins: joins + [join] + other.joins,
+      where: `where` + other.where,
+      group: group + other.group,
+      having: having + other.having,
+      order: order + other.order,
+      limit: other.limit ?? limit
+    )
+  }
+
   /// Creates a new select statement from this one by left-joining another table.
   ///
   /// - Parameters:
@@ -849,6 +879,37 @@ extension Select {
     )
   }
 
+  @_disfavoredOverload
+  @_documentation(visibility: private)
+  public func leftJoin<F: Table>(
+    // TODO: Report issue to Swift team. Using 'some' crashes the compiler.
+    _ other: any SelectStatementOf<F>,
+    on constraint: (
+      (From.TableColumns, Joins.TableColumns, F.TableColumns)
+    ) -> some QueryExpression<Bool>
+  ) -> Select<(), From, (Joins, F._Optionalized)>
+  where Joins: Table {
+    let other = other.asSelect()
+    let join = _JoinClause(
+      operator: .left,
+      table: F.self,
+      constraint: constraint(
+        (From.columns, Joins.columns, F.columns)
+      )
+    )
+    return Select<(), From, (Joins, F._Optionalized)>(
+      isEmpty: isEmpty || other.isEmpty,
+      distinct: distinct || other.distinct,
+      columns: columns + other.columns,
+      joins: joins + [join] + other.joins,
+      where: `where` + other.where,
+      group: group + other.group,
+      having: having + other.having,
+      order: order + other.order,
+      limit: other.limit ?? limit
+    )
+  }
+
   /// Creates a new select statement from this one by right-joining another table.
   ///
   /// - Parameters:
@@ -988,6 +1049,37 @@ extension Select {
     )
   }
 
+  @_disfavoredOverload
+  @_documentation(visibility: private)
+  public func rightJoin<F: Table>(
+    // TODO: Report issue to Swift team. Using 'some' crashes the compiler.
+    _ other: any SelectStatementOf<F>,
+    on constraint: (
+      (From.TableColumns, Joins.TableColumns, F.TableColumns)
+    ) -> some QueryExpression<Bool>
+  ) -> Select<(), From._Optionalized, (Joins._Optionalized, F)>
+  where Joins: Table {
+    let other = other.asSelect()
+    let join = _JoinClause(
+      operator: .right,
+      table: F.self,
+      constraint: constraint(
+        (From.columns, Joins.columns, F.columns)
+      )
+    )
+    return Select<(), From._Optionalized, (Joins._Optionalized, F)>(
+      isEmpty: isEmpty || other.isEmpty,
+      distinct: distinct || other.distinct,
+      columns: columns + other.columns,
+      joins: joins + [join] + other.joins,
+      where: `where` + other.where,
+      group: group + other.group,
+      having: having + other.having,
+      order: order + other.order,
+      limit: other.limit ?? limit
+    )
+  }
+
   /// Creates a new select statement from this one by full-joining another table.
   ///
   /// - Parameters:
@@ -1127,6 +1219,37 @@ extension Select {
     )
   }
 
+  @_disfavoredOverload
+  @_documentation(visibility: private)
+  public func fullJoin<F: Table>(
+    // TODO: Report issue to Swift team. Using 'some' crashes the compiler.
+    _ other: any SelectStatementOf<F>,
+    on constraint: (
+      (From.TableColumns, Joins.TableColumns, F.TableColumns)
+    ) -> some QueryExpression<Bool>
+  ) -> Select<(), From._Optionalized, (Joins._Optionalized, F._Optionalized)>
+  where Joins: Table {
+    let other = other.asSelect()
+    let join = _JoinClause(
+      operator: .full,
+      table: F.self,
+      constraint: constraint(
+        (From.columns, Joins.columns, F.columns)
+      )
+    )
+    return Select<(), From._Optionalized, (Joins._Optionalized, F._Optionalized)>(
+      isEmpty: isEmpty || other.isEmpty,
+      distinct: distinct || other.distinct,
+      columns: columns + other.columns,
+      joins: joins + [join] + other.joins,
+      where: `where` + other.where,
+      group: group + other.group,
+      having: having + other.having,
+      order: order + other.order,
+      limit: other.limit ?? limit
+    )
+  }
+
   /// Creates a new select statement from this one by appending a predicate to its `WHERE` clause.
   ///
   /// - Parameter keyPath: A key path from this select's table to a Boolean expression to filter by.

Tests/StructuredQueriesTests/SelectTests.swift

@@ -1406,6 +1406,22 @@ extension SnapshotTests {
     @Test func singleJoinChaining() {
       let base = Reminder.group(by: \.id).join(ReminderTag.all) { $0.id.eq($1.reminderID) }
       _ = base.select { r, _ in r.isCompleted }
+      _ = base.join(RemindersList.all) { _, _, _ in true }
+      _ = base.leftJoin(RemindersList.all) { _, _, _ in true }
+      _ = base.rightJoin(RemindersList.all) { _, _, _ in true }
+      _ = base.fullJoin(RemindersList.all) { _, _, _ in true }
+      _ = base
+        .join(RemindersList.all) { _, _, _ in true }
+        .join(RemindersList.all) { _, _, _, _ in true }
+      _ = base
+        .leftJoin(RemindersList.all) { _, _, _ in true }
+        .leftJoin(RemindersList.all) { _, _, _, _ in true }
+      _ = base
+        .rightJoin(RemindersList.all) { _, _, _ in true }
+        .rightJoin(RemindersList.all) { _, _, _, _ in true }
+      _ = base
+        .fullJoin(RemindersList.all) { _, _, _ in true }
+        .fullJoin(RemindersList.all) { _, _, _, _ in true }
       _ = base.where { r, _ in r.isCompleted }
       _ = base.group { r, _ in r.isCompleted }
       _ = base.having { r, _ in r.isCompleted }