Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Conteggio documenti con query di aggregazione

Una query di aggregazione elabora i dati di più voci di indice per restituire un singolo valore di riepilogo.

Firestore supporta la query di aggregazione count(). count() consente di determinare il numero di documenti in una raccolta o query. Il server calcola il conteggio e trasmette solo il risultato, un singolo numero intero, di nuovo alla tua app, risparmiando sia sulle letture dei documenti fatturati che sui byte trasferiti, rispetto all'esecuzione della query completa.

Le query di aggregazione si basano sulla configurazione degli indici esistente che le query già utilizzano e scalano in modo proporzionale al numero di voci di indice scansionate. Ciò significa che le aggregazioni di set di dati di piccole e medie dimensioni vengono eseguite entro 20-40 ms, anche se la latenza aumenta con il numero di elementi conteggiati.

Utilizzare l'aggregazione count()

Fai riferimento ai dati di esempio che abbiamo configurato in Ottenere i dati.

L'aggregazione count() seguente restituisce il numero totale di città nella raccolta cities.

Versione web 9

const coll = collection(db, "cities");
const snapshot = await getCountFromServer(coll);
console.log('count: ', snapshot.data().count);
    
Swift
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);
    }
  }
];
      
Java
Android
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());
  }
});
      
Kotlin+KTX
Android
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");
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'aggregazione count() prende in considerazione qualsiasi filtro nella query e le clausole limit. Ad esempio, la seguente aggregazione restituisce un conteggio del numero di città in cui state è uguale a CA.

Versione web 9

const coll = collection(db, "cities");
const query_ = query(coll, where('state', '==', 'CA'));
const snapshot = await getCountFromServer(query_);
console.log('count: ', snapshot.data().count);
    
Swift
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);
    }
  }
];
      
Java
Android
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());
  }
});
      
Kotlin+KTX
Android
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");
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);
      

Le regole di sicurezza di Firestore funzionano allo stesso modo nelle query di aggregazione di count() e nelle query normali che restituiscono documenti. In altre parole, se e solo se le regole consentono ai client di eseguire determinate query della raccolta o del gruppo di raccolte, i clienti possono anche eseguire l'aggregazione count() in tali query. Scopri di più su come le regole di sicurezza Firestore interagiscono con le query.

Limitazioni

Tieni presente le seguenti limitazioni per la query di aggregazione di count():

  • count() query di aggregazione sono attualmente supportate solo tramite risposta diretta del server. Le query vengono pubblicate solo dal backend Firestore, ignorando la cache locale e gli aggiornamenti presenti nel buffer. Questo comportamento è identico a quello delle operazioni eseguite all'interno delle transazioni di Firestore. Al momento non puoi utilizzare le query count() con ascoltatori in tempo reale e query offline.

  • Se l'aggregazione di count() non riesce a risolvere entro 60 secondi, restituisce un errore DEADLINE_EXCEEDED. Le prestazioni dipendono dalla configurazione dell'indice e dalle dimensioni del set di dati.

    Se l'operazione non può essere completata entro i 60 secondi, una possibile soluzione alternativa è utilizzare i contatori per set di dati di grandi dimensioni.

  • L'aggregazione count() legge dalle voci dell'indice e conteggia solo i campi indicizzati.

  • L'aggiunta di una clausola OrderBy alla query limita il conteggio alle entità in cui esiste la proprietà di ordinamento.

Prezzi

I prezzi di count() dipendono dal numero di voci di indice corrispondenti alla query. Ti viene addebitato un numero ridotto di letture per un numero elevato di voci corrispondenti.

Consulta informazioni sui prezzi più dettagliate.