如何使用 Firestore 中的集合和子集合在数组中创建数组？

Question

我需要创建一个包含Questions 数组的Categories 数组。

struct CategoryFB {
    var title: String
    var id: Int
    var questions: [QuestionsFB]

    var dictionary: [String : Any] {
        return ["title" : title, 
                "id" : id]
    }
}

extension CategoryFB {
    init?(dictionary: [String : Any], questions: [QuestionsFB]) {
        guard let title = dictionary["title"] as? String, let id = dictionary["id"] as? Int else { return nil }

        self.init(title: title, id: id, questions: questions)
    }
}

Firestore 具有以下结构

1. 集合（“类别”）
2. 文档（“some_id”）
3. 集合（“问题”）

如何创建这样的数组？

array = [Category(title: "First", 
                  questions: [
                      Question("1"),
                      ...
                  ]), 
         ... ]

我的尝试是错误的：

db.collection("Categories").order(by: "id", descending: false).getDocuments {
    (querySnapshot, error) in
    if error != nil {
        print("Error when getting data \(String(describing: error?.localizedDescription))")
    } else {
        for document in querySnapshot!.documents {
            print(document.documentID)
            self.db.collection("Categories").document(document.documentID).collection("Questions").getDocuments(completion: { (subQuerySnapshot, error) in
                if error != nil {
                    print(error!.localizedDescription)
                } else {
                    var questionsArray: [QuestionsFB]?
                    questionsArray = subQuerySnapshot?.documents.compactMap({QuestionsFB(dictionary: $0.data())})
                    self.categoriesArray = querySnapshot?.documents.compactMap({CategoryFB(dictionary: $0.data(), questions: questionsArray!)})
                    print(self.categoriesArray![0].questions.count)
                    DispatchQueue.main.async {
                        self.tableView.reloadData()
                    }
                }
            })
        }
    }
}

Answer 1

这是我自己找到的解决方案。希望这对将来的人有所帮助。

func getData(completion: @escaping (_ result: [Any]) -> Void) {
    let rootCollection = db.collection("Categories")

    var data = [Any]()

    rootCollection.order(by: "id", descending: false).getDocuments(completion: {

        (querySnapshot, error) in

        if error != nil {
            print("Error when getting data \(String(describing: error?.localizedDescription))")
        } else {
            guard let topSnapshot = querySnapshot?.documents else { return }
            for category in topSnapshot {
                rootCollection.document(category.documentID).collection("Questions").getDocuments(completion: {
                    (snapshot, err) in

                    guard let snapshot = snapshot?.documents else { return }

                    var questions = [Question]()

                    for document in snapshot {
                        let title = document.data()["title"] as! String
                        let details = document.data()["details"] as! String
                        let article = document.data()["article"] as! String
                        let link = document.data()["link"] as! String
                        let id = document.data()["id"] as! String
                        let possibleAnswers = document.data()["possibleAnswers"] as! [String]
                        let rightAnswerID = document.data()["rightAnswerID"] as! Int

                        let newQuestion = Question(title: title, article: article, details: details, link: link, possibleAnswers: possibleAnswers, rightAnswerID: rightAnswerID, id: id)

                        questions.append(newQuestion)

                    }
                    let categoryTitle = category.data()["title"] as! String
                    let collectionID = category.data()["id"] as! Int


                    let newCategory = Category(title: categoryTitle, id: collectionID, questions: questions)


                    data.append(newCategory)

                    //Return data on completion
                    completion(data)
                })
            }
        }
    })
}

Answer 2

您的主要问题似乎源于您每次运行子查询时都在重新生成类别数组，而当您这样做时，您只为整个事物提供了一个问题数组。

有很多方法可以解决这个问题。我可能会分解它，以便您 a) 首先允许自己创建一个没有任何问题的类别数组，然后 b) 回顾每个单独的子查询，并在获得它们时将它们插入到您的类别中。

您的最终代码可能看起来像这样。请注意，这意味着更改您的 Category 对象，以便您可以在没有 Questions 数组的情况下首先创建它，并实现此自定义 addQuestions:toCategory: 方法（如果您将类别存储为字典而不是数组，这将容易得多）

db.collection("Categories").order(by: "id", descending: false).getDocuments {
    (querySnapshot, error) in
    if error != nil {
        print("Error when getting data \(String(describing: error?.localizedDescription))")
    } else {
        self.categoriesArray = querySnapshot?.documents.compactMap({CategoryFB(dictionary: $0.data()})
        for document in querySnapshot!.documents {
            print(document.documentID)
            self.db.collection("Categories").document(document.documentID).collection("Questions").getDocuments(completion: { (subQuerySnapshot, error) in
                if error != nil {
                    print(error!.localizedDescription)
                } else {
                    var questionsArray: [QuestionsFB]?
                    questionsArray = subQuerySnapshot?.documents.compactMap({QuestionsFB(dictionary: $0.data())})
                    self.addQuestions(questionsArray toCategory: document.documentID)
                    print(self.categoriesArray![0].questions.count)
                    DispatchQueue.main.async {
                        self.tableView.reloadData()
                    }
                }
            })
        }
    }
}

或者，如果您认为您将处于每次想要获取某个类别时总是想要获取您的问题的情况，您可能会考虑不放置它们根本就在一个子集合中，只是在原始类别文档中使它们成为一个地图。