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 cities
.
Web version 9
const coll = collection(db, "cities"); const snapshot = await getCountFromServer(coll); console.log('count: ', snapshot.data().count);
Rapide
let query = db.collection("cities") let countQuery = query.count do { let snapshot = try await countQuery.getAggregation(source: .server) print(snapshot.count) } catch { print(error); }
Objectif c
FIRCollectionReference *query = [self.db collectionWithPath:@"cities"]; [query.count aggregationWithSource:FIRAggregateSourceServer completion:^(FIRAggregateQuerySnapshot *snapshot, NSError *error) { if (error != nil) { NSLog(@"Error fetching count: %@", error); } else { NSLog(@"Cities count: %@", snapshot.count); } }];
Java
Query query = db.collection("cities"); AggregateQuery countQuery = query.count(); countQuery.get(AggregateSource.SERVER).addOnCompleteListener(new OnCompleteListener<AggregateQuerySnapshot>() { @Override public void onComplete(@NonNull Task<AggregateQuerySnapshot> task) { if (task.isSuccessful()) { // Count fetched successfully AggregateQuerySnapshot snapshot = task.getResult(); Log.d(TAG, "Count: " + snapshot.getCount()); } else { Log.d(TAG, "Count failed: ", task.getException()); } } });
Kotlin+KTX
val query = db.collection("cities") val countQuery = query.count() countQuery.get(AggregateSource.SERVER).addOnCompleteListener { task -> if (task.isSuccessful) { // Count fetched successfully val snapshot = task.result Log.d(TAG, "Count: ${snapshot.count}") } else { Log.d(TAG, "Count failed: ", task.getException()) } }
Dart
// Returns number of documents in users collection db.collection("users").count().get().then( (res) => print(res.count), onError: (e) => print("Error completing: $e"), );
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
.
Web version 9
const coll = collection(db, "cities"); const q = query(coll, where("state", "==", "CA")); const snapshot = await getCountFromServer(q); console.log('count: ', snapshot.data().count);
Rapide
let query = db.collection("cities").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
FIRQuery *query = [[self.db collectionWithPath:@"cities"] queryWhereField:@"state" isEqualTo:@"CA"]; [query.count aggregationWithSource:FIRAggregateSourceServer completion:^(FIRAggregateQuerySnapshot *snapshot, NSError *error) { if (error != nil) { NSLog(@"Error fetching count: %@", error); } else { NSLog(@"Cities count: %@", snapshot.count); } }];
Java
Query query = db.collection("cities").whereEqualTo("state", "CA"); AggregateQuery countQuery = query.count(); countQuery.get(AggregateSource.SERVER).addOnCompleteListener(new OnCompleteListener<AggregateQuerySnapshot>() { @Override public void onComplete(@NonNull Task<AggregateQuerySnapshot> task) { if (task.isSuccessful()) { // Count fetched successfully AggregateQuerySnapshot snapshot = task.getResult(); Log.d(TAG, "Count: " + snapshot.getCount()); } else { Log.d(TAG, "Count failed: ", task.getException()); } } });
Kotlin+KTX
val query = db.collection("cities").whereEqualTo("state", "CA") val countQuery = query.count() countQuery.get(AggregateSource.SERVER).addOnCompleteListener { task -> if (task.isSuccessful) { // Count fetched successfully val snapshot = task.result Log.d(TAG, "Count: ${snapshot.count}") } else { Log.d(TAG, "Count failed: ", task.getException()) } }
Dart
// This also works with collectionGroup queries. db.collection("users").where("age", isGreaterThan: 10).count().get().then( (res) => print(res.count), onError: (e) => print("Error completing: $e"), );
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êtescount()
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 erreurDEADLINE_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 documents où le champ 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 .