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

Contar documentos con consultas de agregación

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Una consulta de agregación procesa los datos de varias entradas de índice para devolver un solo valor de resumen.

Cloud Firestore admite la consulta de agregación count() . count() le permite determinar la cantidad de documentos en una colección o consulta. El servidor calcula el conteo y transmite solo el resultado, un solo número entero, de vuelta a su aplicación, ahorrando lecturas de documentos facturados y bytes transferidos, en comparación con la ejecución de la consulta completa.

Las consultas de agregación se basan en la configuración de índice existente que sus consultas ya usan y escalan proporcionalmente al número de entradas de índice escaneadas. Esto significa que las agregaciones de conjuntos de datos de tamaño pequeño a mediano se realizan en 20 a 40 ms, aunque la latencia aumenta con la cantidad de elementos contados.

Usa la agregación count()

Consulte los datos de ejemplo que configuramos en Obtener datos .

La siguiente agregación count() devuelve el número total de ciudades en la colección de cities .

Web version 9

const coll = collection(db, "cities");
const snapshot = await getCountFromServer(coll);
console.log('count: ', snapshot.data().count);
    
Rápido
let collection = db.collection("cities")
let countQuery = collection.count
do {
  let snapshot = try await countQuery.getAggregation(source: .server)
  print(snapshot.count)
} catch {
  print(error);
}
      
C objetivo
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());
      
Nodo.js
const collectionRef = db.collection('cities');
const snapshot = await collectionRef.count().get();
console.log(snapshot.data().count);
      

La agregación count() tiene en cuenta los filtros de la consulta y las cláusulas de limit . Por ejemplo, la siguiente agregación devuelve un recuento de la cantidad de ciudades donde state es igual a 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);
    
Rápido
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);
}
      
C objetivo
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());
      
Nodo.js
const collectionRef = db.collection('cities');
const query = collectionRef.where('state', '==', 'CA');
const snapshot = await query.count().get();
console.log(snapshot.data().count);
      

Las reglas de seguridad de Cloud Firestore funcionan igual en las consultas de agregación count() que en las consultas normales que devuelven documentos. En otras palabras, si y solo si sus reglas permiten a los clientes ejecutar ciertas consultas de colección o grupo de colección, los clientes también pueden realizar la agregación count() en esas consultas. Obtenga más información sobre cómo las reglas de seguridad de Cloud Firestore interactúan con las consultas .

Limitaciones

Tenga en cuenta las siguientes limitaciones en la consulta de agregación count() :

  • Las consultas de agregación count() actualmente solo se admiten a través de la respuesta directa del servidor. Las consultas son atendidas solo por el backend de Cloud Firestore, omitiendo el caché local y cualquier actualización almacenada en búfer. Este comportamiento es idéntico a las operaciones realizadas dentro de las transacciones de Cloud Firestore . Actualmente no puede usar consultas de count() con oyentes en tiempo real y consultas fuera de línea.

  • Si una agregación count() no puede resolverse en 60 segundos, devuelve un error DEADLINE_EXCEEDED . El rendimiento depende de la configuración de su índice y del tamaño del conjunto de datos.

    Si la operación no se puede completar dentro del plazo de 60 segundos, una posible solución es usar contadores para grandes conjuntos de datos.

  • La agregación count() lee las entradas del índice y cuenta solo los campos indexados.

  • Agregar una cláusula OrderBy a la consulta limita el recuento a las entidades donde existe la propiedad de clasificación.

Precios

El precio de count() depende del número de entradas de índice que coincidan con la consulta. Se le cobra una pequeña cantidad de lecturas por una gran cantidad de entradas coincidentes.

Ver información de precios más detallada.