使用 Parse Swift 在 mongoDB 上进行查询

Question

我在 Mongo DB 中有两个集合。

这是文档在第一个集合 (MainCollection) 中的外观：

_id
:"mzWqPEDYRU"
TITLE
:"ZAZ: I want."
ownerID
:"lGutCBY52g"
accessKey
:"0kAd4TOmoK0"
_created_at
:2020-03-13T11:42:11.169+00:00
_updated_at
:2020-03-13T17:08:15.090+00:00
downloadCount
:2

这是它在第二个集合中的样子 (SecondCollection)：

_id
:"07BOGA8bHG"
_p_unit
:"MainCollection$mzWqPEDYRU"
SENTENCE
:"I love nature peace and freedom."
Order
:5
ownerID
:"lGutCBY52g"
AUDIO
:"07067b5589d1edd1d907e96c1daf6da1_VOICE.bin"
_created_at
:2020-03-13T11:42:17.483+00:00
_updated_at
:2020-03-13T11:42:19.336+00:00

第一个和第二个集合之间存在父子关系。在最后一个文档中，我们可以看到 _p_unit 字段，其中“mzWqPEDYRU”部分指向第一个集合中父级的 id。

虽然我终于得到了我想要的，用给定的父级获取第二个集合的元素，但它并没有按照应有的方式完成。

我在对SecondCollection 进行选择性查询时遇到了一个问题。这是当前工作的代码：

func theFunction(element: MainCollection) {
    do {SecondCollection.query().find() {
            result in
            switch result {
            case .success(let items):
                print("items.count = \(items.count)")
                var finalCount = 0
                for item in items {
                    // Ignore useless elements:
                    if item.unit?.objectId != element.objectId! {continue}

                    finalCount += 1
                    /// .... Work with selected element.
                }
                print("finalCount = \(finalCount)")
            case .failure(let error):
                print("Error in \(#function): \(error)")
            }
        }
    }
}

上述代码的编写方式在我获得了我感兴趣的 SecondCollection 中的元素的意义上是有效的。但是 for 循环 中的这个技巧可以消除不需要的元素不是要走的路。

if item.unit?.objectId != element.objectId! {continue}

过滤应该发生在查询中，行：

SecondCollection.query().find()

问题是我尝试过的一切都失败了。我做了类似的事情：

SecondCollection.query("unit" == element.objectId!).find()

有无数种变化，但都没有运气。

有人知道正确的语法吗？

如果这可能有用，下面是 SecondCollection 的声明方式：

struct SecondCollection: ParseObject,Identifiable,Equatable,Hashable {
    // These fields are required for any Object.
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    
    // Local properties.
    var id:UUID {return UUID()}
    var SENTENCE: String?,
        Order: Int?,
        ownerID: String?,
        AUDIO: ParseFile?,
        unit: Pointer<MainCollection>?
    .......
}

Answer 1

首先，我不认为引入所有元素然后“消除”你不需要的元素是一个好方法。这样一来，您检索的数据比需要的多得多，而且效率很低。 我尝试了您的代码，但您并不清楚（至少对我而言）您是否在这些类之间使用指针或关系。每个人的方法都会有所不同。 你用的是哪一个？

更新：嘿！我想我可以让它按照你需要的方式工作。 我创建了两个类 ParentClass（名称：字符串，年龄：数字，孩子：与 ChildClass 的关系）：

struct ParentClass: ParseObject {
    //: These are required for any Object.
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?

    //: Your own properties.
    var name: String?
    var age: Int = 0
    var children: ParseRelation<Self> {
        ParseRelation(parent: self, key: "children", className: "ChildClass")
    }
}

和 ChildClass（名称：字符串，年龄：数字）：

struct ChildClass: ParseObject {
    //: These are required for any Object.
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?

    //: Your own properties.
    var name: String?
    var age: Int = 0
}

然后我做了一个简单的查询来找到第一个父母。您可以使用 find() 方法并带上您需要的所有方法，但我这样做是为了使其更易于解释：

让 parentQuery = ParentClass.query()

    parentQuery.first { result in
        switch result {
        case .success(let found):
            print ("FOUND A PARENT!")
            print(found.name!)
            print(found.age)
            print(found.children)
        case .failure(let error):
            print(error)
        }
    }

现在我得到了 Parent（在我的例子中有两个孩子），我使用 query() 方法在 ChildClass 上生成查询，该查询包含找到的 parent 的所有 ChildClass 对象：

do {
                    let childrenObject = ChildClass()
                    try found.children.query(childrenObject).find()
                    { result in
                        switch result {
                        case .success(let allChildrenFromParent):
                            print("The following Children are part of the \(found.name!):")
                            for child in allChildrenFromParent {
                                print("\(child.name!) is a child of \(found.name!)")
                            }
                        case .failure(let error):
                            print("Error finding Children: \(error)")
                        }
                    }

                } catch {
                    print("Error: \(error)")
                }

整个代码最终是这样的：

let parentQuery = ParentClass.query()
        
        parentQuery.first { result in
            switch result {
            case .success(let found):
                print ("FOUND A PARENT!")
                print(found.name!)
                print(found.age)
                print(found.children)
                do {
                    let childrenObject = ChildClass()
                    try found.children.query(childrenObject).find()
                    { result in
                        switch result {
                        case .success(let allChildrenFromParent):
                            print("The following Children are part of the \(found.name!):")
                            for child in allChildrenFromParent {
                                print("\(child.name!) is a child of \(found.name!)")
                            }
                        case .failure(let error):
                            print("Error finding Children: \(error)")
                        }
                    }

                } catch {
                    print("Error: \(error)")
                }
            case .failure(let error):
                print(error)
            }
        }