获取我们在 Firebase 峰会上发布的所有信息,了解 Firebase 可如何帮助您加快应用开发速度并满怀信心地运行应用。了解详情

Conta documenti con query di aggregazione

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

Cloud 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, 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 dell'indice esistente già utilizzata dalle query e si adattano proporzionalmente al numero di voci di indice analizzate. Ciò significa che le aggregazioni di set di dati di piccole e medie dimensioni vengono eseguite entro 20-40 ms, sebbene la latenza aumenti con il numero di elementi contati.

Utilizzare l'aggregazione count()

Fai riferimento ai dati di esempio che abbiamo impostato in Recupero dati .

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

Web version 9

const coll = collection(db, "cities");
const snapshot = await getCountFromServer(coll);
console.log('count: ', snapshot.data().count);
    
Rapido
let collection = db.collection("cities")
let countQuery = collection.count
do {
  let snapshot = try await countQuery.getAggregation(source: .server)
  print(snapshot.count)
} catch {
  print(error);
}
      
Obiettivo-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());
  }
});
      
Giava
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() tiene conto di eventuali filtri sulla query e di eventuali clausole limit . Ad esempio, la seguente aggregazione restituisce un conteggio del numero di città in cui state è uguale 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);
    
Rapido
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);
}
      
Obiettivo-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());
  }
});
      
Giava
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 Cloud Firestore funzionano allo stesso modo sulle query di aggregazione count() come sulle normali query che restituiscono documenti. In altre parole, se e solo se le tue regole consentono ai client di eseguire determinate query di raccolte o gruppi di raccolte, i client possono anche eseguire l'aggregazione count() su tali query. Scopri di più su come le regole di sicurezza di Cloud Firestore interagiscono con le query .

Limitazioni

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

  • Le query di aggregazione count() sono attualmente supportate solo tramite risposta diretta del server. Le query vengono servite solo dal back-end di Cloud Firestore, saltando la cache locale ed eventuali aggiornamenti bufferizzati. Questo comportamento è identico alle operazioni eseguite all'interno delle transazioni di Cloud Firestore . Al momento non è possibile utilizzare le query count() con i listener in tempo reale e le query offline.

  • Se un'aggregazione count() non può essere risolta 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 la scadenza dei 60 secondi, una possibile soluzione consiste nell'utilizzare contatori per insiemi di dati di grandi dimensioni.

  • L'aggregazione count() legge dalle voci di indice e conta 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

Il prezzo per count() dipende dal numero di voci di indice corrispondenti alla query. Ti viene addebitato un piccolo numero di letture per un numero elevato di voci corrispondenti.

Visualizza informazioni più dettagliate sui prezzi .