Merge remote-tracking branch 'origin/main' into default-date-uuid-representations

Author: stephencelis

Package.resolved

@@ -143,14 +143,19 @@ generated when writing queries will correctly use `"is_completed"`.
 
 ### Custom data types
 
-There are many data types that do not have native support in SQLite. For these data types you must
-define a conformance to ``QueryBindable`` in order to translate values to a format that SQLite does
-understand. The library comes with conformances to aid in representing dates, UUIDs, and JSON, and
-you can define your own conformances for your own custom data types.
+StructuredQueries provides support for many basic Swift data types out of the box, like strings,
+integers, doubles, bytes, and booleans, but you may want to represent custom, domain specific types
+with your table's columns, instead. For these data types you must either define a conformance to
+``QueryBindable`` to translate values to a format that the library does understand, or provide a
+``QueryRepresentable`` type that wraps your domain type.
+
+The library comes with several `QueryRepresentable` conformances to aid in representing dates,
+UUIDs, and JSON, and you can define your own conformances for your own custom data types.
 
 #### Dates
 
-SQLite does not have a native date type, and instead has 3 different ways to represent dates:
+While some relational databases, like MySQL and Postgres, have native support for dates, SQLite
+does _not_. Instead, it has 3 different ways to represent dates:
 
   * Text column interpreted as ISO-8601-formatted string.
   * Int column interpreted as number of seconds since Unix epoch.
@@ -203,6 +208,14 @@ And StructuredQueries will take care of formatting the value for the database:
   }
 }
 
+When querying against a date column with a Swift date, you will need to explicitly bundle up the
+Swift date into the appropriate representation to use various query helpers. This can be done using
+the `#bind` macro:
+
+```swift
+Reminder.where { $0.created > #bind(startDate) }
+```
+
 #### UUID
 
 SQLite also does not have native support for UUIDs. If you try to use a UUID in your tables you
@@ -238,6 +251,14 @@ translate the UUID to text:
 }
 ```
 
+When querying against a UUID column with a Swift UUID, you will need to explicitly bundle up the
+Swift UUID into the appropriate representation to use various query helpers. This can be done using
+the `#bind` macro:
+
+```swift
+Reminder.where { $0.id != #bind(reminder.id) }
+```
+
 #### RawRepresentable
 
 Simple data types, in particular ones conforming to `RawRepresentable` whose `RawValue` is a string

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

@@ -721,7 +721,8 @@ The `limit(_:offset:)` function is used to change a query's `LIMIT` and `OFFSET`
   }
 }
 
-Multiple chained calls to `limit` will override the limit and offset to the last call:
+Multiple chained calls to `limit` will override the limit and offset to the last call, using the
+existing offset if none is provided:
 
 @Row {
   @Column {
@@ -755,6 +756,22 @@ Multiple chained calls to `limit` will override the limit and offset to the last
   }
 }
 
+@Row {
+  @Column {
+    ```swift
+    Reminder
+      .limit(10, offset: 10)
+      .limit(20, offset: 20)
+    ```
+  }
+  @Column {
+    ```sql
+    SELECT … FROM "reminders"
+    LIMIT 20 OFFSET 20
+    ```
+  }
+}
+
 ### Compound selects
 
 It is possible to combine multiple selects together using the `union`, `intersect`, and `except`

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

@@ -861,7 +861,7 @@ extension QueryExpression where QueryValue: QueryBindable {
     BinaryOperator(
       lhs: self,
       operator: "BETWEEN",
-      rhs: BinaryOperator<Void>(lhs: lowerBound, operator: "AND", rhs: upperBound)
+      rhs: SQLQueryExpression("\(lowerBound) AND \(upperBound)")
     )
   }
 }

Sources/StructuredQueriesCore/Operators.swift

@@ -1282,8 +1282,8 @@ extension Select {
   where Joins == (repeat each J) {
     var select = self
     select.limit = _LimitClause(
-      maxLength: maxLength(From.columns, repeat (each J).columns),
-      offset: offset?(From.columns, repeat (each J).columns)
+      maxLength: maxLength(From.columns, repeat (each J).columns).queryFragment,
+      offset: offset?(From.columns, repeat (each J).columns).queryFragment ?? select.limit?.offset
     )
     return select
   }
@@ -1297,7 +1297,10 @@ extension Select {
   public func limit<each J: Table>(_ maxLength: Int, offset: Int? = nil) -> Self
   where Joins == (repeat each J) {
     var select = self
-    select.limit = _LimitClause(maxLength: maxLength, offset: offset)
+    select.limit = _LimitClause(
+      maxLength: maxLength.queryFragment,
+      offset: offset?.queryFragment ?? select.limit?.offset
+    )
     return select
   }
 
@@ -1488,14 +1491,6 @@ public struct _LimitClause: QueryExpression {
   let maxLength: QueryFragment
   let offset: QueryFragment?
 
-  init(
-    maxLength: some QueryExpression,
-    offset: (some QueryExpression)? = Int?.none
-  ) {
-    self.maxLength = maxLength.queryFragment
-    self.offset = offset?.queryFragment
-  }
-
   public var queryFragment: QueryFragment {
     var query: QueryFragment = "LIMIT \(maxLength)"
     if let offset {

Sources/StructuredQueriesCore/Statements/Select.swift

@@ -34,7 +34,8 @@ extension TableMacro: ExtensionMacro {
     var diagnostics: [Diagnostic] = []
 
     // NB: A compiler bug prevents us from applying the '@_Draft' macro directly
-    var draftBindings: [(PatternBindingSyntax, queryOutputType: TypeSyntax?)] = []
+    var draftBindings: [(PatternBindingSyntax, queryOutputType: TypeSyntax?, optionalize: Bool)] =
+      []
     // NB: End of workaround
 
     var draftProperties: [DeclSyntax] = []
@@ -223,12 +224,8 @@ extension TableMacro: ExtensionMacro {
         )
       }
 
-      // NB: A compiled bug prevents us from applying the '@_Draft' macro directly
-      if identifier == primaryKey?.identifier {
-        draftBindings.append((binding.optionalized(), columnQueryOutputType))
-      } else {
-        draftBindings.append((binding, columnQueryOutputType))
-      }
+      // NB: A compiler bug prevents us from applying the '@_Draft' macro directly
+      draftBindings.append((binding, columnQueryOutputType, identifier == primaryKey?.identifier))
       // NB: End of workaround
 
       var assignedType: String? {
@@ -398,8 +395,12 @@ extension TableMacro: ExtensionMacro {
       .compactMap(\.memberBlock.members.trimmed)
       var memberwiseArguments: [PatternBindingSyntax] = []
       var memberwiseAssignments: [TokenSyntax] = []
-      for (binding, queryOutputType) in draftBindings {
-        let argument = binding.trimmed.annotated(queryOutputType).rewritten(selfRewriter)
+      for (binding, queryOutputType, optionalize) in draftBindings {
+        var argument = binding.trimmed
+        if optionalize {
+          argument = argument.optionalized()
+        }
+        argument = argument.annotated(queryOutputType).rewritten(selfRewriter)
         if argument.typeAnnotation == nil {
           let identifier =
             (argument.pattern.as(IdentifierPatternSyntax.self)?.identifier.trimmedDescription)

Sources/StructuredQueriesMacros/TableMacro.swift

@@ -146,42 +146,5 @@ extension SnapshotTests {
         """#
       }
     }
-
-    @Test func dateDiagnostic() {
-      assertMacro {
-        """
-        @Selection struct ReminderDate {
-          var date: Date
-        }
-        """
-      } expansion: {
-        #"""
-        struct ReminderDate {
-          var date: Date
-        }
-
-        extension ReminderDate: StructuredQueriesCore.QueryRepresentable {
-          public struct Columns: StructuredQueriesCore.QueryExpression {
-            public typealias QueryValue = ReminderDate
-            public let queryFragment: StructuredQueriesCore.QueryFragment
-            public init(
-              date: some StructuredQueriesCore.QueryExpression<Date>
-            ) {
-              self.queryFragment = """
-              \(date.queryFragment) AS "date"
-              """
-            }
-          }
-          public init(decoder: inout some StructuredQueriesCore.QueryDecoder) throws {
-            let date = try decoder.decode(Date.self)
-            guard let date else {
-              throw QueryDecodingError.missingRequiredColumn
-            }
-            self.date = date
-          }
-        }
-        """#
-      }
-    }
   }
 }

Tests/StructuredQueriesMacrosTests/SelectionMacroTests.swift

@@ -8,16 +8,16 @@ import Testing
 @Suite(
   .serialized,
   .macros(
-    record: .failed,
-    macros: [
+    [
       "_Draft": TableMacro.self,
       "bind": BindMacro.self,
       "Column": ColumnMacro.self,
       "Ephemeral": EphemeralMacro.self,
-      "Table": TableMacro.self,
       "Selection": SelectionMacro.self,
       "sql": SQLMacro.self,
-    ]
+      "Table": TableMacro.self,
+    ],
+    record: .failed
   )
 ) struct SnapshotTests {}