AllColumnsExcluding tests

Author: groue

Tests/GRDBTests/AssociationBelongsToRowScopeTests.swift

@@ -66,6 +66,16 @@ class AssociationBelongsToRowScopeTests: GRDBTestCase {
         XCTAssertEqual(rows[0].scopes["team"]!, ["id":1, "name":"Reds"])
     }
 
+    func testDefaultScopeIncludingRequiredRestrictedSelection() throws {
+        let dbQueue = try makeDatabaseQueue()
+        let request = Player.select(.allColumns(excluding: ["name"])).including(required: Player.defaultTeam)
+        let rows = try dbQueue.inDatabase { try Row.fetchAll($0, request) }
+        XCTAssertEqual(rows.count, 1)
+        XCTAssertEqual(rows[0].unscoped, ["id":1, "teamId":1])
+        XCTAssertEqual(Set(rows[0].scopes.names), ["team"])
+        XCTAssertEqual(rows[0].scopes["team"]!, ["id":1, "name":"Reds"])
+    }
+    
     func testDefaultScopeAnnotatedWithRequired() throws {
         let dbQueue = try makeDatabaseQueue()
         let request = Player.annotated(withRequired: Player.defaultTeam)
@@ -82,6 +92,14 @@ class AssociationBelongsToRowScopeTests: GRDBTestCase {
         XCTAssertEqual(rows[0], ["id":1, "teamId":1, "name":"Arthur", "teamName":"Reds"])
     }
 
+    func testDefaultScopeAnnotatedWithRequiredRestrictedSelection() throws {
+        let dbQueue = try makeDatabaseQueue()
+        let request = Player.annotated(withRequired: Player.defaultTeam.select(.allColumns(excluding: ["name"])))
+        let rows = try dbQueue.inDatabase { try Row.fetchAll($0, request) }
+        XCTAssertEqual(rows.count, 1)
+        XCTAssertEqual(rows[0], ["id":1, "teamId":1, "name":"Arthur", "id":1])
+    }
+    
     func testDefaultScopeIncludingOptional() throws {
         let dbQueue = try makeDatabaseQueue()
         let request = Player.including(optional: Player.defaultTeam)
@@ -113,6 +131,15 @@ class AssociationBelongsToRowScopeTests: GRDBTestCase {
         XCTAssertEqual(rows[1], ["id":2, "teamId":nil, "name":"Barbara", "teamName":nil])
     }
 
+    func testDefaultScopeAnnotatedWithOptionalRestrictedSelection() throws {
+        let dbQueue = try makeDatabaseQueue()
+        let request = Player.annotated(withOptional: Player.defaultTeam.select(.allColumns(excluding: ["name"])))
+        let rows = try dbQueue.inDatabase { try Row.fetchAll($0, request) }
+        XCTAssertEqual(rows.count, 2)
+        XCTAssertEqual(rows[0], ["id":1, "teamId":1, "name":"Arthur", "id":1])
+        XCTAssertEqual(rows[1], ["id":2, "teamId":nil, "name":"Barbara", "id":nil])
+    }
+    
     func testDefaultScopeJoiningRequired() throws {
         let dbQueue = try makeDatabaseQueue()
         let request = Player.joining(required: Player.defaultTeam)
@@ -153,6 +180,16 @@ class AssociationBelongsToRowScopeTests: GRDBTestCase {
         XCTAssertEqual(rows[0].scopes["customTeam"]!, ["id":1, "name":"Reds"])
     }
 
+    func testCustomScopeIncludingRequiredRestrictedSelection() throws {
+        let dbQueue = try makeDatabaseQueue()
+        let request = Player.select(.allColumns(excluding: ["name"])).including(required: Player.customTeam)
+        let rows = try dbQueue.inDatabase { try Row.fetchAll($0, request) }
+        XCTAssertEqual(rows.count, 1)
+        XCTAssertEqual(rows[0].unscoped, ["id":1, "teamId":1])
+        XCTAssertEqual(Set(rows[0].scopes.names), ["customTeam"])
+        XCTAssertEqual(rows[0].scopes["customTeam"]!, ["id":1, "name":"Reds"])
+    }
+    
     func testCustomScopeAnnotatedWithRequired() throws {
         let dbQueue = try makeDatabaseQueue()
         let request = Player.annotated(withRequired: Player.customTeam)
@@ -169,6 +206,14 @@ class AssociationBelongsToRowScopeTests: GRDBTestCase {
         XCTAssertEqual(rows[0], ["id":1, "teamId":1, "name":"Arthur", "teamName":"Reds"])
     }
 
+    func testCustomScopeAnnotatedWithRequiredRestrictedSelection() throws {
+        let dbQueue = try makeDatabaseQueue()
+        let request = Player.annotated(withRequired: Player.customTeam.select(.allColumns(excluding: ["name"])))
+        let rows = try dbQueue.inDatabase { try Row.fetchAll($0, request) }
+        XCTAssertEqual(rows.count, 1)
+        XCTAssertEqual(rows[0], ["id":1, "teamId":1, "name":"Arthur", "id":1])
+    }
+    
     func testCustomScopeIncludingOptional() throws {
         let dbQueue = try makeDatabaseQueue()
         let request = Player.including(optional: Player.customTeam)
@@ -200,6 +245,15 @@ class AssociationBelongsToRowScopeTests: GRDBTestCase {
         XCTAssertEqual(rows[1], ["id":2, "teamId":nil, "name":"Barbara", "teamName":nil])
     }
 
+    func testCustomScopeAnnotatedWithOptionalRestrictedSelection() throws {
+        let dbQueue = try makeDatabaseQueue()
+        let request = Player.annotated(withOptional: Player.customTeam.select(.allColumns(excluding: ["name"])))
+        let rows = try dbQueue.inDatabase { try Row.fetchAll($0, request) }
+        XCTAssertEqual(rows.count, 2)
+        XCTAssertEqual(rows[0], ["id":1, "teamId":1, "name":"Arthur", "id":1])
+        XCTAssertEqual(rows[1], ["id":2, "teamId":nil, "name":"Barbara", "id":nil])
+    }
+    
     func testCustomPluralScopeIncludingRequired() throws {
         // Make sure explicit plural keys are preserved
         let dbQueue = try makeDatabaseQueue()

Tests/GRDBTests/AssociationBelongsToSQLDerivationTests.swift

@@ -5,7 +5,8 @@ import GRDB
 private struct A : TableRecord {
     static let databaseTableName = "a"
     static let b = belongsTo(B.self)
-    static let restrictedB = belongsTo(RestrictedB.self)
+    static let restrictedB1 = belongsTo(RestrictedB1.self)
+    static let restrictedB2 = belongsTo(RestrictedB2.self)
     static let extendedB = belongsTo(ExtendedB.self)
 }
 
@@ -14,11 +15,16 @@ private struct B : TableRecord {
     static let databaseTableName = "b"
 }
 
-private struct RestrictedB : TableRecord {
+private struct RestrictedB1 : TableRecord {
     static let databaseTableName = "b"
     static var databaseSelection: [any SQLSelectable] { [Column("name")] }
 }
 
+private struct RestrictedB2 : TableRecord {
+    static let databaseTableName = "b"
+    static var databaseSelection: [any SQLSelectable] { [.allColumns(excluding: ["id"])] }
+}
+
 private struct ExtendedB : TableRecord {
     static let databaseTableName = "b"
     static var databaseSelection: [any SQLSelectable] { [.allColumns, .rowID] }
@@ -48,7 +54,12 @@ class AssociationBelongsToSQLDerivationTests: GRDBTestCase {
                 FROM "a" \
                 JOIN "b" ON "b"."id" = "a"."bid"
                 """)
-            try assertEqualSQL(db, A.including(required: A.restrictedB), """
+            try assertEqualSQL(db, A.including(required: A.restrictedB1), """
+                SELECT "a".*, "b"."name" \
+                FROM "a" \
+                JOIN "b" ON "b"."id" = "a"."bid"
+                """)
+            try assertEqualSQL(db, A.including(required: A.restrictedB2), """
                 SELECT "a".*, "b"."name" \
                 FROM "a" \
                 JOIN "b" ON "b"."id" = "a"."bid"
@@ -89,9 +100,9 @@ class AssociationBelongsToSQLDerivationTests: GRDBTestCase {
                 let request = A
                     .aliased(aAlias)
                     .including(required: A.b
-                    .select(
-                        Column("name"),
-                        (Column("id") + aAlias[Column("id")]).forKey("foo")))
+                        .select(
+                            Column("name"),
+                            (Column("id") + aAlias[Column("id")]).forKey("foo")))
                 try assertEqualSQL(db, request, """
                     SELECT "a".*, "b"."name", "b"."id" + "a"."id" AS "foo" \
                     FROM "a" \