Google Firestore - Wie erhalte ich Dokumente mit mehreren IDs auf einer Rundreise?

Ich frage mich, ob es möglich ist, mehrere Dokumente anhand der ID-Liste in einer Hin- und Rückfahrt (Netzwerkanruf) zum Firestore abzurufen.

Wenn Sie sich innerhalb des Knotens befinden:

https://github.com/googleapis/nodejs-firestore/blob/master/dev/src/index.ts#L701

/**
* Retrieves multiple documents from Firestore.
*
* @param {...DocumentReference} documents - The document references
* to receive.
* @returns {Promise<Array.<DocumentSnapshot>>} A Promise that
* contains an array with the resulting document snapshots.
*
* @example
* let documentRef1 = firestore.doc('col/doc1');
* let documentRef2 = firestore.doc('col/doc2');
*
* firestore.getAll(documentRef1, documentRef2).then(docs => {
*   console.log(`First document: ${JSON.stringify(docs[0])}`);
*   console.log(`Second document: ${JSON.stringify(docs[1])}`);
* });
*/

Dies ist speziell für das Server-SDK

UPDATE: "Cloud Firestore [clientseitiges SDK] unterstützt jetzt IN-Abfragen!"

https://firebase.googleblog.com/2019/11/cloud-firestore-now-supports-in-queries.html

myCollection.where(firestore.FieldPath.documentId(), 'in', ["123","456","789"])

Sie haben gerade diese Funktionalität angekündigt, https://firebase.googleblog.com/2019/11/cloud-firestore-now-supports-in-queries.html .

Jetzt können Sie Abfragen wie verwenden, aber beachten Sie, dass die Eingabegröße nicht größer als 10 sein darf.

userCollection.where('uid', 'in', ["1231","222","2131"])

Nein, derzeit gibt es keine Möglichkeit, mehrere Leseanforderungen mit dem Cloud Firestore SDK zu stapeln, und daher keine Möglichkeit, sicherzustellen, dass Sie alle Daten gleichzeitig lesen können.

Wie Frank van Puffelen in den obigen Kommentaren gesagt hat, bedeutet dies jedoch nicht, dass das Abrufen von 3 Dokumenten dreimal so langsam ist wie das Abrufen eines Dokuments. Es ist am besten, eigene Messungen durchzuführen, bevor Sie hier zu einer Schlussfolgerung gelangen.

In der Praxis würden Sie firestore.getAll so verwenden

async getUsers({userIds}) {
    const refs = userIds.map(id => this.firestore.doc(`users/${id}`))
    const users = await this.firestore.getAll(...refs)
    console.log(users.map(doc => doc.data()))
}

oder mit Versprechenssyntax

getUsers({userIds}) {
    const refs = userIds.map(id => this.firestore.doc(`users/${id}`))
    this.firestore.getAll(...refs).then(users => console.log(users.map(doc => doc.data())))
}

Sie könnten eine Funktion wie diese verwenden:

function getById (path, ids) {
  return firestore.getAll(
    [].concat(ids).map(id => firestore.doc(`${path}/${id}`))
  )
}

Es kann mit einer einzigen ID aufgerufen werden:

getById('collection', 'some_id')

oder ein Array von IDs:

getById('collection', ['some_id', 'some_other_id'])

Der beste Weg, dies zu tun, ist sicherlich die Implementierung der eigentlichen Abfrage von Firestore in einer Cloud-Funktion. Es würde dann nur einen einzigen Hin- und Rückruf vom Kunden zu Firebase geben, was genau das zu sein scheint, wonach Sie fragen.

Sie möchten wirklich Ihre gesamte Datenzugriffslogik wie diese Serverseite beibehalten.

Intern wird es wahrscheinlich die gleiche Anzahl von Anrufen bei Firebase selbst geben, aber alle werden über die superschnellen Verbindungen von Google und nicht über das externe Netzwerk erfolgen. In Kombination mit dem von Frank van Puffelen erläuterten Pipelining sollten Sie eine hervorragende Leistung erzielen dieser Ansatz.

Wenn Sie Flattern verwenden, können Sie Folgendes tun:

Firestore.instance.collection('your collection name').where(FieldPath.documentId, whereIn:[list containing multiple document IDs]).getDocuments();

Dies gibt eine Zukunft zurück, List<DocumentSnapshot>die Sie wiederholen können, wenn Sie sich fit fühlen.

So würden Sie in Kotlin mit dem Android SDK so etwas machen.
Möglicherweise nicht unbedingt in einer Hin- und Rückfahrt, aber es gruppiert das Ergebnis effektiv und vermeidet viele verschachtelte Rückrufe.

val userIds = listOf("123", "456")
val userTasks = userIds.map { firestore.document("users/${it!!}").get() }

Tasks.whenAllSuccess<DocumentSnapshot>(userTasks).addOnSuccessListener { documentList ->
    //Do what you need to with the document list
}

Beachten Sie, dass das Abrufen bestimmter Dokumente viel besser ist als das Abrufen aller Dokumente und das Filtern des Ergebnisses. Dies liegt daran, dass Firestore Ihnen die Abfrageergebnismenge in Rechnung stellt.

Dies scheint im Firestore derzeit nicht möglich zu sein. Ich verstehe nicht, warum Alexanders Antwort akzeptiert wird. Die von ihm vorgeschlagene Lösung gibt nur alle Dokumente in der Sammlung "Benutzer" zurück.

Je nachdem, was Sie tun müssen, sollten Sie die relevanten Daten, die Sie anzeigen müssen, duplizieren und nur bei Bedarf ein vollständiges Dokument anfordern.

Das Beste, was Sie tun können, ist, es nicht zu verwenden, Promise.allda Ihr Client darauf warten muss.all die Lesevorgänge bevor Sie fortfahren.

Iterieren Sie die Lesevorgänge und lassen Sie sie unabhängig voneinander auflösen. Auf der Clientseite läuft dies wahrscheinlich darauf hinaus, dass die Benutzeroberfläche mehrere Progress Loader-Images unabhängig voneinander in Werte auflöst. Dies ist jedoch besser als das Einfrieren des gesamten Clients bis.all die Lesevorgänge aufgelöst sind.

Speichern Sie daher alle synchronen Ergebnisse sofort in der Ansicht und lassen Sie die asynchronen Ergebnisse einzeln beim Auflösen eingehen. Dies mag wie eine geringfügige Unterscheidung erscheinen, aber wenn Ihr Client über eine schlechte Internetverbindung verfügt (wie ich sie derzeit in diesem Café habe), führt das Einfrieren der gesamten Client-Erfahrung für einige Sekunden wahrscheinlich zu einer "Diese App ist zum Kotzen" -Erfahrung.

Ich hoffe das hilft dir, es funktioniert bei mir.

getCartGoodsData(id) {

    const goodsIDs: string[] = [];

    return new Promise((resolve) => {
      this.fs.firestore.collection(`users/${id}/cart`).get()
        .then(querySnapshot => {
          querySnapshot.forEach(doc => {
            goodsIDs.push(doc.id);
          });

          const getDocs = goodsIDs.map((id: string) => {
            return this.fs.firestore.collection('goods').doc(id).get()
              .then((docData) => {
                return docData.data();
              });
          });

          Promise.all(getDocs).then((goods: Goods[]) => {
            resolve(goods);
          });
        });
    });
  }