Merge branch 'main' into query-fragment-segments

Author: stephencelis

.github/workflows/ci.yml

@@ -34,6 +34,7 @@ jobs:
     strategy:
       matrix:
         swift:
+          - '6.0'
           - '6.1'
     runs-on: ubuntu-latest
     container: swift:${{ matrix.swift }}

Sources/StructuredQueries/Macros.swift

@@ -132,3 +132,10 @@ public macro sql<QueryValue>(
   as queryValueType: QueryValue.Type = QueryValue.self
 ) -> SQLQueryExpression<QueryValue> =
   #externalMacro(module: "StructuredQueriesMacros", type: "SQLMacro")
+
+@freestanding(expression)
+public macro sql(
+  _ queryFragment: QueryFragment,
+  as queryValueType: Any.Type = Any.self
+) -> SQLQueryExpression<Any> =
+  #externalMacro(module: "StructuredQueriesMacros", type: "SQLMacro")

Sources/StructuredQueriesCore/Documentation.docc/Extensions/QueryExpression.md

@@ -28,3 +28,8 @@
 
 - ``jsonArrayLength()``
 - ``jsonGroupArray(order:filter:)``
+
+### Optionality
+
+- ``map(_:)``
+- ``flatMap(_:)``

Sources/StructuredQueriesCore/Internal/Deprecations.swift

@@ -89,7 +89,7 @@ extension Table {
     or conflictResolution: ConflictResolution? = nil,
     _ columns: (TableColumns) -> (TableColumn<Self, V1>, repeat TableColumn<Self, each V2>),
     select selection: () -> Select<(C1, repeat each C2), From, Joins>,
-    onConflict updates: ((inout Updates<Self>) -> Void)?,
+    onConflict updates: ((inout Updates<Self>) -> Void)?
   ) -> InsertOf<Self>
   where C1.QueryValue == V1, (repeat (each C2).QueryValue) == (repeat each V2) {
     insert(or: conflictResolution, columns, select: selection, onConflictDoUpdate: updates)

Sources/StructuredQueriesCore/Optional.swift

@@ -137,3 +137,43 @@ where Wrapped.TableColumns: PrimaryKeyedTableDefinition {
     self[dynamicMember: \.primaryKey]
   }
 }
+
+extension QueryExpression where QueryValue: _OptionalProtocol {
+  /// Creates and optionalizes a new expression from this one by applying an unwrapped version of
+  /// this expression to a given closure.
+  ///
+  /// ```swift
+  /// Reminder.where {
+  ///   $0.dueDate.map { $0 > Date() }
+  /// }
+  /// // SELECT … FROM "reminders"
+  /// // WHERE "reminders"."dueDate" > '2018-01-29 00:08:00.000'
+  /// ```
+  ///
+  /// - Parameter transform: A closure that takes an unwrapped version of this expression.
+  /// - Returns: The result of the transform function, optionalized.
+  public func map<T>(
+    _ transform: (SQLQueryExpression<QueryValue.Wrapped>) -> some QueryExpression<T>
+  ) -> some QueryExpression<T?> {
+    SQLQueryExpression(transform(SQLQueryExpression(queryFragment)).queryFragment)
+  }
+
+  /// Creates a new optional expression from this one by applying an unwrapped version of this
+  /// expression to a given closure.
+  ///
+  /// ```swift
+  /// Reminder.select {
+  ///   $0.dueDate.flatMap { $0.max() }
+  /// }
+  /// // SELECT max("reminders"."dueDate") FROM "reminders"
+  /// // => [Date?]
+  /// ```
+  ///
+  /// - Parameter transform: A closure that takes an unwrapped version of this expression.
+  /// - Returns: The result of the transform function.
+  public func flatMap<T>(
+    _ transform: (SQLQueryExpression<QueryValue.Wrapped>) -> some QueryExpression<T?>
+  ) -> some QueryExpression<T?> {
+    SQLQueryExpression(transform(SQLQueryExpression(queryFragment)).queryFragment)
+  }
+}

Sources/StructuredQueriesCore/Statements/Select.swift

@@ -212,7 +212,7 @@ extension Table {
   /// - Returns: A select statement that groups by the given column.
   public static func group<C: QueryExpression>(
     by grouping: (TableColumns) -> C
-  ) -> SelectOf<Self> where C.QueryValue: QueryDecodable {
+  ) -> SelectOf<Self> {
     Where().group(by: grouping)
   }
 
@@ -226,12 +226,7 @@ extension Table {
     each C3: QueryExpression
   >(
     by grouping: (TableColumns) -> (C1, C2, repeat each C3)
-  ) -> SelectOf<Self>
-  where
-    C1.QueryValue: QueryDecodable,
-    C2.QueryValue: QueryDecodable,
-    repeat (each C3).QueryValue: QueryDecodable
-  {
+  ) -> SelectOf<Self> {
     Where().group(by: grouping)
   }
 
@@ -1182,8 +1177,7 @@ extension Select {
   /// - Returns: A new select statement that groups by the given column.
   public func group<C: QueryExpression, each J: Table>(
     by grouping: (From.TableColumns, repeat (each J).TableColumns) -> C
-  ) -> Self
-  where C.QueryValue: QueryDecodable, Joins == (repeat each J) {
+  ) -> Self where Joins == (repeat each J) {
     _group(by: grouping)
   }
 
@@ -1199,13 +1193,7 @@ extension Select {
     each J: Table
   >(
     by grouping: (From.TableColumns, repeat (each J).TableColumns) -> (C1, C2, repeat each C3)
-  ) -> Self
-  where
-    C1.QueryValue: QueryDecodable,
-    C2.QueryValue: QueryDecodable,
-    repeat (each C3).QueryValue: QueryDecodable,
-    Joins == (repeat each J)
-  {
+  ) -> Self where Joins == (repeat each J) {
     _group(by: grouping)
   }
 
@@ -1214,11 +1202,7 @@ extension Select {
     each J: Table
   >(
     by grouping: (From.TableColumns, repeat (each J).TableColumns) -> (repeat each C)
-  ) -> Self
-  where
-    repeat (each C).QueryValue: QueryDecodable,
-    Joins == (repeat each J)
-  {
+  ) -> Self where Joins == (repeat each J) {
     var select = self
     select.group
       .append(

Sources/StructuredQueriesCore/Statements/Where.swift

@@ -387,22 +387,16 @@ extension Where: SelectStatement {
   }
 
   /// A select statement for the filtered table grouped by the given column.
-  public func group<C: QueryExpression>(by grouping: (From.TableColumns) -> C) -> Select<
-    (), From, ()
-  >
-  where C.QueryValue: QueryDecodable {
+  public func group<C: QueryExpression>(
+    by grouping: (From.TableColumns) -> C
+  ) -> Select<(), From, ()> {
     asSelect().group(by: grouping)
   }
 
   /// A select statement for the filtered table grouped by the given columns.
   public func group<C1: QueryExpression, C2: QueryExpression, each C3: QueryExpression>(
     by grouping: (From.TableColumns) -> (C1, C2, repeat each C3)
-  ) -> SelectOf<From>
-  where
-    C1.QueryValue: QueryDecodable,
-    C2.QueryValue: QueryDecodable,
-    repeat (each C3).QueryValue: QueryDecodable
-  {
+  ) -> SelectOf<From> {
     asSelect().group(by: grouping)
   }
 

Tests/StructuredQueriesTests/SelectTests.swift

@@ -644,6 +644,23 @@ extension SnapshotTests {
         └───────┴───┘
         """
       }
+
+      assertQuery(
+        Reminder.select { ($0.isCompleted, $0.id.count()) }.group { #sql("\($0.isCompleted)") }
+      ) {
+        """
+        SELECT "reminders"."isCompleted", count("reminders"."id")
+        FROM "reminders"
+        GROUP BY "reminders"."isCompleted"
+        """
+      } results: {
+        """
+        ┌───────┬───┐
+        │ false │ 7 │
+        │ true  │ 3 │
+        └───────┴───┘
+        """
+      }
     }
 
     @Test func having() {
@@ -1153,6 +1170,50 @@ extension SnapshotTests {
         """
       }
     }
+
+    @Test func optionalMapAndFlatMap() {
+      do {
+        let query: some Statement<Bool?> = Reminder.select {
+          $0.priority.map { $0 < Priority.high }
+        }
+        assertQuery(query) {
+          """
+          SELECT ("reminders"."priority" < 3)
+          FROM "reminders"
+          """
+        } results: {
+          """
+          ┌───────┐
+          │ nil   │
+          │ nil   │
+          │ false │
+          │ nil   │
+          │ nil   │
+          │ false │
+          │ true  │
+          │ false │
+          │ nil   │
+          │ true  │
+          └───────┘
+          """
+        }
+      }
+      do {
+        let query: some Statement<Int?> = Reminder.select { $0.priority.flatMap { $0.max() } }
+        assertQuery(query) {
+          """
+          SELECT max("reminders"."priority")
+          FROM "reminders"
+          """
+        } results: {
+          """
+          ┌───┐
+          │ 3 │
+          └───┘
+          """
+        }
+      }
+    }
   }
 }