Google Firestore - Comment obtenir un document par plusieurs identifiants en un aller-retour?

Je me demande s'il est possible d'obtenir plusieurs documents par liste d'identifiants en un aller-retour (appel réseau) au Firestore.

si vous êtes dans 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])}`);
* });
*/

Ceci est spécifiquement pour le SDK du serveur

MISE À JOUR: «Cloud Firestore [sdk côté client] prend désormais en charge les requêtes IN!»

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

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

Ils viennent d'annoncer cette fonctionnalité, https://firebase.googleblog.com/2019/11/cloud-firestore-now-supports-in-queries.html .

Vous pouvez maintenant utiliser des requêtes comme, mais sachez que la taille d'entrée ne peut pas être supérieure à 10.

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

Non, pour le moment, il n'existe aucun moyen de regrouper plusieurs demandes de lecture à l'aide du SDK Cloud Firestore et donc aucun moyen de garantir que vous pouvez lire toutes les données à la fois.

Cependant, comme Frank van Puffelen l'a dit dans les commentaires ci-dessus, cela ne signifie pas que la récupération de 3 documents sera 3 fois plus lente que la récupération d'un document. Il est préférable d'effectuer vos propres mesures avant d'arriver à une conclusion ici.

En pratique, vous utiliseriez firestore.getAll comme ça

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

ou avec la syntaxe de promesse

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

Vous pouvez utiliser une fonction comme celle-ci:

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

Il peut être appelé avec un seul identifiant:

getById('collection', 'some_id')

ou un tableau d'identifiants:

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

La meilleure façon de le faire est sûrement d'implémenter la requête réelle de Firestore dans une fonction cloud? Il n'y aurait alors qu'un seul appel aller-retour du client à Firebase, ce qui semble être ce que vous demandez.

Vous voulez vraiment conserver toute votre logique d'accès aux données comme ce côté serveur de toute façon.

En interne, il y aura probablement le même nombre d'appels à Firebase lui-même, mais ils seraient tous via les interconnexions ultra-rapides de Google, plutôt que le réseau externe, et combinés avec le pipeline que Frank van Puffelen a expliqué, vous devriez obtenir d'excellentes performances de cette approche.

Si vous utilisez le flutter, vous pouvez effectuer les opérations suivantes:

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

Cela renverra un Future contenant List<DocumentSnapshot>que vous pourrez itérer à votre guise.

Voici comment vous feriez quelque chose comme ça dans Kotlin avec le SDK Android.
Cela peut ne pas être nécessairement en un aller-retour, mais cela regroupe efficacement le résultat et évite de nombreux rappels imbriqués.

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
}

Notez que la récupération de documents spécifiques est bien meilleure que la récupération de tous les documents et le filtrage du résultat. En effet, Firestore vous facture le jeu de résultats de la requête.

Cela ne semble pas possible dans Firestore pour le moment. Je ne comprends pas pourquoi la réponse d'Alexandre est acceptée, la solution qu'il propose renvoie simplement tous les documents de la collection «utilisateurs».

En fonction de ce que vous devez faire, vous devriez envisager de dupliquer les données pertinentes que vous devez afficher et ne demander un document complet que lorsque cela est nécessaire.

Le mieux que vous puissiez faire est de ne pas utiliser Promise.allcar votre client doit alors attendre .allles lectures avant de continuer.

Répétez les lectures et laissez-les se résoudre indépendamment. Du côté client, cela se résume probablement à l'interface utilisateur ayant plusieurs images du chargeur de progression résolues en valeurs indépendamment. Cependant, c'est mieux que de geler l'ensemble du client jusqu'à .allce que les lectures soient résolues.

Par conséquent, videz immédiatement tous les résultats synchrones dans la vue, puis laissez les résultats asynchrones entrer au fur et à mesure de leur résolution, individuellement. Cela peut sembler insignifiant, mais si votre client a une mauvaise connectivité Internet (comme je l'ai actuellement dans ce café), geler toute l'expérience client pendant plusieurs secondes entraînera probablement une expérience `` cette application est nul ''.

J'espère que cela vous aide, cela fonctionne pour moi.

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