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

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

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

Firestore est compatible avec la requête d'agrégation count(). count() permet de déterminer le nombre de documents dans une collection ou une requête. Le serveur calcule le nombre et transmet uniquement le résultat, un entier unique, à votre application, ce qui permet d'économiser à la fois les lectures de documents facturés et 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 et moyenne taille sont effectuées dans les 20 à 40 ms, bien que la latence augmente en fonction du nombre d'éléments comptabilisés.

Utiliser l'agrégation count()

Consultez les 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 cities.

Version Web 9

const coll = collection(db, "cities");
const snapshot = await getCountFromServer(coll);
console.log('count: ', snapshot.data().count);
    
Swift
let collection = db.collection("cities")
let countQuery = collection.count
do {
  let snapshot = try await countQuery.getAggregation(source: .server)
  print(snapshot.count)
} catch {
  print(error);
}
      
Objective-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);
    }
  }
];
      
Java
Android
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());
  }
});
      
Kotlin + KTX
Android
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");
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 limit. Par exemple, l'agrégation suivante renvoie le nombre de villes où state est égal à CA.

Version Web 9

const coll = collection(db, "cities");
const query_ = query(coll, where('state', '==', 'CA'));
const snapshot = await getCountFromServer(query_);
console.log('count: ', snapshot.data().count);
    
Swift
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);
}
      
Objective-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);
    }
  }
];
      
Java
Android
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());
  }
});
      
Kotlin + KTX
Android
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");
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é Firestore fonctionnent de la même manière pour les requêtes d'agrégation count() et pour 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, ils peuvent également effectuer l'agrégation count() sur ces requêtes. En savoir plus sur l'interaction des règles de sécurité Firestore avec les requêtes

Limites

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

  • Les requêtes d'agrégation count() ne sont actuellement acceptées que via la réponse directe du serveur. Les requêtes ne sont diffusées que par le backend Firestore, ce qui ignore le cache local et les mises à jour en mémoire tampon. Ce comportement est identique aux opérations effectuées dans les transactions Firestore. Actuellement, vous ne pouvez pas utiliser de requêtes count() avec des écouteurs en temps réel et des requêtes hors connexion.

  • 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 terminée dans le délai de 60 secondes, une solution de contournement possible consiste à utiliser des compteurs pour les ensembles de données volumineux.

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

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

Tarifs

La tarification de count() dépend du nombre d'entrées d'index mises en correspondance par la requête. Un nombre limité de lectures vous est facturé pour un grand nombre d'entrées correspondantes.

Consultez des informations tarifaires plus détaillées.