Mit Abfragen in Cloud Firestore können Sie Dokumente in großen Sammlungen finden. Um einen Einblick in die Eigenschaften der gesamten Sammlung zu erhalten, können Sie Daten über eine Sammlung hinweg aggregieren.
Sie können Daten entweder zum Lese- oder zum Schreibzeitpunkt aggregieren:
Lesezeitaggregationen berechnen ein Ergebnis zum Zeitpunkt der Anfrage. Cloud Firestore unterstützt die Aggregationsabfragen
count(),sum()undaverage()zum Lesezeitpunkt. Lesezeit-Aggregationsabfragen lassen sich einfacher zu Ihrer App hinzufügen als Schreibzeit-Aggregationsabfragen. Weitere Informationen zu Aggregationsabfragen finden Sie unter Daten mit Aggregationsabfragen zusammenfassen .Schreibzeitaggregationen berechnen jedes Mal ein Ergebnis, wenn die App einen relevanten Schreibvorgang ausführt. Die Implementierung von Aggregationen zur Schreibzeit ist aufwändiger, Sie können sie jedoch aus einem der folgenden Gründe anstelle von Aggregationen zur Lesezeit verwenden:
- Sie möchten das Aggregationsergebnis für Echtzeitaktualisierungen abhören. Die Aggregationsabfragen
count(),sum()undaverage()unterstützen keine Echtzeitaktualisierungen. - Sie möchten das Aggregationsergebnis in einem clientseitigen Cache speichern. Die Aggregationsabfragen
count(),sum()undaverage()unterstützen kein Caching. - Sie aggregieren Daten aus Zehntausenden Dokumenten für jeden Ihrer Benutzer und berücksichtigen die Kosten. Bei einer geringeren Anzahl von Dokumenten kosten Lesezeitaggregationen weniger. Bei einer großen Anzahl von Dokumenten in einer Aggregation können Aggregationen zur Schreibzeit weniger kosten.
- Sie möchten das Aggregationsergebnis für Echtzeitaktualisierungen abhören. Die Aggregationsabfragen
Sie können eine Schreibzeitaggregation entweder mithilfe einer clientseitigen Transaktion oder mit Cloud Functions implementieren. In den folgenden Abschnitten wird beschrieben, wie Schreibzeitaggregationen implementiert werden.
Lösung: Schreibzeitaggregation mit einer clientseitigen Transaktion
Erwägen Sie eine lokale Empfehlungs-App, die Benutzern hilft, tolle Restaurants zu finden. Die folgende Abfrage ruft alle Bewertungen für ein bestimmtes Restaurant ab:
Netz
db.collection("restaurants")
.doc("arinell-pizza")
.collection("ratings")
.get();Schnell
do {
let snapshot = try await db.collection("restaurants")
.document("arinell-pizza")
.collection("ratings")
.getDocuments()
print(snapshot)
} catch {
print(error)
}Ziel c
FIRQuery *query = [[[self.db collectionWithPath:@"restaurants"]
documentWithPath:@"arinell-pizza"] collectionWithPath:@"ratings"];
[query getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot,
NSError * _Nullable error) {
// ...
}];Kotlin+KTX
db.collection("restaurants")
.document("arinell-pizza")
.collection("ratings")
.get()Java
db.collection("restaurants")
.document("arinell-pizza")
.collection("ratings")
.get();Anstatt alle Bewertungen abzurufen und dann aggregierte Informationen zu berechnen, können wir diese Informationen im Restaurantdokument selbst speichern:
Netz
var arinellDoc = {
name: 'Arinell Pizza',
avgRating: 4.65,
numRatings: 683
};Schnell
struct Restaurant {
let name: String
let avgRating: Float
let numRatings: Int
}
let arinell = Restaurant(name: "Arinell Pizza", avgRating: 4.65, numRatings: 683)Ziel c
@interface FIRRestaurant : NSObject
@property (nonatomic, readonly) NSString *name;
@property (nonatomic, readonly) float averageRating;
@property (nonatomic, readonly) NSInteger ratingCount;
- (instancetype)initWithName:(NSString *)name
averageRating:(float)averageRating
ratingCount:(NSInteger)ratingCount;
@end
@implementation FIRRestaurant
- (instancetype)initWithName:(NSString *)name
averageRating:(float)averageRating
ratingCount:(NSInteger)ratingCount {
self = [super init];
if (self != nil) {
_name = name;
_averageRating = averageRating;
_ratingCount = ratingCount;
}
return self;
}
@endKotlin+KTX
data class Restaurant(
// default values required for use with "toObject"
internal var name: String = "",
internal var avgRating: Double = 0.0,
internal var numRatings: Int = 0,
)val arinell = Restaurant("Arinell Pizza", 4.65, 683)Java
public class Restaurant {
String name;
double avgRating;
int numRatings;
public Restaurant(String name, double avgRating, int numRatings) {
this.name = name;
this.avgRating = avgRating;
this.numRatings = numRatings;
}
}Restaurant arinell = new Restaurant("Arinell Pizza", 4.65, 683);Um diese Aggregationen konsistent zu halten, müssen sie jedes Mal aktualisiert werden, wenn der Untersammlung eine neue Bewertung hinzugefügt wird. Eine Möglichkeit, Konsistenz zu erreichen, besteht darin, das Hinzufügen und Aktualisieren in einer einzigen Transaktion durchzuführen:
Netz
function addRating(restaurantRef, rating) {
// Create a reference for a new rating, for use inside the transaction
var ratingRef = restaurantRef.collection('ratings').doc();
// In a transaction, add the new rating and update the aggregate totals
return db.runTransaction((transaction) => {
return transaction.get(restaurantRef).then((res) => {
if (!res.exists) {
throw "Document does not exist!";
}
// Compute new number of ratings
var newNumRatings = res.data().numRatings + 1;
// Compute new average rating
var oldRatingTotal = res.data().avgRating * res.data().numRatings;
var newAvgRating = (oldRatingTotal + rating) / newNumRatings;
// Commit to Firestore
transaction.update(restaurantRef, {
numRatings: newNumRatings,
avgRating: newAvgRating
});
transaction.set(ratingRef, { rating: rating });
});
});
}Schnell
func addRatingTransaction(restaurantRef: DocumentReference, rating: Float) async {
let ratingRef: DocumentReference = restaurantRef.collection("ratings").document()
do {
let _ = try await db.runTransaction({ (transaction, errorPointer) -> Any? in
do {
let restaurantDocument = try transaction.getDocument(restaurantRef).data()
guard var restaurantData = restaurantDocument else { return nil }
// Compute new number of ratings
let numRatings = restaurantData["numRatings"] as! Int
let newNumRatings = numRatings + 1
// Compute new average rating
let avgRating = restaurantData["avgRating"] as! Float
let oldRatingTotal = avgRating * Float(numRatings)
let newAvgRating = (oldRatingTotal + rating) / Float(newNumRatings)
// Set new restaurant info
restaurantData["numRatings"] = newNumRatings
restaurantData["avgRating"] = newAvgRating
// Commit to Firestore
transaction.setData(restaurantData, forDocument: restaurantRef)
transaction.setData(["rating": rating], forDocument: ratingRef)
} catch {
// Error getting restaurant data
// ...
}
return nil
})
} catch {
// ...
}
}Ziel c
- (void)addRatingTransactionWithRestaurantReference:(FIRDocumentReference *)restaurant
rating:(float)rating {
FIRDocumentReference *ratingReference =
[[restaurant collectionWithPath:@"ratings"] documentWithAutoID];
[self.db runTransactionWithBlock:^id (FIRTransaction *transaction,
NSError **errorPointer) {
FIRDocumentSnapshot *restaurantSnapshot =
[transaction getDocument:restaurant error:errorPointer];
if (restaurantSnapshot == nil) {
return nil;
}
NSMutableDictionary *restaurantData = [restaurantSnapshot.data mutableCopy];
if (restaurantData == nil) {
return nil;
}
// Compute new number of ratings
NSInteger ratingCount = [restaurantData[@"numRatings"] integerValue];
NSInteger newRatingCount = ratingCount + 1;
// Compute new average rating
float averageRating = [restaurantData[@"avgRating"] floatValue];
float newAverageRating = (averageRating * ratingCount + rating) / newRatingCount;
// Set new restaurant info
restaurantData[@"numRatings"] = @(newRatingCount);
restaurantData[@"avgRating"] = @(newAverageRating);
// Commit to Firestore
[transaction setData:restaurantData forDocument:restaurant];
[transaction setData:@{@"rating": @(rating)} forDocument:ratingReference];
return nil;
} completion:^(id _Nullable result, NSError * _Nullable error) {
// ...
}];
}Kotlin+KTX
private fun addRating(restaurantRef: DocumentReference, rating: Float): Task<Void> {
// Create reference for new rating, for use inside the transaction
val ratingRef = restaurantRef.collection("ratings").document()
// In a transaction, add the new rating and update the aggregate totals
return db.runTransaction { transaction ->
val restaurant = transaction.get(restaurantRef).toObject<Restaurant>()!!
// Compute new number of ratings
val newNumRatings = restaurant.numRatings + 1
// Compute new average rating
val oldRatingTotal = restaurant.avgRating * restaurant.numRatings
val newAvgRating = (oldRatingTotal + rating) / newNumRatings
// Set new restaurant info
restaurant.numRatings = newNumRatings
restaurant.avgRating = newAvgRating
// Update restaurant
transaction.set(restaurantRef, restaurant)
// Update rating
val data = hashMapOf<String, Any>(
"rating" to rating,
)
transaction.set(ratingRef, data, SetOptions.merge())
null
}
}Java
private Task<Void> addRating(final DocumentReference restaurantRef, final float rating) {
// Create reference for new rating, for use inside the transaction
final DocumentReference ratingRef = restaurantRef.collection("ratings").document();
// In a transaction, add the new rating and update the aggregate totals
return db.runTransaction(new Transaction.Function<Void>() {
@Override
public Void apply(@NonNull Transaction transaction) throws FirebaseFirestoreException {
Restaurant restaurant = transaction.get(restaurantRef).toObject(Restaurant.class);
// Compute new number of ratings
int newNumRatings = restaurant.numRatings + 1;
// Compute new average rating
double oldRatingTotal = restaurant.avgRating * restaurant.numRatings;
double newAvgRating = (oldRatingTotal + rating) / newNumRatings;
// Set new restaurant info
restaurant.numRatings = newNumRatings;
restaurant.avgRating = newAvgRating;
// Update restaurant
transaction.set(restaurantRef, restaurant);
// Update rating
Map<String, Object> data = new HashMap<>();
data.put("rating", rating);
transaction.set(ratingRef, data, SetOptions.merge());
return null;
}
});
}Durch die Verwendung einer Transaktion bleiben Ihre aggregierten Daten mit der zugrunde liegenden Sammlung konsistent. Weitere Informationen zu Transaktionen in Cloud Firestore finden Sie unter Transaktionen und Batch-Schreibvorgänge .
Einschränkungen
Die oben gezeigte Lösung veranschaulicht die Aggregation von Daten mithilfe der Cloud Firestore-Clientbibliothek. Sie sollten sich jedoch der folgenden Einschränkungen bewusst sein:
- Sicherheit – Für clientseitige Transaktionen müssen Sie den Kunden die Erlaubnis erteilen, die aggregierten Daten in Ihrer Datenbank zu aktualisieren. Sie können zwar die Risiken dieses Ansatzes verringern, indem Sie erweiterte Sicherheitsregeln schreiben, dies ist jedoch möglicherweise nicht in allen Situationen angemessen.
- Offline-Unterstützung – Clientseitige Transaktionen schlagen fehl, wenn das Gerät des Benutzers offline ist. Das bedeutet, dass Sie diesen Fall in Ihrer App behandeln und es zu gegebener Zeit erneut versuchen müssen.
- Leistung – Wenn Ihre Transaktion mehrere Lese-, Schreib- und Aktualisierungsvorgänge enthält, sind möglicherweise mehrere Anfragen an das Cloud Firestore-Backend erforderlich. Auf einem mobilen Gerät kann dies erhebliche Zeit in Anspruch nehmen.
- Schreibraten – diese Lösung funktioniert möglicherweise nicht für häufig aktualisierte Aggregationen, da Cloud Firestore-Dokumente höchstens einmal pro Sekunde aktualisiert werden können. Wenn eine Transaktion außerdem ein Dokument liest, das außerhalb der Transaktion geändert wurde, versucht sie es eine begrenzte Anzahl von Malen erneut und schlägt dann fehl. Sehen Sie sich die verteilten Zähler an, um eine entsprechende Problemumgehung für Aggregationen zu finden, die häufigere Aktualisierungen erfordern.
Lösung: Schreibzeitaggregation mit Cloud Functions
Wenn clientseitige Transaktionen für Ihre Anwendung nicht geeignet sind, können Sie eine Cloud-Funktion verwenden, um die aggregierten Informationen jedes Mal zu aktualisieren, wenn einem Restaurant eine neue Bewertung hinzugefügt wird:
Node.js
exports.aggregateRatings = functions.firestore
.document('restaurants/{restId}/ratings/{ratingId}')
.onWrite(async (change, context) => {
// Get value of the newly added rating
const ratingVal = change.after.data().rating;
// Get a reference to the restaurant
const restRef = db.collection('restaurants').doc(context.params.restId);
// Update aggregations in a transaction
await db.runTransaction(async (transaction) => {
const restDoc = await transaction.get(restRef);
// Compute new number of ratings
const newNumRatings = restDoc.data().numRatings + 1;
// Compute new average rating
const oldRatingTotal = restDoc.data().avgRating * restDoc.data().numRatings;
const newAvgRating = (oldRatingTotal + ratingVal) / newNumRatings;
// Update restaurant info
transaction.update(restRef, {
avgRating: newAvgRating,
numRatings: newNumRatings
});
});
});Diese Lösung verlagert die Arbeit vom Client auf eine gehostete Funktion, was bedeutet, dass Ihre mobile App Bewertungen hinzufügen kann, ohne auf den Abschluss einer Transaktion warten zu müssen. In einer Cloud-Funktion ausgeführter Code ist nicht an Sicherheitsregeln gebunden, was bedeutet, dass Sie Clients keinen Schreibzugriff mehr auf die aggregierten Daten gewähren müssen.
Einschränkungen
Die Verwendung einer Cloud-Funktion für Aggregationen vermeidet einige der Probleme bei clientseitigen Transaktionen, bringt jedoch andere Einschränkungen mit sich:
- Kosten – Jede hinzugefügte Bewertung führt zu einem Aufruf der Cloud-Funktion, was Ihre Kosten erhöhen kann. Weitere Informationen finden Sie auf der Preisseite für Cloud Functions.
- Latenz – Durch die Auslagerung der Aggregationsarbeit auf eine Cloud-Funktion werden Ihrer App aktualisierte Daten erst angezeigt, wenn die Ausführung der Cloud-Funktion abgeschlossen ist und der Client über die neuen Daten benachrichtigt wurde. Abhängig von der Geschwindigkeit Ihrer Cloud-Funktion kann dies länger dauern als die lokale Ausführung der Transaktion.
- Schreibraten – diese Lösung funktioniert möglicherweise nicht für häufig aktualisierte Aggregationen, da Cloud Firestore-Dokumente höchstens einmal pro Sekunde aktualisiert werden können. Wenn eine Transaktion außerdem ein Dokument liest, das außerhalb der Transaktion geändert wurde, versucht sie es eine begrenzte Anzahl von Malen erneut und schlägt dann fehl. Sehen Sie sich die verteilten Zähler an, um eine entsprechende Problemumgehung für Aggregationen zu finden, die häufigere Aktualisierungen erfordern.