Diese Seite wurde von der Cloud Translation API übersetzt.

Aggregationen während der Schreibzeit

Mit Abfragen in Firestore können Sie Dokumente finden in großen Sammlungen. Um einen Einblick in die Eigenschaften der gesammelt haben, können Sie Daten über eine Sammlung aggregieren.

Sie können Daten entweder zum Lese- oder zum Schreiben aggregieren:

Bei Aggregationen zur Lesezeit wird ein Ergebnis zum Zeitpunkt der Anfrage berechnet. Firestore unterstützt count(), sum() und average() Aggregationsabfragen zur Lesezeit. Abfragen zur Aggregation bei der Lesezeit lassen sich Ihrer App leichter hinzufügen als Aggregationen bei der Schreibzeit. Weitere Informationen Aggregationsabfragen finden Sie unter Daten mit Aggregationsabfragen zusammenfassen.
Bei Aggregationen zur Schreibzeit wird bei jeder Ausführung der Anwendung ein Ergebnis berechnet. eine relevante Schreiboperation. Aggregationen zur Laufzeit sind zwar aufwendiger zu implementieren, können aber aus einem der folgenden Gründe anstelle von Aggregationen zur Lesezeit verwendet werden:
- Sie möchten das Aggregationsergebnis auf Echtzeitaktualisierungen überwachen. Die Aggregationsabfragen count(), sum() und average() werden nicht unterstützt Echtzeit-Updates.
- Sie möchten das Aggregationsergebnis in einem clientseitigen Cache speichern. Die Aggregationsabfragen count(), sum() und average() werden nicht unterstützt Caching.
- Sie aggregieren Daten aus Zehntausenden von Dokumenten für jeden und die Kosten berücksichtigen. Bei einer geringeren Anzahl von Dokumenten wird die Lesezeit Aggregationen weniger kosten. Bei einer großen Anzahl von Dokumenten in einer Aggregation Aggregationen bei der Schreibzeit möglicherweise weniger kosten.

Sie können eine Aggregation zur Schreibzeit entweder mit einer clientseitigen Transaktion oder mit Cloud Run-Funktionen implementieren. In den folgenden Abschnitten wird beschrieben, wie Sie Aggregationen zur Schreibzeit.

Lösung: Aggregation der Schreibzeit mit einer clientseitigen Transaktion

Stellen Sie sich eine App mit lokalen Empfehlungen vor, mit der Nutzer bei der Suche nach guten Restaurants unterstützt werden. Mit der folgenden Abfrage werden alle Bewertungen für ein bestimmtes Restaurant abgerufen:

Web

db.collection("restaurants")
  .doc("arinell-pizza")
  .collection("ratings")
  .get();test.solution-aggregation.js

Swift

Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.

do {
  let snapshot = try await db.collection("restaurants")
    .document("arinell-pizza")
    .collection("ratings")
    .getDocuments()
  print(snapshot)
} catch {
  print(error)
}SolutionAggregationViewController.swift

Objective-C

Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.

FIRQuery *query = [[[self.db collectionWithPath:@"restaurants"]
    documentWithPath:@"arinell-pizza"] collectionWithPath:@"ratings"];
[query getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot,
                                    NSError * _Nullable error) {
  // ...
}];FIRSolutionAggregationViewController.m

Kotlin+KTX
Android

db.collection("restaurants")
    .document("arinell-pizza")
    .collection("ratings")
    .get()SolutionAggregation.kt

Java
Android

db.collection("restaurants")
        .document("arinell-pizza")
        .collection("ratings")
        .get();SolutionAggregation.java

Anstatt alle Bewertungen abzurufen und dann die aggregierten Daten zu berechnen, können diese Informationen im Restaurantdokument selbst gespeichert werden:

Web

var arinellDoc = {
  name: 'Arinell Pizza',
  avgRating: 4.65,
  numRatings: 683
};test.solution-aggregation.js

Swift

Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.

struct Restaurant {

  let name: String
  let avgRating: Float
  let numRatings: Int

}

let arinell = Restaurant(name: "Arinell Pizza", avgRating: 4.65, numRatings: 683)SolutionAggregationViewController.swift

Objective-C

Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.

@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;
}

@endFIRSolutionAggregationViewController.m

Kotlin+KTX
Android

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)SolutionAggregation.kt

Java
Android

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);SolutionAggregation.java

Damit diese Aggregationen konsistent bleiben, müssen sie jedes Mal aktualisiert werden, wenn eine neue Bewertung zur untergeordneten Sammlung hinzugefügt wird. Eine Möglichkeit, Konsistenz zu erreichen, besteht darin, das Hinzufügen und Aktualisieren in einer einzigen Transaktion durchzuführen:

Web

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 });
        });
    });
}test.firestore.js

Swift

Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.

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 {
    // ...
  }
}SolutionAggregationViewController.swift

Objective-C

Hinweis: Dieses Produkt nicht ist auf WatchOS- und App Clip-Zielen verfügbar.

- (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) {
    // ...
  }];
}FIRSolutionAggregationViewController.m

Kotlin+KTX
Android

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
    }
}SolutionAggregation.kt

Java
Android

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;
        }
    });
}SolutionAggregation.java

Mit einer Transaktion bleiben Ihre aggregierten Daten mit der zugrunde liegenden Sammlung konsistent. Weitere Informationen zu Transaktionen in Firestore finden Sie unter Transaktionen und Batch-Schreibvorgänge.

Beschränkungen

Die oben dargestellte Lösung veranschaulicht das Aggregieren von Daten mithilfe der Firestore-Clientbibliothek. Beachten Sie dabei aber die folgenden Einschränkungen:

Sicherheit – Clientseitige Transaktionen setzen voraus, dass die Clients die Berechtigung zum Aktualisieren der aggregierten Daten in Ihrer Datenbank haben. Sie können zwar die Risiken dieses Ansatzes reduzieren, indem Sie erweiterte Sicherheitsregeln schreiben, dies ist jedoch möglicherweise nicht in allen Situationen angebracht.
Offline nutzbar – Clientseitige Transaktionen schlagen fehl, wenn das Gerät des Nutzers offline ist. Das bedeutet, dass Sie diesen Fall in Ihrer App verarbeiten und die Transaktion später wiederholen müssen.
Leistung – Wenn Ihre Transaktion mehrere Lese-, Schreib- und kann es mehrere Anfragen an den Firestore-Back-End Auf einem Mobilgerät kann dies viel Zeit in Anspruch nehmen.
Schreibraten: Diese Lösung funktioniert möglicherweise nicht für häufig aktualisierte Aggregationen, da Cloud Firestore-Dokumente nur einmal pro Sekunde aktualisiert werden können. Wenn eine Transaktion ein Dokument liest, das außerhalb der Transaktion geändert wurde, wird außerdem eine endliche Anzahl von Wiederholungen ausgeführt und schlägt dann fehl. Unter Verteilte Zähler finden Sie eine relevante Problemumgehung für Aggregationen, die häufigere Aktualisierungen erfordern.

Lösung: Aggregation der Schreibzeit mit Cloud Functions

Wenn clientseitige Transaktionen für Ihre Anwendung nicht geeignet sind, können Sie die aggregierten Informationen mit einer Cloud Functions-Funktion jedes Mal aktualisieren, wenn eine neue Bewertung zu einem Restaurant 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
        });
      });
    });index.js

Mit dieser Lösung wird die Arbeit vom Client an eine gehostete Funktion übertragen. Das bedeutet, dass in Ihrer mobilen App Bewertungen hinzugefügt werden können, ohne auf den Abschluss einer Transaktion warten zu müssen. Code, der in einer Cloud Functions-Funktion ausgeführt wird, ist nicht an Sicherheitsregeln gebunden. Das bedeutet, dass Sie den Clients keinen Schreibzugriff mehr auf die aggregierten Daten geben müssen.

Beschränkungen

Durch die Verwendung einer Cloud Functions-Funktion für Aggregationen werden einige Probleme bei clientseitigen Transaktionen vermieden. Es gibt jedoch andere Einschränkungen:

Kosten – Jede hinzugefügte Bewertung führt zu einem Aufruf von Cloud Functions, wodurch Ihre Kosten steigen können. Weitere Informationen finden Sie auf der Preisseite für Cloud Functions.
Latenz – Durch die Übertragung der Aggregationsarbeit auf Cloud Functions werden in Ihrer App keine aktualisierten Daten angezeigt, bis die Cloud Functions-Funktion ausgeführt und der Client über die neuen Daten informiert wurde. Abhängig von der Geschwindigkeit Ihrer Cloud Functions-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 nur einmal pro Sekunde aktualisiert werden können. Wenn eine Transaktion ein Dokument liest, das außerhalb der Transaktion geändert wurde, wird außerdem eine endliche Anzahl von Wiederholungen ausgeführt und schlägt dann fehl. Unter Verteilte Zähler finden Sie eine relevante Problemumgehung für Aggregationen, die häufigere Aktualisierungen erfordern.

Aggregationen während der Schreibzeit

Lösung: Aggregation der Schreibzeit mit einer clientseitigen Transaktion

Web

Swift

Objective-C

Kotlin+KTXAndroid

JavaAndroid

Web

Swift

Objective-C

Kotlin+KTXAndroid

JavaAndroid

Web

Swift

Objective-C

Kotlin+KTXAndroid

JavaAndroid

Beschränkungen

Lösung: Aggregation der Schreibzeit mit Cloud Functions

Node.js

Beschränkungen

Kotlin+KTX
Android

Java
Android

Kotlin+KTX
Android

Java
Android

Kotlin+KTX
Android

Java
Android