Agregacje czasu zapisu

Zapytania w Cloud Firestore umożliwiają znajdowanie dokumentów w dużych zbiorach. Aby uzyskać wgląd w właściwości w całości, można agregować dane dotyczące danego zbioru.

Dane możesz agregować w czasie odczytu lub zapisu:

  • Agregacje czasu odczytu obliczają wynik w chwili wysłania żądania. Cloud Firestore obsługuje count(), sum() i average() zapytań agregujących w czasie odczytu. Zapytania dotyczące agregacji w czasie odczytu są łatwiejsze niż agregacje w czasie zapisu. Więcej informacji: Zapytania agregujące: przeczytaj artykuł Podsumowywanie danych za pomocą zapytań agregowanych.

  • Agregacje czasu zapisu obliczają wynik za każdym razem, gdy aplikacja działa odpowiednią operację zapisu. Agregacje czasu zapisu wymagają więcej pracy do wykonania, ale możesz ich używać zamiast agregacji czasu odczytu dla jednej następujące przyczyny:

    • Chcesz poznać wynik agregacji, aby poznać aktualizacje w czasie rzeczywistym. Zapytania zbiorcze count(), sum() i average() nie obsługują na bieżąco.
    • Chcesz zapisać wynik agregacji w pamięci podręcznej po stronie klienta. Zapytania zbiorcze count(), sum() i average() nie obsługują buforowanie.
    • Agregujesz dane z dziesiątek tysięcy dokumentów dotyczących każdego użytkowników i uwzględnienie kosztów. Czas odczytu przy mniejszej liczbie dokumentów agregacje są tańsze. W przypadku dużej liczby dokumentów w agregacjach agregacje w czasie zapisu mogą kosztować mniej.

Możesz wdrożyć agregację czasu zapisu przy użyciu funkcji po stronie klienta lub za pomocą Cloud Functions. W sekcjach poniżej dowiesz się, jak zaimplementować agregacje w czasie zapisu.

Rozwiązanie: agregacja czasu zapisu w przypadku transakcji po stronie klienta

Rozważ skorzystanie z aplikacji z rekomendacjami dla osób w okolicy, która pomoże użytkownikom znaleźć świetne restauracje. To zapytanie pobiera wszystkie oceny danej restauracji:

Sieć

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

Swift

Uwaga: ten produkt nie jest dostępny na urządzeniach docelowych watchOS i wycinków aplikacji. 
do {
  let snapshot = try await db.collection("restaurants")
    .document("arinell-pizza")
    .collection("ratings")
    .getDocuments()
  print(snapshot)
} catch {
  print(error)
}
SolutionAggregationViewController.swift

Objective-C

Uwaga: ten produkt nie jest dostępny na urządzeniach docelowych watchOS i wycinków aplikacji. 
FIRQuery *query = [[[self.db collectionWithPath:@"restaurants"]
    documentWithPath:@"arinell-pizza"] collectionWithPath:@"ratings"];
[query getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot,
                                    NSError * _Nullable error) {
  // ...
}];
FIRSolutionAggregationViewController.m

Kotlin+KTX 

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

Java 

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

Zamiast pobierać wszystkie oceny i obliczać informacje zbiorcze, mogą zapisać te informacje w dokumencie dotyczącym restauracji:

Sieć

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

Swift

Uwaga: ten produkt nie jest dostępny na urządzeniach docelowych watchOS i wycinków aplikacji. 
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

Uwaga: ten produkt nie jest dostępny na urządzeniach docelowych watchOS i wycinków aplikacji. 
@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;
}

@end
FIRSolutionAggregationViewController.m

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

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

Aby zachować spójność tych agregacji, należy je za każdym razem aktualizować nowa ocena zostanie dodana do podkolekcji. Jednym ze sposobów na osiągnięcie spójności jest wykonanie tej czynności w ramach jednej transakcji:

Sieć

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

Uwaga: ten produkt nie jest dostępny na urządzeniach docelowych watchOS i wycinków aplikacji. 
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

Uwaga: ten produkt nie jest dostępny na urządzeniach docelowych watchOS i wycinków aplikacji. 
- (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 

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 

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

Korzystanie z transakcji pozwala zapewnić spójność danych zbiorczych kolekcji. Aby dowiedzieć się więcej o transakcjach w Cloud Firestore, Więcej informacji znajdziesz w sekcji Transakcje i zapisy zbiorcze.

Ograniczenia

Powyższe rozwiązanie pokazuje agregację danych za pomocą metody biblioteki klienta Cloud Firestore, ale warto znać te kwestie: Ograniczenia:

  • Bezpieczeństwo – transakcje po stronie klienta wymagają udzielenia klientom uprawnień , aby zaktualizować dane zbiorcze w bazie danych. Chociaż możesz zredukować związane z tym podejściem przez napisanie zaawansowanych reguł zabezpieczeń. Może to nie być w każdej sytuacji.
  • Obsługa offline – transakcje po stronie klienta zakończą się niepowodzeniem, gdy urządzenie użytkownika Użytkownik jest offline, co oznacza, że musisz rozwiązać ten problem w aplikacji i spróbować ponownie w odpowiednim momencie.
  • Wydajność – jeśli transakcja obejmuje wiele operacji odczytu, zapisu i aktualizacji, może wymagać wielu żądań wysyłanych do Backend Cloud Firestore. Na urządzeniu mobilnym może to potrwać przez dłuższy czas.
  • Szybkość zapisu – to rozwiązanie może nie działać w przypadku częstych aktualizacji. agregacje, ponieważ dokumenty Cloud Firestore można aktualizować najwyżej raz na sekundę. Ponadto, jeśli transakcja odczytuje dokument, który został modyfikowane poza transakcją, ponawia wiele prób a potem przestaje działać. Sprawdź rozpowszechniane liczniki zdarzeń. rozwiązania problemu w przypadku agregacji, które wymagają częstszych aktualizacji.

Rozwiązanie: agregacja czasu zapisu w Cloud Functions

Jeśli transakcje po stronie klienta nie są odpowiednie dla Twojej aplikacji, możesz funkcji w Cloud Functions do aktualizowania zagregowanych informacji. po każdym dodaniu do restauracji nowej oceny:

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

To rozwiązanie przenosi zadania z klienta do funkcji hostowanej, która oznacza, że Twoja aplikacja mobilna może dodawać oceny bez oczekiwania na transakcję gotowe. Kod wykonywany w funkcji w Cloud Functions nie jest objęty regułami zabezpieczeń, co oznacza, że nie musisz już przyznawać klientom dostępu do zapisu agregacji. i skalowalnych danych.

Ograniczenia

Używanie funkcji w Cloud Functions do agregacji pozwala uniknąć niektórych problemów z transakcji po stronie klienta, ale wiążą się one z innymi ograniczeniami:

  • Koszt – każda dodana ocena spowoduje wywołanie funkcji w Cloud Functions, która może zwiększyć koszty. Więcej informacji znajdziesz w Cloud Functions stronie z cenami.
  • Czas oczekiwania – dzięki przeniesieniu pracy agregacji do funkcji w Cloud Functions aplikacja nie będzie widzieć zaktualizowanych danych, dopóki funkcja w Cloud Functions nie zostanie zakończona i klient został powiadomiony o nowych danych. W zależności od to szybkość działania funkcji w Cloud Functions, może to potrwać dłużej niż wykonanie transakcji lokalnej.
  • Szybkość zapisu – to rozwiązanie może nie działać w przypadku częstych aktualizacji. agregacje, ponieważ dokumenty Cloud Firestore można aktualizować najwyżej raz na sekundę. Ponadto, jeśli transakcja odczytuje dokument, który został modyfikowane poza transakcją, ponawia wiele prób a potem przestaje działać. Sprawdź rozpowszechniane liczniki zdarzeń. rozwiązania problemu w przypadku agregacji, które wymagają częstszych aktualizacji.