Agregaciones en tiempo de escritura
Las consultas de Firestore te permiten encontrar documentos en colecciones grandes. Para obtener información valiosa sobre las propiedades de la colección en su conjunto, puede agregar datos de una colección.
Puedes agregar datos en tiempo de lectura o en tiempo de escritura:
Las agregaciones en tiempo de lectura calculan un resultado en el momento de la solicitud. Firestore admite las consultas de agregación
count(),sum()yaverage()en tiempo de lectura. Las consultas de agregación de tiempo de lectura son más fáciles de añadir a tu aplicación que las agregaciones de tiempo de escritura. Para obtener más información sobre las consultas de agregación, consulta Resumir datos con consultas de agregación.Las agregaciones en tiempo de escritura calculan un resultado cada vez que la aplicación realiza una operación de escritura relevante. Las agregaciones en tiempo de escritura requieren más trabajo para implementarse, pero puedes usarlas en lugar de las agregaciones en tiempo de lectura por uno de los siguientes motivos:
- Quieres recibir actualizaciones en tiempo real sobre el resultado de la agregación.
Las consultas de agregación
count(),sum()yaverage()no admiten actualizaciones en tiempo real. - Quieres almacenar el resultado de la agregación en una caché del lado del cliente.
Las consultas de agregación
count(),sum()yaverage()no admiten el almacenamiento en caché. - Estás agregando datos de decenas de miles de documentos para cada uno de tus usuarios y tienes en cuenta los costes. Si el número de documentos es menor, las agregaciones de tiempo de lectura cuestan menos. Si hay un gran número de documentos en una agregación, las agregaciones en tiempo de escritura pueden costar menos.
- Quieres recibir actualizaciones en tiempo real sobre el resultado de la agregación.
Las consultas de agregación
Puedes implementar una agregación en tiempo de escritura mediante una transacción del lado del cliente o con funciones de Cloud Run. En las siguientes secciones se describe cómo implementar agregaciones en tiempo de escritura.
Solución: agregación en tiempo de escritura con una transacción del lado del cliente
Imagina una aplicación de recomendaciones locales que ayude a los usuarios a encontrar buenos restaurantes. La siguiente consulta obtiene todas las valoraciones de un restaurante concreto:
Web
db.collection("restaurants") .doc("arinell-pizza") .collection("ratings") .get();
Swift
Nota: Este producto no está disponible en los destinos de watchOS y App Clip.
do { let snapshot = try await db.collection("restaurants") .document("arinell-pizza") .collection("ratings") .getDocuments() print(snapshot) } catch { print(error) }
Objective‑C
Nota: Este producto no está disponible en los destinos de watchOS y App Clip.
FIRQuery *query = [[[self.db collectionWithPath:@"restaurants"] documentWithPath:@"arinell-pizza"] collectionWithPath:@"ratings"]; [query getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot, NSError * _Nullable error) { // ... }];
Kotlin
Android
db.collection("restaurants") .document("arinell-pizza") .collection("ratings") .get()
Java
Android
db.collection("restaurants") .document("arinell-pizza") .collection("ratings") .get();
En lugar de obtener todas las valoraciones y, a continuación, calcular la información agregada, podemos almacenar esta información en el documento del restaurante:
Web
var arinellDoc = { name: 'Arinell Pizza', avgRating: 4.65, numRatings: 683 };
Swift
Nota: Este producto no está disponible en los destinos de watchOS y App Clip.
struct Restaurant { let name: String let avgRating: Float let numRatings: Int } let arinell = Restaurant(name: "Arinell Pizza", avgRating: 4.65, numRatings: 683)
Objective‑C
Nota: Este producto no está disponible en los destinos de watchOS y 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
Kotlin
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)
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);
Para que estas agregaciones sean coherentes, deben actualizarse cada vez que se añada una nueva valoración a la subcolección. Una forma de conseguir coherencia es realizar la adición y la actualización en una sola transacción:
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 }); }); }); }
Swift
Nota: Este producto no está disponible en los destinos de watchOS y 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 { // ... } }
Objective‑C
Nota: Este producto no está disponible en los destinos de watchOS y 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) { // ... }]; }
Kotlin
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 } }
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; } }); }
Si usas una transacción, los datos agregados serán coherentes con la colección subyacente. Para obtener más información sobre las transacciones en Firestore, consulta el artículo Transacciones y escrituras por lotes.
Limitaciones
La solución que se muestra arriba explica cómo agregar datos mediante la biblioteca de cliente de Firestore, pero debes tener en cuenta las siguientes limitaciones:
- Seguridad: las transacciones del lado del cliente requieren que se conceda permiso a los clientes para actualizar los datos agregados de tu base de datos. Aunque puedes reducir los riesgos de este método escribiendo reglas de seguridad avanzadas, puede que no sea adecuado en todas las situaciones.
- Compatibilidad sin conexión: las transacciones del lado del cliente fallarán cuando el dispositivo del usuario no tenga conexión, por lo que deberás gestionar este caso en tu aplicación y volver a intentarlo en el momento oportuno.
- Rendimiento: si tu transacción contiene varias operaciones de lectura, escritura y actualización, es posible que requiera varias solicitudes al backend de Firestore. En un dispositivo móvil, este proceso puede llevar bastante tiempo.
- Velocidades de escritura: esta solución puede no funcionar con agregaciones que se actualizan con frecuencia, ya que los documentos de Cloud Firestore solo se pueden actualizar como máximo una vez por segundo. Además, si una transacción lee un documento que se ha modificado fuera de la transacción, se vuelve a intentar un número finito de veces y, después, falla. Consulta los contadores distribuidos para ver una solución alternativa adecuada para las agregaciones que necesitan actualizaciones más frecuentes.
Solución: agregación en tiempo de escritura con Cloud Functions
Si las transacciones del lado del cliente no son adecuadas para tu aplicación, puedes usar una función de Cloud para actualizar la información agregada cada vez que se añada una nueva valoración a un 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 }); }); });
Esta solución delega el trabajo del cliente a una función alojada, lo que significa que tu aplicación móvil puede añadir valoraciones sin esperar a que se complete una transacción. El código ejecutado en una función de Cloud no está sujeto a reglas de seguridad, lo que significa que ya no es necesario dar a los clientes acceso de escritura a los datos agregados.
Limitaciones
Si usas una función de Cloud para las agregaciones, evitarás algunos de los problemas de las transacciones del lado del cliente, pero tendrás otras limitaciones:
- Coste: cada valoración añadida provocará una invocación de Cloud Functions, lo que puede aumentar los costes. Para obtener más información, consulta la página de precios de Cloud Functions.
- Latencia: al delegar el trabajo de agregación en una función de Cloud, tu aplicación no verá los datos actualizados hasta que la función de Cloud haya terminado de ejecutarse y se haya notificado al cliente sobre los nuevos datos. En función de la velocidad de tu función de Cloud, este proceso podría tardar más que la ejecución de la transacción de forma local.
- Velocidades de escritura: esta solución puede no funcionar con agregaciones que se actualizan con frecuencia, ya que los documentos de Cloud Firestore solo se pueden actualizar como máximo una vez por segundo. Además, si una transacción lee un documento que se ha modificado fuera de la transacción, se vuelve a intentar un número finito de veces y, después, falla. Consulta los contadores distribuidos para ver una solución alternativa adecuada para las agregaciones que necesitan actualizaciones más frecuentes.