Merge branch 'main' into more-association-docs

Author: mbrandonw

Sources/StructuredQueriesCore/AggregateFunctions.swift

@@ -20,7 +20,12 @@ extension QueryExpression where QueryValue: QueryBindable {
     distinct isDistinct: Bool = false,
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<Int> {
-    AggregateFunction("count", isDistinct: isDistinct, self, filter: filter)
+    AggregateFunction(
+      "count",
+      isDistinct: isDistinct,
+      [queryFragment],
+      filter: filter?.queryFragment
+    )
   }
 }
 
@@ -46,11 +51,12 @@ where QueryValue: _OptionalPromotable, QueryValue._Optionalized.Wrapped == Strin
     order: (some QueryExpression)? = Bool?.none,
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<String?> {
-    if let separator {
-      return AggregateFunction("group_concat", self, separator, order: order, filter: filter)
-    } else {
-      return AggregateFunction("group_concat", self, order: order, filter: filter)
-    }
+    AggregateFunction(
+      "group_concat",
+      separator.map { [queryFragment, $0.queryFragment] } ?? [queryFragment],
+      order: order?.queryFragment,
+      filter: filter?.queryFragment
+    )
   }
 
   /// A string concatenation aggregate of this expression.
@@ -68,7 +74,13 @@ where QueryValue: _OptionalPromotable, QueryValue._Optionalized.Wrapped == Strin
     order: (some QueryExpression)? = Bool?.none,
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<String?> {
-    AggregateFunction("group_concat", isDistinct: isDistinct, self, order: order, filter: filter)
+    AggregateFunction(
+      "group_concat",
+      isDistinct: isDistinct,
+      [queryFragment],
+      order: order?.queryFragment,
+      filter: filter?.queryFragment
+    )
   }
 }
 
@@ -85,7 +97,7 @@ extension QueryExpression where QueryValue: QueryBindable {
   public func max(
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<Int?> {
-    AggregateFunction("max", self, filter: filter)
+    AggregateFunction("max", [queryFragment], filter: filter?.queryFragment)
   }
 
   /// A minimum aggregate of this expression.
@@ -100,7 +112,7 @@ extension QueryExpression where QueryValue: QueryBindable {
   public func min(
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<Int?> {
-    AggregateFunction("min", self, filter: filter)
+    AggregateFunction("min", [queryFragment], filter: filter?.queryFragment)
   }
 }
 
@@ -122,7 +134,7 @@ where QueryValue: _OptionalPromotable, QueryValue._Optionalized.Wrapped: Numeric
     distinct isDistinct: Bool = false,
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<Double?> {
-    AggregateFunction("avg", isDistinct: isDistinct, self, filter: filter)
+    AggregateFunction("avg", isDistinct: isDistinct, [queryFragment], filter: filter?.queryFragment)
   }
 
   /// An sum aggregate of this expression.
@@ -145,7 +157,10 @@ where QueryValue: _OptionalPromotable, QueryValue._Optionalized.Wrapped: Numeric
     // TODO: Report issue to Swift team.
     SQLQueryExpression(
       AggregateFunction<QueryValue._Optionalized>(
-        "sum", isDistinct: isDistinct, self, filter: filter
+        "sum",
+        isDistinct: isDistinct,
+        [queryFragment],
+        filter: filter?.queryFragment
       )
       .queryFragment
     )
@@ -167,7 +182,12 @@ where QueryValue: _OptionalPromotable, QueryValue._Optionalized.Wrapped: Numeric
     distinct isDistinct: Bool = false,
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<QueryValue> {
-    AggregateFunction("total", isDistinct: isDistinct, self, filter: filter)
+    AggregateFunction(
+      "total",
+      isDistinct: isDistinct,
+      [queryFragment],
+      filter: filter?.queryFragment
+    )
   }
 }
 
@@ -182,9 +202,9 @@ extension QueryExpression where Self == AggregateFunction<Int> {
   /// - Parameter filter: A `FILTER` clause to apply to the aggregation.
   /// - Returns: A `count(*)` aggregate.
   public static func count(
-    filter: (some QueryExpression<Bool>)? = Bool?.none
+    filter: (any QueryExpression<Bool>)? = nil
   ) -> Self {
-    AggregateFunction("count", SQLQueryExpression("*"), filter: filter)
+    AggregateFunction("count", ["*"], filter: filter?.queryFragment)
   }
 }
 
@@ -196,18 +216,18 @@ public struct AggregateFunction<QueryValue>: QueryExpression {
   var order: QueryFragment?
   var filter: QueryFragment?
 
-  init<each Argument: QueryExpression>(
+  init(
     _ name: QueryFragment,
     isDistinct: Bool = false,
-    _ arguments: repeat each Argument,
-    order: (some QueryExpression)? = Bool?.none,
-    filter: (some QueryExpression)? = Bool?.none
+    _ arguments: [QueryFragment] = [],
+    order: QueryFragment? = nil,
+    filter: QueryFragment? = nil
   ) {
     self.name = name
     self.isDistinct = isDistinct
-    self.arguments = Array(repeat each arguments)
-    self.order = order?.queryFragment
-    self.filter = filter?.queryFragment
+    self.arguments = arguments
+    self.order = order
+    self.filter = filter
   }
 
   public var queryFragment: QueryFragment {

Sources/StructuredQueriesCore/Documentation.docc/Articles/DefiningYourSchema.md

@@ -21,6 +21,7 @@ that represent those database definitions.
   * [Custom data types](#Custom-data-types)
     * [RawRepresentable](#RawRepresentable)
     * [JSON](#JSON)
+    * [Tagged identifiers](#Tagged-identifiers)
     * [Default representations for dates and UUIDs](#Default-representations-for-dates-and-UUIDs)
 * [Primary keyed tables](#Primary-keyed-tables)
 * [Ephemeral columns](#Ephemeral-columns)
@@ -298,10 +299,11 @@ This adds a new layer of type-safety when constructing queries. Previously compa
 `RemindersList.ID` to a `Reminder.ID` would compile just fine, even though it is a nonsensical thing
 to do. But now, such a comparison is a compile time error:
 
-```
+```swift
 RemindersList.leftJoin(Reminder.all) {
   $0.id == $1.id  // 🛑 Requires the types 'Reminder.ID' and 'RemindersList.ID' be equivalent
 }
+```
 
 #### Default representations for dates and UUIDs
 

Sources/StructuredQueriesCore/Operators.swift

@@ -187,6 +187,7 @@ public func != <QueryValue>(
 
 // NB: This overload is required due to an overload resolution bug of 'Updates[dynamicMember:]'.
 @_documentation(visibility: private)
+@_disfavoredOverload
 public func == <QueryValue: _OptionalProtocol>(
   lhs: any QueryExpression<QueryValue>,
   rhs: some QueryExpression<QueryValue.Wrapped>
@@ -196,6 +197,7 @@ public func == <QueryValue: _OptionalProtocol>(
 
 // NB: This overload is required due to an overload resolution bug of 'Updates[dynamicMember:]'.
 @_documentation(visibility: private)
+@_disfavoredOverload
 public func != <QueryValue: _OptionalProtocol>(
   lhs: any QueryExpression<QueryValue>,
   rhs: some QueryExpression<QueryValue.Wrapped>

Sources/StructuredQueriesCore/Optional.swift

@@ -1,6 +1,8 @@
 public protocol _OptionalProtocol<Wrapped> {
   associatedtype Wrapped
   var _wrapped: Wrapped? { get }
+  static var none: Self { get }
+  static func some(_ wrapped: Wrapped) -> Self
 }
 
 extension Optional: _OptionalProtocol {

Sources/StructuredQueriesCore/SQLite/JSONFunctions.swift

@@ -37,7 +37,12 @@ extension QueryExpression where QueryValue: Codable & QueryBindable & Sendable {
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<[QueryValue].JSONRepresentation> {
     AggregateFunction(
-      "json_group_array", isDistinct: isDistinct, self, order: order, filter: filter)
+      "json_group_array",
+      isDistinct: isDistinct,
+      [queryFragment],
+      order: order?.queryFragment,
+      filter: filter?.queryFragment
+    )
   }
 }
 
@@ -98,7 +103,12 @@ extension PrimaryKeyedTableDefinition where QueryValue: Codable & Sendable {
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<[QueryValue].JSONRepresentation> {
     AggregateFunction(
-      "json_group_array", isDistinct: isDistinct, jsonObject, order: order, filter: filter)
+      "json_group_array",
+      isDistinct: isDistinct,
+      [jsonObject.queryFragment],
+      order: order?.queryFragment,
+      filter: filter?.queryFragment
+    )
   }
 
   private var jsonObject: some QueryExpression<QueryValue> {

Sources/StructuredQueriesCore/Statements/Select.swift

@@ -295,7 +295,7 @@ extension Table {
   /// - Parameter filter: A `FILTER` clause to apply to the aggregation.
   /// - Returns: A select statement that selects `count(*)`.
   public static func count(
-    filter: (some QueryExpression<Bool>)? = Bool?.none
+    filter: ((TableColumns) -> any QueryExpression<Bool>)? = nil
   ) -> Select<Int, Self, ()> {
     Where().count(filter: filter)
   }
@@ -444,6 +444,18 @@ extension Select {
     _select(selection)
   }
 
+  /// Creates a new select statement from this one by selecting the given result column.
+  ///
+  /// - Parameter selection: A closure that selects a result column from this select's tables.
+  /// - Returns: A new select statement that selects the given column.
+  @_disfavoredOverload
+  public func select<C: QueryExpression, each J: Table>(
+    _ selection: (From.TableColumns, repeat (each J).TableColumns) -> C
+  ) -> Select<C.QueryValue, From, (repeat each J)>
+  where Columns == (), C.QueryValue: QueryRepresentable, Joins == (repeat each J) {
+    _select(selection)
+  }
+
   /// Creates a new select statement from this one by appending the given result column to its
   /// selection.
   ///
@@ -1309,23 +1321,25 @@ extension Select {
   /// - Parameter filter: A `FILTER` clause to apply to the aggregation.
   /// - Returns: A new select statement that selects `count(*)`.
   public func count<each J: Table>(
-    filter: (some QueryExpression<Bool>)? = Bool?.none
+    filter: ((From.TableColumns, repeat (each J).TableColumns) -> any QueryExpression<Bool>)? = nil
   ) -> Select<Int, From, (repeat each J)>
   where Columns == (), Joins == (repeat each J) {
-    select { _ in .count(filter: filter) }
+    let filter = filter?(From.columns, repeat (each J).columns)
+    return select { _ in .count(filter: filter) }
   }
 
   /// Creates a new select statement from this one by appending `count(*)` to its selection.
   ///
   /// - Parameter filter: A `FILTER` clause to apply to the aggregation.
   /// - Returns: A new select statement that selects `count(*)`.
   public func count<each C: QueryRepresentable, each J: Table>(
-    filter: (some QueryExpression<Bool>)? = Bool?.none
+    filter: ((From.TableColumns, repeat (each J).TableColumns) -> any QueryExpression<Bool>)? = nil
   ) -> Select<
     (repeat each C, Int), From, (repeat each J)
   >
   where Columns == (repeat each C), Joins == (repeat each J) {
-    select { _ in .count(filter: filter) }
+    let filter = filter?(From.columns, repeat (each J).columns)
+    return select { _ in .count(filter: filter) }
   }
 
   /// Creates a new select statement from this one by transforming its selected columns to a new

Sources/StructuredQueriesCore/Statements/Where.swift

@@ -462,7 +462,7 @@ extension Where: SelectStatement {
   /// - Parameter filter: A `FILTER` clause to apply to the aggregation.
   /// - Returns: A select statement that selects `count(*)`.
   public func count(
-    filter: (some QueryExpression<Bool>)? = Bool?.none
+    filter: ((From.TableColumns) -> any QueryExpression<Bool>)? = nil
   ) -> Select<Int, From, ()> {
     asSelect().count(filter: filter)
   }

Tests/StructuredQueriesTests/CompileTimeTests.swift

@@ -0,0 +1,21 @@
+import StructuredQueries
+
+// NB: This is a compile-time test for a 'select' overload.
+@Selection
+private struct ReminderRow {
+  let reminder: Reminder
+  let isPastDue: Bool
+  @Column(as: [String].JSONRepresentation.self)
+  let tags: [String]
+}
+private var remindersQuery: some Statement<ReminderRow> {
+  Reminder
+    .limit(1)
+    .select {
+      ReminderRow.Columns(
+        reminder: $0,
+        isPastDue: true,
+        tags: #sql("[]")
+      )
+    }
+}

Tests/StructuredQueriesTests/SelectTests.swift

@@ -16,6 +16,11 @@ extension SnapshotTests {
       _ = Reminder.where(\.isCompleted).select(\.id)
       _ = Reminder.where(\.isCompleted).select { $0.id }
       _ = Reminder.where(\.isCompleted).select { ($0.id, $0.isCompleted) }
+
+      let condition1 = Int?.some(1) == 2
+      #expect(condition1 == false)
+      let condition2 = Int?.some(1) != 2
+      #expect(condition2 == true)
     }
 
     @Test func selectAll() {
@@ -852,6 +857,21 @@ extension SnapshotTests {
       }
     }
 
+    @Test func countFilter() {
+      assertQuery(Reminder.count { !$0.isCompleted }) {
+        """
+        SELECT count(*) FILTER (WHERE NOT ("reminders"."isCompleted"))
+        FROM "reminders"
+        """
+      } results: {
+        """
+        ┌───┐
+        │ 7 │
+        └───┘
+        """
+      }
+    }
+
     @Test func map() {
       assertQuery(Reminder.limit(1).select { ($0.id, $0.title) }.map { ($1, $0) }) {
         """