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 com consultas de agregação

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Uma consulta de agregação processa os dados de várias entradas de índice para retornar um único valor de resumo.

O Cloud Firestore é compatível com a consulta de agregação count() . count() permite determinar o número de documentos em uma coleção ou consulta. O servidor calcula a contagem e transmite apenas o resultado, um único número inteiro, de volta ao seu aplicativo, economizando nas leituras de documentos faturados e nos bytes transferidos, em comparação com a execução da consulta completa.

As consultas de agregação dependem da configuração de índice existente que suas consultas já usam e são dimensionadas proporcionalmente ao número de entradas de índice verificadas. Isso significa que as agregações de conjuntos de dados de pequeno a médio porte são executadas em 20 a 40 ms, embora a latência aumente com o número de itens contados.

Use a agregação count()

Consulte os dados de exemplo que configuramos em Obtendo dados .

A agregação count() a seguir retorna o número total de cidades na coleção 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);
}
      
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);
    }
  }
];
      

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);
      

A agregação count() leva em consideração quaisquer filtros na consulta e quaisquer cláusulas de limit . Por exemplo, a agregação a seguir retorna uma contagem do número de cidades em que state é 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);
}
      
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);
    }
  }
];
      

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);
      

As regras de segurança do Cloud Firestore funcionam da mesma forma em consultas de agregação count() e em consultas normais que retornam documentos. Em outras palavras, se e somente se suas regras permitirem que os clientes executem determinadas consultas de coleta ou grupo de coleta, os clientes também poderão executar a agregação count() nessas consultas. Saiba mais sobre como as regras de segurança do Cloud Firestore interagem com as consultas .

Limitações

Observe as seguintes limitações na consulta de agregação count() :

  • Atualmente, as consultas de agregação count() são suportadas apenas por meio de resposta direta do servidor. As consultas são atendidas apenas pelo back-end do Cloud Firestore, ignorando o cache local e quaisquer atualizações em buffer. Esse comportamento é idêntico às operações realizadas nas transações do Cloud Firestore . No momento, você não pode usar consultas count() com ouvintes em tempo real e consultas offline.

  • Se uma agregação count() não puder ser resolvida em 60 segundos, ela retornará um erro DEADLINE_EXCEEDED . O desempenho depende da configuração do índice e do tamanho do conjunto de dados.

    Se a operação não puder ser concluída dentro do prazo de 60 segundos, uma solução possível é usar contadores para grandes conjuntos de dados.

  • A agregação count() lê as entradas do índice e conta apenas os campos indexados.

  • Adicionar uma cláusula OrderBy à consulta limita a contagem às entidades nas quais existe a propriedade de classificação.

Preços

O preço de count() depende do número de entradas de índice correspondidas pela consulta. Você é cobrado por um pequeno número de leituras para um grande número de entradas correspondentes.

Veja informações de preços mais detalhadas.