Aggregazioni al momento della scrittura

Le query in Cloud Firestore ti consentono di trovare documenti in grandi raccolte. Per ottenere informazioni sulle proprietà della raccolta nel suo complesso, puoi aggregare i dati in una raccolta.

Puoi aggregare i dati al momento della lettura o della scrittura:

  • Le aggregazioni in base al momento di lettura calcolano un risultato al momento della richiesta. Cloud Firestore supporta le query di aggregazione count(), sum() e average() al momento della lettura. Le query di aggregazione in fase di lettura sono più facili da aggiungere all'app rispetto alle aggregazioni in fase di scrittura. Per saperne di più sulle query di aggregazione, consulta Riepilogare i dati con le query di aggregazione.

  • Le aggregazioni in fase di scrittura calcolano un risultato ogni volta che l'app esegue un'operazione di scrittura pertinente. Le aggregazioni al momento della scrittura richiedono un maggiore impegno per l'implementazione, ma potresti utilizzarle al posto di quelle al momento della lettura per uno dei seguenti motivi:

    • Vuoi ascoltare il risultato dell'aggregazione per gli aggiornamenti in tempo reale. Le query di aggregazione count(), sum() e average() non supportano gli aggiornamenti in tempo reale.
    • Vuoi memorizzare il risultato dell'aggregazione in una cache lato client. Le query di aggregazione count(), sum() e average() non supportano la memorizzazione nella cache.
    • Aggreghi i dati di decine di migliaia di documenti per ogni uno dei tuoi utenti e prendi in considerazione i costi. Con un numero inferiore di documenti, le aggregazioni del tempo di lettura hanno un costo inferiore. Per un numero elevato di documenti in un'aggregazione, le aggregazioni al momento della scrittura potrebbero costare meno.

Puoi implementare un'aggregazione al momento della scrittura utilizzando una transazione lato client o con Cloud Functions. Le sezioni seguenti descrivono come implementare le aggregazioni al momento della scrittura.

Soluzione: aggregazione al momento della scrittura con una transazione lato client

Prendi in considerazione un'app di consigli locali che aiuti gli utenti a trovare ottimi ristoranti. La seguente query recupera tutte le valutazioni di un determinato ristorante:

Web

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

Swift

Nota:questo prodotto non è disponibile come target per 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

Objective-C

Nota:questo prodotto non è disponibile come target per 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 

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

Java 

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

Anziché recuperare tutte le valutazioni e poi calcolare le informazioni aggregate, possiamo archiviarle nel documento del ristorante stesso:

Web

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

Swift

Nota:questo prodotto non è disponibile come target per 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

Objective-C

Nota:questo prodotto non è disponibile come target per 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 

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

Per mantenere coerenti queste aggregazioni, devono essere aggiornate ogni volta che viene aggiunta una nuova classificazione alla sottoraccolta. Un modo per ottenere la coerenza è eseguire l'aggiunta e l'aggiornamento in un'unica transazione:

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

Nota:questo prodotto non è disponibile come target per 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

Objective-C

Nota:questo prodotto non è disponibile come target per 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 

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

L'utilizzo di una transazione mantiene i dati aggregati coerenti con la raccolta di base. Per scoprire di più sulle transazioni in Cloud Firestore, consulta Transazioni e scritture collettive.

Limitazioni

La soluzione mostrata sopra mostra l'aggregazione dei dati utilizzando la libreria client Cloud Firestore, ma devi tenere presente le seguenti limitazioni:

  • Sicurezza: le transazioni lato client richiedono di concedere ai clienti l'autorizzazione per aggiornare i dati aggregati nel database. Sebbene sia possibile ridurre i rischi di questo approccio scrivendo regole di sicurezza avanzate, questa operazione potrebbe non essere appropriata in tutte le situazioni.
  • Supporto offline: le transazioni lato client non andranno a buon fine quando il dispositivo dell'utente è offline, il che significa che devi gestire questa situazione nella tua app e riprovare al momento opportuno.
  • Rendimento: se la transazione contiene più operazioni di lettura, scrittura e aggiornamento, potrebbe richiedere più richieste al backend Cloud Firestore. Su un dispositivo mobile, l'operazione potrebbe richiedere molto tempo.
  • Tasso di scrittura: questa soluzione potrebbe non funzionare per le aggregazioni aggiornate di frequente perché i documenti Cloud Firestore possono essere aggiornati al massimo una volta al secondo. Inoltre, se una transazione legge un documento che è stato modificato al di fuori della transazione, riprova un numero finito di volte e poi non va a buon fine. Consulta i contatori distribuiti per una soluzione alternativa pertinente per le aggregazioni che richiedono aggiornamenti più frequenti.

Soluzione: aggregazione al momento della scrittura con Cloud Functions

Se le transazioni lato client non sono adatte alla tua applicazione, puoi utilizzare una funzione Cloud per aggiornare le informazioni aggregate ogni volta che viene aggiunta una nuova valutazione a un ristorante:

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

Questa soluzione scarica il lavoro dal client a una funzione ospitata, il che significa che la tua app mobile può aggiungere valutazioni senza attendere il completamento di una transazione. Il codice eseguito in una funzione Cloud non è vincolato dalle regole di sicurezza, il che significa che non è più necessario concedere ai client l'accesso in scrittura ai dati aggregati.

Limitazioni

L'utilizzo di una funzione Cloud per le aggregazioni evita alcuni dei problemi relativi alle transazioni lato client, ma presenta un insieme diverso di limitazioni:

  • Costo: ogni valutazione aggiunta causerà un'invocazione di Cloud Function, che potrebbe aumentare i costi. Per ulteriori informazioni, consulta la pagina dei prezzi di Cloud Functions.
  • Latenza: se esegui il offload del lavoro di aggregazione in una funzione Cloud, la tua app non vedrà i dati aggiornati finché la funzione Cloud non sarà stata eseguita e il client non avrà ricevuto una notifica relativa ai nuovi dati. A seconda della velocità della funzione Cloud, l'operazione potrebbe richiedere più tempo rispetto all'esecuzione della transazione in locale.
  • Tasso di scrittura: questa soluzione potrebbe non funzionare per le aggregazioni aggiornate di frequente perché i documenti Cloud Firestore possono essere aggiornati al massimo una volta al secondo. Inoltre, se una transazione legge un documento che è stato modificato al di fuori della transazione, riprova un numero finito di volte e poi non va a buon fine. Consulta i contatori distribuiti per una soluzione alternativa pertinente per le aggregazioni che richiedono aggiornamenti più frequenti.