Contar documentos com consultas de agregação

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

O Cloud Firestore tem suporte à consulta de agregação count(). A consulta 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 número inteiro, de volta ao app, economizando leituras de documentos faturados e bytes transferido, em comparação a uma consulta completa.

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

Usar a agregação `count()`

Consulte os dados de exemplo que configuramos em Como receber 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);count_aggregate_collection.js

Swift

Observação: esse produto não está disponível para destinos watchOS e de clipes de apps.

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

Objective-C

Observação: esse produto não está disponível para destinos watchOS e de clipes de apps.

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

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() considera todos os filtros na consulta e todas as cláusulas limit. Por exemplo, a agregação a seguir retorna uma contagem do número de cidades em que state é 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);count_aggregate_query.js

Swift

Observação: esse produto não está disponível para destinos watchOS e de clipes de apps.

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

Objective-C

Observação: esse produto não está disponível para destinos watchOS e de clipes de apps.

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

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 nas consultas de agregação count() e nas consultas normais que retornam documentos. Em outras palavras, se e somente se as regras permitirem que os clientes executem determinadas consultas de coleta ou de grupo de coleções, os clientes também podem executar a agregação count() nessas consultas. Saiba mais sobre como as regras de segurança do Cloud Firestore interagem com consultas.

Limitações

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

No momento, as consultas de agregação count() só são suportadas pela resposta direta do servidor. As consultas são exibidas apenas pelo back-end do Cloud Firestore, pulando o cache local e as atualizações em buffer. Esse comportamento é idêntico às operações realizadas nas transações do Cloud Firestore. No momento, não é possível usar consultas count() com listeners em tempo real e consultas off-line.
Se uma agregação count() não puder ser resolvida em até 60 segundos, ela retornará um erro DEADLINE_EXCEEDED. O desempenho depende da configuração do índice e do tamanho do conjunto de dados.

Observação: a maioria das consultas é escalonada com base no tamanho do conjunto de resultados, não no conjunto em si. No entanto, as consultas de agregação são escalonadas com base no tamanho do conjunto de dados e no número de entradas de índice verificadas.

Se a operação não puder ser concluída dentro do prazo de 60 segundos, uma alternativa possível é usar contadores para conjuntos grandes de dados.
A agregação count() lê as entradas de índice e conta apenas os campos indexados.
Adicionar uma cláusula OrderBy à consulta limita a contagem às entidades em que a propriedade de ordenação existe.

Preços

O preço de count() depende do número de entradas de índice correspondentes à consulta. Você vai receber a cobrança de um pequeno número de leituras por um grande número de entradas correspondentes.

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

Contar documentos com consultas de agregação

Usar a agregação count()

Web version 9

Swift

Objective-C

Java

Kotlin+KTX

Java

Java

Node.js

Web version 9

Swift

Objective-C

Java

Kotlin+KTX

Java

Java

Node.js

Limitações

Preços

Usar a agregação `count()`