Catch up on highlights from Firebase at Google I/O 2023. Learn more

Compter les 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.

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 modular API

const coll = collection(db, "cities");
const snapshot = await getCountFromServer(coll);
console.log('count: ', snapshot.data().count);
count_aggregate_collection.js
Rapide
Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
let query = db.collection("cities")
let countQuery = query.count
do {
    let snapshot = try await countQuery.getAggregation(source: .server)
    print(snapshot.count)
} catch {
    print(error)
}
ViewController.swift
Objectif c
Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
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);
    }
}];
ViewController.m

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());
        }
    }
});
DocSnippets.java

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())
    }
}
DocSnippets.kt

Dart

// Returns number of documents in users collection
db.collection("users").count().get().then(
      (res) => print(res.count),
      onError: (e) => print("Error completing: $e"),
    );
firestore.dart
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 modular API

const coll = collection(db, "cities");
const q = query(coll, where("state", "==", "CA"));
const snapshot = await getCountFromServer(q);
console.log('count: ', snapshot.data().count);
count_aggregate_query.js
Rapide
Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
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)
}
ViewController.swift
Objectif c
Remarque : ce produit n'est pas disponible sur les cibles watchOS et App Clip.
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);
    }
}];
ViewController.m

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());
        }
    }
});
DocSnippets.java

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())
    }
}
DocSnippets.kt

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"),
    );
firestore.dart
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 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 .