Merge pull request #1759 from groue/dev/expression-builder

Build request with closures

Author: groue

Documentation/AssociationsBasics.md

@@ -332,7 +332,7 @@ let hallOfFamePublisher = ValueObservation
 
         // 2nd request
         let bestPlayers = try Player
-            .order(Column("score").desc)
+            .order(\.score.desc)
             .limit(10)
             .fetchAll(db)
 
@@ -358,7 +358,7 @@ let totalPlayerCountPublisher = ValueObservation
 // OK
 let bestPlayerPublisher = ValueObservation
     .tracking(Player
-              .order(Column("score").desc)
+              .order(\.score.desc)
               .limit(10)
               .fetchAll)
     .publisher(in: dbQueue)

Documentation/Combine.md

@@ -31,7 +31,7 @@ The CTE request can be provided as a [query interface request]:
 // WITH playerName AS (SELECT name FROM player) ...
 let playerNameCTE = CommonTableExpression(
     named: "playerName", 
-    request: Player.select(Column("name")))
+    request: Player.select(\.name))
 ```
 
 You can feed a CTE with raw SQL as well (second and third examples use [SQL Interpolation]):
@@ -123,7 +123,7 @@ And we can then filter the `player` table with a subquery:
 // WHERE name = (SELECT * FROM playerName)
 let request = Player
     .with(playerNameCTE)
-    .filter(Column("name") == playerNameCTE.all())
+    .filter { $0.name == playerNameCTE.all() }
 ```
 
 > **Note**: the `with(_:)` method can be called as many times as a there are common table expressions in your request.
@@ -167,13 +167,13 @@ Common table expressions can also be used as subqueries, when you update or dele
 // UPDATE player SET name = (SELECT * FROM playerName)
 try Player
     .with(playerNameCTE)
-    .updateAll(db, Column("name").set(to: playerNameCTE.all()))
+    .updateAll(db) { $0.name.set(to: playerNameCTE.all()) }
 
 // WITH playerName AS (SELECT 'O''Brien')
 // DELETE FROM player WHERE name = (SELECT * FROM playerName)
 try Player
     .with(playerNameCTE)
-    .filter(Column("name") == playerNameCTE.all())
+    .filter { $0.name == playerNameCTE.all() }
     .deleteAll(db)
 ```
 
@@ -281,9 +281,15 @@ struct Chat: Codable, FetchableRecord, PersistableRecord {
 }
 
 struct Message: Codable, FetchableRecord, PersistableRecord {
-    var chatID: Int64
+    var chatId: Int64
     var date: Date
     ...
+    
+    enum Columns {
+        static let chatId = Column("chatId")
+        static let date = Column("date")
+        ...
+    }
 }
 ```
 
@@ -315,16 +321,16 @@ We start by defining the CTE request, which loads the latest messages of all cha
 ```swift
 // SELECT *, MAX(date) FROM message GROUP BY chatID
 let latestMessageRequest = Message
-    .annotated(with: max(Column("date")))
-    .group(Column("chatID"))
+    .annotated { max($0.date) }
+    .group(\.chatId)
 ```
 
 We can now define the CTE for the latest messages:
 
 ```swift
 // WITH latestMessage AS
 //   (SELECT *, MAX(date) FROM message GROUP BY chatID)
-let latestMessageCTE = CommonTableExpression(
+let latestMessageCTE = CommonTableExpression<Message>(
     named: "latestMessage",
     request: latestMessageRequest)
 ```
@@ -337,9 +343,9 @@ The association from a chat to its latest message follows:
 let latestMessage = Chat.association(
     to: latestMessageCTE,
     on: { chat, latestMessage in
-        chat[Column("id")] == latestMessage[Column("chatID")]
+        chat.id == latestMessage.chatId
     })
-    .order(Column("date").desc)
+    .order(\.date.desc)
 ```
 
 The final request can now be defined:

Documentation/CommonTableExpressions.md

@@ -64,45 +64,3 @@ extension Player: Codable, FetchableRecord, MutablePersistableRecord {
         id = inserted.rowID
     }
 }
-
-// Convenience access to player columns in this file
-private typealias Columns = Player.Columns
-
-// MARK: - Player Database Requests
-
-/// Define some player requests used by the application.
-///
-/// See <https://swiftpackageindex.com/groue/GRDB.swift/documentation/grdb/recordrecommendedpractices>
-extension DerivableRequest<Player> {
-    /// A request of players ordered by name.
-    ///
-    /// For example:
-    ///
-    ///     let players: [Player] = try dbWriter.read { db in
-    ///         try Player.all().orderedByName().fetchAll(db)
-    ///     }
-    func orderedByName() -> Self {
-        // Sort by name in a localized case insensitive fashion
-        // See https://github.com/groue/GRDB.swift/blob/master/README.md#string-comparison
-        order(Columns.name.collating(.localizedCaseInsensitiveCompare))
-    }
-    
-    /// A request of players ordered by score.
-    ///
-    /// For example:
-    ///
-    ///     let players: [Player] = try dbWriter.read { db in
-    ///         try Player.all().orderedByScore().fetchAll(db)
-    ///     }
-    ///     let bestPlayer: Player? = try dbWriter.read { db in
-    ///         try Player.all().orderedByScore().fetchOne(db)
-    ///     }
-    func orderedByScore() -> Self {
-        // Sort by descending score, and then by name, in a
-        // localized case insensitive fashion
-        // See https://github.com/groue/GRDB.swift/blob/master/README.md#string-comparison
-        order(
-            Columns.score.desc,
-            Columns.name.collating(.localizedCaseInsensitiveCompare))
-    }
-}

Documentation/DemoApps/GRDBDemo/GRDBDemo/Database/Models/Player.swift

@@ -41,9 +41,16 @@ import GRDB
         let observation = ValueObservation.tracking { [ordering] db in
             switch ordering {
             case .byName:
-                try Player.all().orderedByName().fetchAll(db)
+                try Player
+                    .order { $0.name.collating(.localizedCaseInsensitiveCompare) }
+                    .fetchAll(db)
             case .byScore:
-                try Player.all().orderedByScore().fetchAll(db)
+                try Player
+                    .order { [
+                        $0.score.desc,
+                        $0.name.collating(.localizedCaseInsensitiveCompare),
+                    ] }
+                    .fetchAll(db)
             }
         }
 

Documentation/DemoApps/GRDBDemo/GRDBDemo/Views/PlayerListModel.swift

@@ -316,7 +316,7 @@ Use them in the [query interface](../README.md#the-query-interface):
 let documents = try Document.matching(pattern).fetchAll(db)
 
 // Search in a specific column:
-let documents = try Document.filter(Column("content").match(pattern)).fetchAll(db)
+let documents = try Document.filter { $0.content.match(pattern) }.fetchAll(db)
 ```
 
 
@@ -565,7 +565,7 @@ Use them in the [query interface](../README.md#the-query-interface):
 let documents = try Document.matching(pattern).fetchAll(db)
 
 // Search in a specific column:
-let documents = try Document.filter(Column("content").match(pattern)).fetchAll(db)
+let documents = try Document.filter { $0.content.match(pattern) }.fetchAll(db)
 ```
 
 

Documentation/FullTextSearch.md

@@ -32,14 +32,14 @@ try dbQueue.inDatabase { db in
         CREATE TABLE place (
             id INTEGER PRIMARY KEY,
             title TEXT,
-            favorite BOOLEAN NOT NULL,
+            isFavorite BOOLEAN NOT NULL,
             latitude DOUBLE NOT NULL,
             longitude DOUBLE NOT NULL
         )
         """)
 
     try db.execute(sql: """
-        INSERT INTO place (title, favorite, latitude, longitude)
+        INSERT INTO place (title, isFavorite, latitude, longitude)
         VALUES (?, ?, ?, ?)
         """, arguments: ["Paris", true, 48.85341, 2.3488])
     let parisId = db.lastInsertedRowID
@@ -52,11 +52,11 @@ try! dbQueue.inDatabase { db in
     let rows = try Row.fetchCursor(db, sql: "SELECT * FROM place")
     while let row = try rows.next() {
         let title: String = row["title"]
-        let favorite: Bool = row["favorite"]
+        let isFavorite: Bool = row["isFavorite"]
         let coordinate = CLLocationCoordinate2D(
             latitude: row["latitude"],
             longitude: row["longitude"])
-        print("Fetched", title, favorite, coordinate)
+        print("Fetched", title, isFavorite, coordinate)
     }
 
     let placeCount = try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM place")! // Int
@@ -69,35 +69,43 @@ try! dbQueue.inDatabase { db in
 struct Place {
     var id: Int64?
     var title: String?
-    var favorite: Bool
+    var isFavorite: Bool
     var coordinate: CLLocationCoordinate2D
 }
 
 // Adopt FetchableRecord
 extension Place : FetchableRecord {
     init(row: Row) {
-        id = row["id"]
-        title = row["title"]
-        favorite = row["favorite"]
+        id = row[Columns.id]
+        title = row[Columns.title]
+        isFavorite = row[Columns.isFavorite]
         coordinate = CLLocationCoordinate2DMake(
-            row["latitude"],
-            row["longitude"])
+            row[Columns.latitude],
+            row[Columns.longitude])
     }
 }
 
 // Adopt TableRecord
 extension Place : TableRecord {
     static let databaseTableName = "place"
+    
+    enum Columns {
+        static let id = Column("id")
+        static let title = Column("title")
+        static let isFavorite = Column("isFavorite")
+        static let latitude = Column("latitude")
+        static let longitude = Column("longitude")
+    }
 }
 
 // Adopt MutablePersistableRecord
 extension Place : MutablePersistableRecord {
     func encode(to container: inout PersistenceContainer) throws {
-        container["id"] = id
-        container["title"] = title
-        container["favorite"] = favorite
-        container["latitude"] = coordinate.latitude
-        container["longitude"] = coordinate.longitude
+        container[Columns.id] = id
+        container[Columns.title] = title
+        container[Columns.isFavorite] = isFavorite
+        container[Columns.latitude] = coordinate.latitude
+        container[Columns.longitude] = coordinate.longitude
     }
 
     mutating func didInsert(_ inserted: InsertionSuccess) {
@@ -109,13 +117,13 @@ try dbQueue.inDatabase { db in
     var berlin = Place(
         id: nil,
         title: "Berlin",
-        favorite: false,
+        isFavorite: false,
         coordinate: CLLocationCoordinate2DMake(52.52437, 13.41053))
 
     try berlin.insert(db)
     berlin.id // some value
 
-    berlin.favorite = true
+    berlin.isFavorite = true
     try berlin.update(db)
 
     // Fetch from SQL
@@ -124,13 +132,10 @@ try dbQueue.inDatabase { db in
 
     //: Avoid SQL with the query interface:
 
-    let title = Column("title")
-    let favorite = Column("favorite")
-    
-    berlin = try Place.filter(title == "Berlin").fetchOne(db)!   // Place
+    berlin = try Place.filter { $0.title == "Berlin" }.fetchOne(db)! // Place
     let paris = try Place.fetchOne(db, key: 1)                   // Place?
     let favoritePlaces = try Place                               // [Place]
-        .filter(favorite == true)
-        .order(title)
+        .filter { $0.isFavorite == true }
+        .order { $0.title }
         .fetchAll(db)
 }

Documentation/Playgrounds/Tour.playground/Contents.swift

@@ -93,7 +93,7 @@ Columns are special expressions that allow some optimizations and niceties:
     ValueObservation.tracking { db in
         try Player.fetchOne(db, id: 1)
         // or
-        try Player.filter(Column("id") == 1).fetchOne(db)
+        try Player.filter { $0.id == 1 }.fetchOne(db)
     }
 
     // Non-optimized observations
@@ -110,7 +110,7 @@ Columns are special expressions that allow some optimizations and niceties:
     // Nicer SQL
     // SELECT * FROM player WHERE id = 1
     try Player.fetchOne(db, id: 1)
-    try Player.filter(Column("id") == 1).fetchOne(db)
+    try Player.filter { $0.id == 1 }.fetchOne(db)
 
     // Less nice SQL
     // SELECT * FROM player WHERE id = 1 LIMIT 1
@@ -261,7 +261,7 @@ The basic value types conform to [DatabaseValueConvertible] so that they can fee
 ```swift
 // SELECT * FROM player WHERE name = 'O''Brien'
 //                                   ~~~~~~~~~~
-Player.filter(Column("name") == "O'Brien")
+Player.filter { $0.name == "O'Brien" }
 ```
 
 ### QueryInterfaceRequest
@@ -346,8 +346,9 @@ Functions and methods that build an SQL expression should return an SQLExpressio
 
 ```swift
 // SELECT * FROM player WHERE LENGTH(name) > 0
-let expression = length(Column("name")) > 0 // SQLExpression
-Player.filter(expression)
+Player.filter {
+    length($0.name) > 0 // SQLExpression
+}
 ```
 
 When it looks like GRDB APIs are unable to build a particular expression, use [SQL]:
@@ -358,7 +359,7 @@ func date(_ value: SQLSpecificExpressible) -> SQLExpression {
 }
 
 // SELECT * FROM player WHERE DATE(createdAt) = '2020-01-23'
-let request = Player.filter(date(Column("createdAt")) == "2020-01-23")
+let request = Player.filter { date($0.createdAt) == "2020-01-23" }
 ```
 
 This technique, based on [SQL Interpolation], is composable and works well even when several tables are involved. See how the `createdAt` column below is correctly attributed to the `player` table:
@@ -368,7 +369,7 @@ This technique, based on [SQL Interpolation], is composable and works well even
 // JOIN team ON team.id = player.teamId
 // WHERE DATE(player.createdAt) = '2020-01-23'
 let request = Player
-    .filter(date(Column("createdAt")) == "2020-01-23")
+    .filter { date($0.createdAt) == "2020-01-23" }
     .including(required: Player.team)
 ```
 
@@ -583,7 +584,7 @@ SQLSubqueryable provides the GRDB support for subqueries. Its [SQLSpecificExpres
 // SELECT * FROM player
 // WHERE score >= (SELECT AVG(score) FROM player)
 let averageScore = Player.select(average(Column("score")))
-Player.filter(Column("score") >= averageScore)
+Player.filter { $0.score >= averageScore }
 ```
 
 SQLSubqueryable has the `contains(_:)` and `exists()` methods that support the `value IN (subquery)` and `EXISTS (subquery)` expressions.

Documentation/QueryInterfaceOrganization.md

@@ -175,7 +175,7 @@ func date(_ expression: SQLExpressible) -> SQLExpression {
     SQL("DATE(\(expression))").sqlExpression
 }
 
-let request = Player.filter(date(Column("createdAt")) == "2020-01-23")
+let request = Player.filter { date($0.createdAt) == "2020-01-23" }
 ```
 
 

Documentation/SQLInterpolation.md

@@ -207,13 +207,13 @@ try player.updateChanges {
 
 // SELECT * FROM player ORDER BY score DESC LIMIT 10
 let bestPlayers: [Player] = try Player
-    .order(scoreColumn.desc)
+    .order(\.score.desc)
     .limit(10)
     .fetchAll(db)
 
 // SELECT MAX(score) FROM player
 let maximumScore: Int? = try Player
-    .select(max(scoreColumn))
+    .select { max($0.score) }
     .asRequestOf(Int.self)
     .fetchOne(db)