使用 Parse Swift 在 mongoDB 上进行查询

Posted 2023-03-16

【中文标题】使用 Parse Swift 在 mongoDB 上进行查询

【英文标题】：Making a query on a mongo DB with ParseSwift

【发布时间】：2021-06-13 07:22:03

【问题描述】：

我在 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>?
    .......

【参考方案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)
            
        

【讨论】：

“我不认为......是一个好方法......”：我完全同意。你完全正确！就您的问题而言，我不确定我应该提供哪些信息，指针（对我而言）只是表达关系的一种方式。那么你能告诉我你需要什么吗？或者以其他方式给我您想到的两个选项的解决方案，然后我可以尝试找出与我相关的内容。

@Alex_Kusmenkovsky。我在帖子末尾添加了一些信息，我想它会给你你所缺少的信息。

@Alex_Kusmenkovsky。我不太遵循您的解决方案。知道在亲子关系中，一个父母可以有很多孩子，但一个孩子只有一个父母。我不明白“查找第一个父级的简单查询”的含义。接下来，在我的用例中，您可以在帖子中看到父关系由称为“单元”的变量（指针）表示。在函数中，我只是让 SecondCollection 中的所有项目都具有相同的单位。我觉得您的解决方案比我实际需要的要强大得多（也复杂得多）。

@Alex_Kusmenkovsky。我看到您将其添加到父类： var children: ParseRelation ParseRelation(parent: self, key: "children", className: "ChildClass") 毕竟，为什么不呢？但这真的有必要吗？我在做什么（检查查询中父级的值）应该不够？在我看来，这应该更简单。