Agregações de tempo de gravação

As consultas no Cloud Firestore permitem encontrar documentos em grandes coleções. Para obter insights sobre as propriedades da coleção como um todo, você pode agregar dados em uma coleção.

Você pode agregar dados em tempo de leitura ou em tempo de gravação:

  • As agregações em tempo de leitura calculam um resultado no momento da solicitação. O Cloud Firestore oferece suporte às consultas de agregação count() , sum() e average() em tempo de leitura. Consultas de agregação em tempo de leitura são mais fáceis de adicionar ao seu aplicativo do que agregações em tempo de gravação. Para obter mais informações sobre consultas de agregação, consulte Resumir dados com consultas de agregação .

  • As agregações de tempo de gravação calculam um resultado cada vez que o aplicativo executa uma operação de gravação relevante. As agregações em tempo de gravação são mais trabalhosas para implementar, mas você pode usá-las em vez de agregações em tempo de leitura por um dos seguintes motivos:

    • Você deseja ouvir o resultado da agregação para atualizações em tempo real. As consultas de agregação count() , sum() e average() não suportam atualizações em tempo real.
    • Você deseja armazenar o resultado da agregação em um cache do lado do cliente. As consultas de agregação count() , sum() e average() não suportam armazenamento em cache.
    • Você agrega dados de dezenas de milhares de documentos para cada um de seus usuários e considera os custos. Com um número menor de documentos, as agregações em tempo de leitura custam menos. Para um grande número de documentos em agregações, as agregações em tempo de gravação podem custar menos.

É possível implementar uma agregação de tempo de gravação usando uma transação do lado do cliente ou com o Cloud Functions. As seções a seguir descrevem como implementar agregações de tempo de gravação.

Solução: agregação em tempo de gravação com uma transação do lado do cliente

Considere um aplicativo de recomendações locais que ajude os usuários a encontrar ótimos restaurantes. A consulta a seguir recupera todas as classificações de um determinado restaurante:

Rede

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

Rápido

Observação: este produto não está disponível em destinos watchOS e App Clip.
do {
  let snapshot = try await db.collection("restaurants")
    .document("arinell-pizza")
    .collection("ratings")
    .getDocuments()
  print(snapshot)
} catch {
  print(error)
}
SolutionAggregationViewController.swift

Objetivo-C

Observação: este produto não está disponível em destinos watchOS e App Clip.
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

Em vez de buscar todas as classificações e depois calcular informações agregadas, podemos armazenar essas informações no próprio documento do restaurante:

Rede

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

Rápido

Observação: este produto não está disponível em destinos watchOS e App Clip.
struct Restaurant {

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

}

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

Objetivo-C

Observação: este produto não está disponível em destinos watchOS e App Clip.
@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

Para manter essas agregações consistentes, elas devem ser atualizadas sempre que uma nova classificação for adicionada à subcoleção. Uma maneira de obter consistência é realizar a adição e a atualização em uma única transação:

Rede

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

Rápido

Observação: este produto não está disponível em destinos watchOS e App Clip.
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

Objetivo-C

Observação: este produto não está disponível em destinos watchOS e App Clip.
- (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

O uso de uma transação mantém seus dados agregados consistentes com a coleção subjacente. Para ler mais sobre transações no Cloud Firestore, consulte Transações e gravações em lote .

Limitações

A solução mostrada acima demonstra a agregação de dados usando a biblioteca cliente do Cloud Firestore, mas você deve estar ciente das seguintes limitações:

  • Segurança - As transações do lado do cliente exigem permissão aos clientes para atualizar os dados agregados em seu banco de dados. Embora você possa reduzir os riscos dessa abordagem escrevendo regras de segurança avançadas, isso pode não ser apropriado em todas as situações.
  • Suporte offline – As transações do lado do cliente falharão quando o dispositivo do usuário estiver offline, o que significa que você precisa lidar com esse caso em seu aplicativo e tentar novamente no momento apropriado.
  • Desempenho : se sua transação contiver diversas operações de leitura, gravação e atualização, poderá exigir diversas solicitações ao back-end do Cloud Firestore. Em um dispositivo móvel, isso pode levar um tempo significativo.
  • Taxas de gravação : esta solução pode não funcionar para agregações atualizadas com frequência porque os documentos do Cloud Firestore só podem ser atualizados no máximo uma vez por segundo. Além disso, se uma transação ler um documento que foi modificado fora da transação, ela tentará novamente um número finito de vezes e falhará. Confira os contadores distribuídos para obter uma solução alternativa relevante para agregações que precisam de atualizações mais frequentes.

Solução: agregação em tempo de gravação com Cloud Functions

Se as transações do lado do cliente não forem adequadas para seu aplicativo, você poderá usar uma função do Cloud para atualizar as informações agregadas sempre que uma nova classificação for adicionada a um restaurante:

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

Esta solução transfere o trabalho do cliente para uma função hospedada, o que significa que seu aplicativo móvel pode adicionar classificações sem esperar a conclusão de uma transação. O código executado em uma Cloud Function não está sujeito a regras de segurança, o que significa que você não precisa mais conceder aos clientes acesso de gravação aos dados agregados.

Limitações

O uso de uma função do Cloud para agregações evita alguns dos problemas com transações do lado do cliente, mas apresenta um conjunto diferente de limitações:

  • Custo - Cada classificação adicionada causará uma invocação do Cloud Function, o que pode aumentar seus custos. Para obter mais informações, consulte a página de preços do Cloud Functions.
  • Latência : ao descarregar o trabalho de agregação para uma função do Cloud, seu aplicativo não verá dados atualizados até que a função do Cloud termine de ser executada e o cliente seja notificado sobre os novos dados. Dependendo da velocidade da sua Cloud Function, isso pode demorar mais do que executar a transação localmente.
  • Taxas de gravação : esta solução pode não funcionar para agregações atualizadas com frequência porque os documentos do Cloud Firestore só podem ser atualizados no máximo uma vez por segundo. Além disso, se uma transação ler um documento que foi modificado fora da transação, ela tentará novamente um número finito de vezes e falhará. Confira os contadores distribuídos para obter uma solução alternativa relevante para agregações que precisam de atualizações mais frequentes.