Merge branch 'main' into optional-helpers

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 }}

.gitignore

@@ -7,4 +7,4 @@ DerivedData/
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 .netrc
 Package.resolved
-db.sqlite
+*.sqlite

Sources/StructuredQueries/Macros.swift

@@ -9,22 +9,19 @@ import StructuredQueriesCore
   conformances: Table,
   PartialSelectStatement,
   PrimaryKeyedTable,
-  names: named(TableColumns),
-  named(From),
-  named(Draft),
+  names: named(From),
   named(columns),
   named(init(_:)),
   named(init(decoder:)),
   named(QueryValue),
   named(schemaName),
   named(tableName)
 )
-@attached(
-  memberAttribute
-)
+@attached(member, names: named(Draft), named(TableColumns))
+@attached(memberAttribute)
 public macro Table(
-  _ name: String? = nil,
-  schema schemaName: String? = nil
+  _ name: String = "",
+  schema schemaName: String = ""
 ) =
   #externalMacro(
     module: "StructuredQueriesMacros",
@@ -38,9 +35,9 @@ public macro Table(
 ///   - representableType: A type that represents the property type in a query expression. For types
 ///     that don't have a single representation in SQL, like `Date` and `UUID`.
 ///   - primaryKey: The column is its table's auto-incrementing primary key.
-@attached(accessor, names: named(willSet))
+@attached(peer)
 public macro Column(
-  _ name: String? = nil,
+  _ name: String = "",
   as representableType: (any QueryRepresentable.Type)? = nil,
   primaryKey: Bool = false
 ) =
@@ -52,7 +49,7 @@ public macro Column(
 /// Tells Structured Queries not to consider the annotated property a column of the table
 ///
 /// Like SwiftData's `@Transient` macro, but for SQL.
-@attached(accessor, names: named(willSet))
+@attached(peer)
 public macro Ephemeral() =
   #externalMacro(
     module: "StructuredQueriesMacros",
@@ -95,6 +92,7 @@ public macro Ephemeral() =
   names: named(Columns),
   named(init(decoder:))
 )
+@attached(member, names: named(Columns))
 public macro Selection() =
   #externalMacro(
     module: "StructuredQueriesMacros",
@@ -135,21 +133,9 @@ public macro sql<QueryValue>(
 ) -> SQLQueryExpression<QueryValue> =
   #externalMacro(module: "StructuredQueriesMacros", type: "SQLMacro")
 
-// NB: Due to a bug in Swift, this macro is expanded internally by the '@Table' macro.
-// @attached(
-//   memberAttribute
-// )
-// @attached(
-//   extension,
-//   conformances: Table,
-//   names: named(TableColumns),
-//   named(columns),
-//   named(init(_:)),
-//   named(init(decoder:)),
-//   named(tableName)
-// )
-// public macro _Draft<T: Table>(_: T.Type) =
-//   #externalMacro(
-//     module: "StructuredQueriesMacros",
-//     type: "TableMacro"
-//   )
+@freestanding(expression)
+public macro sql(
+  _ queryFragment: QueryFragment,
+  as queryValueType: Any.Type = Any.self
+) -> SQLQueryExpression<Any> =
+  #externalMacro(module: "StructuredQueriesMacros", type: "SQLMacro")

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 & _OptionalPromotable
   public func max(
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<QueryValue._Optionalized.Wrapped?> {
-    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 & _OptionalPromotable
   public func min(
     filter: (some QueryExpression<Bool>)? = Bool?.none
   ) -> some QueryExpression<QueryValue._Optionalized.Wrapped?> {
-    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)
@@ -188,12 +189,12 @@ and will decode data from the database using the `RawRepresentable` conformance
 @Row {
   @Column {
     ```swift
-    Reminder.insert(
+    Reminder.insert {
       Reminder.Draft(
         title: "Get haircut",
         priority: .medium
       )
-    )
+    }
     ```
   }
   @Column {
@@ -239,12 +240,12 @@ With that you can insert reminders with notes like so:
 @Row {
   @Column {
     ```swift
-    Reminder.insert(
+    Reminder.insert {
       Reminder.Draft(
         title: "Get groceries",
         notes: ["Milk", "Eggs", "Bananas"]
       )
-    )
+    }
     ```
   }
   @Column {
@@ -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
 
@@ -340,9 +342,9 @@ And StructuredQueries will take care of formatting the value for the database:
 @Row {
   @Column {
     ```swift
-    Reminder.insert(
+    Reminder.insert {
       Reminder.Draft(date: Date())
-    )
+    }
     ```
   }
   @Column {

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

@@ -305,7 +305,7 @@ capable of. See <doc:SelectStatements> for more examples of select statements, a
 The library provides the tools necessary to construct type-safe insert statements in SQL, including
 inserting an entire value into a table, inserting only a subset of rows, as well as what to do on
 conflicts. Using the `Reminder` data type from above, we can insert data for all of its rows using
-the  ``Table/insert(or:_:values:onConflict:)`` method:
+the  ``Table/insert(or:_:values:onConflict:where:doUpdate:where:)`` method:
 
 @Row {
   @Column {
@@ -338,10 +338,11 @@ mechanism). The second trailing closure is a list of values that you want to ins
 and the number of columns and data type of each column must match what is specified in the first
 trailing closure.
 
-You can provide a 3rd trailing closure to ``Table/insert(or:_:values:onConflict:)`` to describe what
-to do in case there is a conflict while inserting data. For example, suppose we had a unique index
-on the "title" column of the reminders table. Then when inserting a value with a repeated title we
-could resolve the conflict by appending the string `" (Copy)"` to the title:
+You can provide a 3rd trailing closure to
+``Table/insert(or:_:values:onConflict:where:doUpdate:where:)`` to describe what to do in case there
+is a conflict while inserting data. For example, suppose we had a unique index on the "title" column
+of the reminders table. Then when inserting a value with a repeated title we could resolve the
+conflict by appending the string `" (Copy)"` to the title:
 
 @Row {
   @Column {