fix(DataStore): QueryPredicate translation (#961)

* PR for fixing nested sql statement

* added one more unit test

* rename opAhead to predicateIndex

* added one integration test

Co-authored-by: Guo <[email protected]>

Author: 618coffee

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Storage/SQLite/SQLStatement+Condition.swift

@@ -23,30 +23,37 @@ private func translateQueryPredicate(from modelSchema: ModelSchema,
                                      namespace: Substring? = nil) -> SQLPredicate {
     var sql: [String] = []
     var bindings: [Binding?] = []
-    var groupType: QueryPredicateGroupType = .and
     let indentPrefix = "  "
     var indentSize = 1
-    var groupOpened = false
 
-    func translate(_ pred: QueryPredicate) {
+    func translate(_ pred: QueryPredicate, predicateIndex: Int, groupType: QueryPredicateGroupType) {
         let indent = String(repeating: indentPrefix, count: indentSize)
         if let operation = pred as? QueryPredicateOperation {
-            let logicalOperator = groupOpened ? "" : "\(groupType.rawValue) "
             let column = operation.operator.columnFor(field: operation.field,
                                                       namespace: namespace)
-            sql.append("\(indent)\(logicalOperator)\(column) \(operation.operator.sqlOperation)")
+            if predicateIndex == 0 {
+                sql.append("\(indent)\(column) \(operation.operator.sqlOperation)")
+            } else {
+                sql.append("\(indent)\(groupType.rawValue) \(column) \(operation.operator.sqlOperation)")
+            }
+
             bindings.append(contentsOf: operation.operator.bindings)
-            groupOpened = false
         } else if let group = pred as? QueryPredicateGroup {
             var shouldClose = false
-            groupOpened = group.type != groupType
-            if groupOpened {
+
+            if predicateIndex == 0 {
+                sql.append("\(indent)(")
+            } else {
                 sql.append("\(indent)\(groupType.rawValue) (")
-                groupType = group.type
-                indentSize += 1
-                shouldClose = true
             }
-            group.predicates.forEach { translate($0) }
+
+            indentSize += 1
+            shouldClose = true
+
+            for index in 0 ..< group.predicates.count {
+                translate(group.predicates[index], predicateIndex: index, groupType: group.type)
+            }
+
             if shouldClose {
                 indentSize -= 1
                 sql.append("\(indent))")
@@ -57,7 +64,10 @@ private func translateQueryPredicate(from modelSchema: ModelSchema,
             }
         }
     }
-    translate(predicate)
+
+    // the very first `and` is always prepended, using -1 for if statement checking
+    // the very first `and` is to connect `where` clause with translated QueryPredicate
+    translate(predicate, predicateIndex: -1, groupType: .and)
     return (sql.joined(separator: "\n"), bindings)
 }
 

AmplifyPlugins/DataStore/AWSDataStoreCategoryPluginIntegrationTests/DataStoreLocalStoreTests.swift

@@ -14,8 +14,39 @@ import AWSPluginsCore
 @testable import AmplifyTestCommon
 @testable import AWSDataStoreCategoryPlugin
 
+// swfitlint:disable file_length
+// swiftlint:disable type_body_length
 class DataStoreLocalStoreTests: LocalStoreIntegrationTestBase {
 
+    /// - Given: 4 posts that has been saved
+    /// - When:
+    ///    - query with grouped predicate
+    /// - Then:
+    ///    - 2 post instances will be returned
+    ///    - second page returns the remaining 5 posts
+    ///    - the 15 retrieved posts have unique identifiers
+    func testQueryWithGroupedQueryPredicateInput() throws {
+        setUpLocalStoreForGroupedPredicateTest()
+        var posts = [Post]()
+        let queryFirstTimeSuccess = expectation(description: "Query post completed")
+        let post = Post.keys
+        let predicate = (post.id <= 1 && post.title == "title1")
+            || (post.rating > 2 && post.status == PostStatus.private)
+        Amplify.DataStore.query(Post.self,
+                                where: predicate) { result in
+            switch result {
+            case .success(let returnPosts):
+                posts.append(contentsOf: returnPosts)
+                queryFirstTimeSuccess.fulfill()
+            case .failure(let error):
+                XCTFail("Error querying posts: \(error)")
+            }
+        }
+        wait(for: [queryFirstTimeSuccess], timeout: 10)
+
+        XCTAssertEqual(posts.count, 2)
+    }
+
     /// - Given: 15 posts that has been saved
     /// - When:
     ///    - query with pagination input given a page number and limit 10
@@ -366,4 +397,28 @@ class DataStoreLocalStoreTests: LocalStoreIntegrationTestBase {
         }
         return savedPosts
     }
+
+    func setUpLocalStoreForGroupedPredicateTest() {
+        var savedPosts = [Post]()
+        savedPosts.append(Post(id: "1", title: "title1", content: "content1",
+                               createdAt: .now(), rating: 1, status: .draft))
+        savedPosts.append(Post(id: "2", title: "title2", content: "content2",
+                               createdAt: .now(), rating: 2, status: .private))
+        savedPosts.append(Post(id: "3", title: "title3", content: "content3",
+                               createdAt: .now(), rating: 3, status: .draft))
+        savedPosts.append(Post(id: "4", title: "title4", content: "content4",
+                               createdAt: .now(), rating: 4, status: .private))
+        for post in savedPosts {
+            let saveSuccess = expectation(description: "Save post completed")
+            Amplify.DataStore.save(post) { result in
+                switch result {
+                case .success:
+                    saveSuccess.fulfill()
+                case .failure(let error):
+                    XCTFail("Error saving post, \(error)")
+                }
+            }
+            wait(for: [saveSuccess], timeout: 10)
+        }
+    }
 }