Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Dokumente mit Aggregationsabfragen zählen

Eine Aggregationsabfrage verarbeitet die Daten aus mehreren Indexeinträgen, um einen einzelnen Zusammenfassungswert zurückzugeben.

Firestore unterstützt die Aggregationsabfrage count(). Mit count() können Sie die Anzahl der Dokumente in einer Sammlung oder Abfrage ermitteln. Der Server berechnet die Anzahl und sendet nur das Ergebnis, eine einzige Ganzzahl, zurück an Ihre Anwendung. Dadurch sparen Sie im Vergleich zur vollständigen Abfrage sowohl die in Rechnung gestellten Dokumentlesevorgänge als auch die übertragenen Byte.

Aggregationsabfragen basieren auf der bereits von Ihren Abfragen verwendeten Indexkonfiguration und werden proportional zur Anzahl der gescannten Indexeinträge skaliert. Das bedeutet, dass Zusammenfassungen kleiner bis mittlerer Datensätze innerhalb von 20 bis 40 ms funktionieren, obwohl die Latenz mit der Anzahl der gezählten Elemente zunimmt.

Aggregation count() verwenden

Sehen Sie sich dazu die Beispieldaten unter Daten abrufen an.

Die folgende Aggregation count() gibt die Gesamtzahl der Städte in der Sammlung cities zurück.

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

Bei der Aggregation count() werden alle Filter für die Abfrage und alle limit-Klauseln berücksichtigt. Die folgende Aggregation gibt beispielsweise die Anzahl der Städte zurück, in denen state gleich CA ist.

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

Firestore-Sicherheitsregeln funktionieren bei count()-Aggregationsabfragen genauso wie bei normalen Abfragen, die Dokumente zurückgeben. Mit anderen Worten: Wenn Ihre Regeln es Clients ermöglichen, bestimmte Sammlungs- oder Sammlungsgruppenabfragen auszuführen, können sie auch die count()-Aggregation für diese Abfragen ausführen. Weitere Informationen zur Interaktion von Firestore-Sicherheitsregeln mit Abfragen

Beschränkungen

Beachten Sie die folgenden Einschränkungen bei der Aggregationsabfrage count():

  • count()-Aggregationsabfragen werden derzeit nur über direkte Serverantwort unterstützt. Abfragen werden nur vom Firestore-Back-End ausgeführt und überspringen den lokalen Cache und alle zwischengespeicherten Updates. Dieses Verhalten ist identisch mit Vorgängen, die in Firestore-Transaktionen ausgeführt werden. Sie können derzeit keine count()-Abfragen mit Echtzeit-Listenern und Offlineabfragen verwenden.

  • Wenn eine count()-Aggregation nicht innerhalb von 60 Sekunden aufgelöst werden kann, wird der Fehler DEADLINE_EXCEEDED zurückgegeben. Die Leistung hängt von der Indexkonfiguration und der Größe des Datasets ab.

    Wenn der Vorgang nicht innerhalb der 60-Sekunden-Frist abgeschlossen werden kann, können Sie das Problem umgehen, indem Sie für große Datasets Zähler verwenden.

  • Die Aggregation count() liest aus Indexeinträgen und zählt nur indexierte Felder.

  • Wenn Sie der Abfrage eine OrderBy-Klausel hinzufügen, wird die Anzahl auf die Entitäten beschränkt, in denen das Sortierattribut vorhanden ist.

Preise

Die Preise für count() hängen von der Anzahl der Indexeinträge ab, die der Abfrage entsprechen. Bei einer großen Anzahl von übereinstimmenden Einträgen wird Ihnen eine geringe Anzahl von Lesevorgängen in Rechnung gestellt.

Weitere Informationen zu den Preisen