Google Firestore: come ottenere documenti da più ID in un unico viaggio di andata e ritorno?

Mi chiedo se sia possibile ottenere più documenti per elenco di ID in un viaggio di andata e ritorno (chiamata di rete) al Firestore.

se sei all'interno di Node:

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])}`);
* });
*/

Questo è specifico per l'SDK del server

AGGIORNAMENTO: "Cloud Firestore [sdk lato client] ora supporta le query IN!"

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

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

Hanno appena annunciato questa funzionalità, https://firebase.googleblog.com/2019/11/cloud-firestore-now-supports-in-queries.html .

Ora puoi usare query come, ma tieni presente che la dimensione dell'input non può essere maggiore di 10.

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

No, al momento non è possibile inviare in batch più richieste di lettura utilizzando Cloud Firestore SDK e quindi non è possibile garantire che sia possibile leggere tutti i dati contemporaneamente.

Tuttavia, come ha detto Frank van Puffelen nei commenti sopra, ciò non significa che il recupero di 3 documenti sarà 3 volte più lento del recupero di un documento. È meglio eseguire le proprie misurazioni prima di giungere a una conclusione qui.

In pratica useresti firestore.getAll in questo modo

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()))
}

o con sintassi promettente

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())))
}

Potresti usare una funzione come questa:

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

Può essere chiamato con un unico ID:

getById('collection', 'some_id')

o un array di ID:

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

Sicuramente il modo migliore per farlo è implementare la query effettiva di Firestore in una funzione Cloud? Ci sarebbe quindi solo una singola chiamata di andata e ritorno dal client a Firebase, che sembra essere quello che stai chiedendo.

Vuoi davvero mantenere comunque tutta la tua logica di accesso ai dati come questo lato server.

Internamente ci sarà probabilmente lo stesso numero di chiamate alla stessa Firebase, ma sarebbero tutte attraverso le interconnessioni super veloci di Google, piuttosto che la rete esterna, e combinate con il pipelining che ha spiegato Frank van Puffelen, dovresti ottenere prestazioni eccellenti da questo approccio.

Se stai usando flutter, puoi fare quanto segue:

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

Questo restituirà un futuro contenente List<DocumentSnapshot>che puoi iterare come ti senti in forma.

Ecco come faresti qualcosa di simile in Kotlin con Android SDK.
Potrebbe non essere necessariamente in un round trip, ma raggruppa efficacemente il risultato ed evita molti callback nidificati.

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
}

Nota che il recupero di documenti specifici è molto meglio che il recupero di tutti i documenti e il filtraggio del risultato. Questo perché Firestore ti addebita il set di risultati della query.

Questo non sembra essere possibile in Firestore al momento. Non capisco perché la risposta di Alexander venga accettata, la soluzione che propone restituisce solo tutti i documenti nella raccolta "utenti".

A seconda di ciò che devi fare, dovresti cercare di duplicare i dati rilevanti che devi visualizzare e richiedere un documento completo solo quando necessario.

Il meglio che puoi fare è non usarlo Promise.allcome client, quindi deve attendere .allle letture prima di procedere.

Ripeti le letture e lascia che si risolvano in modo indipendente. Sul lato client, questo probabilmente si riduce all'interfaccia utente con diverse immagini del caricatore di avanzamento che si risolvono in valori in modo indipendente. Tuttavia, è meglio che congelare l'intero client fino a quando .allle letture non si risolvono.

Pertanto, scarica immediatamente tutti i risultati sincroni nella vista, quindi lascia che i risultati asincroni arrivino mentre si risolvono, individualmente. Questa può sembrare una distinzione insignificante, ma se il tuo client ha una scarsa connettività Internet (come quella che ho attualmente in questo bar), il congelamento dell'intera esperienza del cliente per diversi secondi risulterà probabilmente in un'esperienza `` questa app fa schifo ''.

Spero che questo ti aiuti, funziona per me.

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);
          });
        });
    });
  }