Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Compter les documents avec des requêtes d'agrégation

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Une requête d'agrégation traite les données de plusieurs entrées d'index pour renvoyer une seule valeur récapitulative.

Cloud Firestore prend en charge la requête d'agrégation count() . count() vous permet de déterminer le nombre de documents dans une collection ou une requête. Le serveur calcule le nombre et ne transmet que le résultat, un seul entier, à votre application, ce qui permet d'économiser à la fois sur les lectures de documents facturés et sur les octets transférés, par rapport à l'exécution de la requête complète.

Les requêtes d'agrégation reposent sur la configuration d'index existante que vos requêtes utilisent déjà et évoluent proportionnellement au nombre d'entrées d'index analysées. Cela signifie que les agrégations d'ensembles de données de petite à moyenne taille s'exécutent en 20 à 40 ms, bien que la latence augmente avec le nombre d'éléments comptés.

Utiliser l'agrégation count()

Reportez-vous aux exemples de données que nous avons configurés dans Obtenir des données .

L'agrégation count() suivante renvoie le nombre total de villes dans la collection de cities .

Web version 9

const coll = collection(db, "cities");
const snapshot = await getCountFromServer(coll);
console.log('count: ', snapshot.data().count);
    
Rapide
let collection = db.collection("cities")
let countQuery = collection.count
do {
  let snapshot = try await countQuery.getAggregation(source: .server)
  print(snapshot.count)
} catch {
  print(error);
}
      
Objectif c
FIRCollectionReference* collection = [db collectionWithPath:@"cities"];
[collection.count
  aggregationWithSource:FIRAggregateSourceServer
  completion:^(FIRAggregateQuerySnapshot *snapshot, NSError *error) {
    if (error == nil) {
        NSLog(@"Cities count: %@", snapshot.count);
    } else {
        NSLog(@"Error fetching count: %@", error);
    }
  }
];
      

Kotlin+KTX

val collection = db.collection("cities")
val countQuery = collection.count()
countQuery.get(AggregateSource.SERVER).addOnCompleteListener { task ->
  if (task.isSuccessful) {
    val snapshot = task.result
    Log.d(TAG, "Count: ${snapshot.count}")
  } else {
    Log.d(TAG, "Count failed: ", task.getException())
  }
}
      

Java

CollectionReference collection = db.collection("cities");
AggregateQuery countQuery = collection.count();
countQuery.get(AggregateSource.SERVER).addOnCompleteListener(task -> {
  if (task.isSuccessful()) {
    AggregateQuerySnapshot snapshot = task.getResult();
    Log.d(TAG, "Count: " + snapshot.getCount());
  } else {
    Log.d(TAG, "Count failed: ", task.getException());
  }
});
      
Java
CollectionReference collection = db.collection("cities");
AggregateQuerySnapshot snapshot = collection.count().get().get();
System.out.println("Count: " + snapshot.getCount());
      
Node.js
const collectionRef = db.collection('cities');
const snapshot = await collectionRef.count().get();
console.log(snapshot.data().count);
      

L'agrégation count() prend en compte tous les filtres de la requête et toutes les clauses de limit . Par exemple, l'agrégation suivante renvoie le nombre de villes où state est égal à CA .

Web version 9

const coll = collection(db, "cities");
const query_ = query(coll, where('state', '==', 'CA'));
const snapshot = await getCountFromServer(query_);
console.log('count: ', snapshot.data().count);
    
Rapide
let collection = db.collection("cities")
let query = collection.whereField("state", isEqualTo: "CA")
let countQuery = query.count
do {
  let snapshot = try await countQuery.getAggregation(source: .server)
  print(snapshot.count)
} catch {
  print(error);
}
      
Objectif c
FIRCollectionReference* collection = [db collectionWithPath:@"cities"];
FIRQuery* query = [collection queryWhereField:@"state" isEqualTo:@"CA"];
[query.count
  aggregationWithSource:FIRAggregateSourceServer
  completion:^(FIRAggregateQuerySnapshot *snapshot, NSError *error) {
    if (error == nil) {
        NSLog(@"Cities count: %@", snapshot.count);
    } else {
        NSLog(@"Error fetching count: %@", error);
    }
  }
];
      

Kotlin+KTX

val collection = db.collection("cities")
val query = collection.whereEqualTo("state", "CA")
val countQuery = query.count()
countQuery.get(AggregateSource.SERVER).addOnCompleteListener { task ->
  if (task.isSuccessful) {
    val snapshot = task.result
    Log.d(TAG, "Count: ${snapshot.count}")
  } else {
    Log.d(TAG, "Count failed: ", task.getException())
  }
}
      

Java

CollectionReference collection = db.collection("cities");
Query query = collection.whereEqualTo("state", "CA");
AggregateQuery countQuery = query.count();
countQuery.get(AggregateSource.SERVER).addOnCompleteListener(task -> {
  if (task.isSuccessful()) {
    AggregateQuerySnapshot snapshot = task.getResult();
    Log.d(TAG, "Count: " + snapshot.getCount());
  } else {
    Log.d(TAG, "Count failed: ", task.getException());
  }
});
      
Java
CollectionReference collection = db.collection("cities");
Query query = collection.whereEqualTo("state", "CA");
AggregateQuerySnapshot snapshot = query.count().get().get();
System.out.println("Count: " + snapshot.getCount());
      
Node.js
const collectionRef = db.collection('cities');
const query = collectionRef.where('state', '==', 'CA');
const snapshot = await query.count().get();
console.log(snapshot.data().count);
      

Les règles de sécurité Cloud Firestore fonctionnent de la même manière sur les requêtes d'agrégation count() que sur les requêtes normales qui renvoient des documents. En d'autres termes, si et seulement si vos règles autorisent les clients à exécuter certaines requêtes de collection ou de groupe de collections, les clients peuvent également effectuer l'agrégation count() sur ces requêtes. En savoir plus sur la manière dont les règles de sécurité Cloud Firestore interagissent avec les requêtes .

Limites

Notez les limitations suivantes sur la requête d'agrégation count() :

  • Les requêtes d'agrégation count() ne sont actuellement prises en charge que via la réponse directe du serveur. Les requêtes sont traitées uniquement par le backend Cloud Firestore, en ignorant le cache local et toutes les mises à jour mises en mémoire tampon. Ce comportement est identique aux opérations effectuées dans les transactions Cloud Firestore . Vous ne pouvez pas actuellement utiliser les requêtes count() avec des écouteurs en temps réel et des requêtes hors ligne.

  • Si une agrégation count() ne peut pas être résolue dans les 60 secondes, elle renvoie une erreur DEADLINE_EXCEEDED . Les performances dépendent de la configuration de votre index et de la taille de l'ensemble de données.

    Si l'opération ne peut pas être effectuée dans le délai de 60 secondes, une solution de contournement possible consiste à utiliser des compteurs pour les grands ensembles de données.

  • L'agrégation count() lit les entrées d'index et ne compte que les champs indexés.

  • L'ajout d'une clause OrderBy à la requête limite le nombre aux entités où la propriété de tri existe.

Tarification

Le prix de count() dépend du nombre d'entrées d'index correspondant à la requête. Un petit nombre de lectures vous est facturé pour un grand nombre d'entrées correspondantes.

Voir les informations de tarification plus détaillées .