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 consultascount()
com ouvintes em tempo real e consultas offline.Se uma agregação
count()
não puder ser resolvida em 60 segundos, ela retornará um erroDEADLINE_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.