Агрегации времени записи

Запросы в Cloud Firestore позволяют находить документы в больших коллекциях. Чтобы получить представление о свойствах коллекции в целом, вы можете агрегировать данные по коллекции.

Агрегировать данные можно как во время чтения, так и во время записи:

  • Агрегация данных во время чтения вычисляет результат в момент запроса. Cloud Firestore поддерживает запросы агрегации count() , sum() и average() во время чтения. Запросы агрегации во время чтения проще добавить в приложение, чем запросы агрегации во время записи. Подробнее о запросах агрегации см. в разделе «Суммирование данных с помощью запросов агрегации» .

  • Агрегации времени записи вычисляют результат каждый раз, когда приложение выполняет соответствующую операцию записи. Реализация агрегаций времени записи требует больше усилий, но вы можете использовать их вместо агрегаций времени чтения по одной из следующих причин:

    • Вам необходимо отслеживать результаты агрегирования для получения обновлений в реальном времени. Запросы агрегирования count() , sum() и average() не поддерживают обновления в реальном времени.
    • Вы хотите сохранить результат агрегирования в кэше на стороне клиента. Запросы агрегирования count() , sum() и average() не поддерживают кэширование.
    • Вы агрегируете данные из десятков тысяч документов для каждого из ваших пользователей и учитываете затраты. При меньшем количестве документов агрегирование во время чтения обходится дешевле. При большом количестве документов в агрегировании агрегирование во время записи может обойтись дешевле.

Агрегацию во время записи можно реализовать либо с помощью транзакции на стороне клиента, либо с помощью Cloud Functions . В следующих разделах описано, как реализовать агрегацию во время записи.

Решение: Агрегация транзакций на стороне клиента во время записи.

Рассмотрим приложение для поиска местных ресторанов, которое помогает пользователям находить отличные заведения. Следующий запрос извлекает все рейтинги для заданного ресторана:

Веб 

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

Быстрый

Примечание: Этот продукт недоступен для watchOS и приложений 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

Примечание: Этот продукт недоступен для watchOS и приложений 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

Вместо того чтобы получать все рейтинги, а затем вычислять сводную информацию, мы можем хранить эту информацию непосредственно в документе, относящемся к ресторану:

Веб 

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

Быстрый

Примечание: Этот продукт недоступен для watchOS и приложений 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

Примечание: Этот продукт недоступен для watchOS и приложений 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

Для обеспечения согласованности этих агрегированных данных их необходимо обновлять каждый раз, когда в подколлекцию добавляется новый рейтинг. Один из способов достижения согласованности — выполнение добавления и обновления в рамках одной транзакции:

Веб 

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

Быстрый

Примечание: Этот продукт недоступен для watchOS и приложений 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

Примечание: Этот продукт недоступен для watchOS и приложений 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

Использование транзакций обеспечивает согласованность ваших агрегированных данных с базовой коллекцией. Подробнее о транзакциях в Cloud Firestore см. в разделах «Транзакции» и «Пакетная запись» .

Ограничения

Представленное выше решение демонстрирует агрегирование данных с использованием клиентской библиотеки Cloud Firestore , однако следует учитывать следующие ограничения:

  • Безопасность — транзакции на стороне клиента требуют предоставления клиентам разрешения на обновление сводных данных в вашей базе данных. Хотя вы можете снизить риски такого подхода, написав сложные правила безопасности, это может быть нецелесообразно во всех ситуациях.
  • Поддержка работы в автономном режиме — транзакции на стороне клиента завершатся неудачей, если устройство пользователя находится в автономном режиме. Это означает, что вам необходимо обработать этот случай в своем приложении и повторить попытку в соответствующее время.
  • Производительность — если ваша транзакция содержит несколько операций чтения, записи и обновления, это может потребовать нескольких запросов к бэкэнду Cloud Firestore . На мобильном устройстве это может занять значительное время.
  • Частота записи — это решение может не подойти для часто обновляемых агрегированных данных, поскольку документы Cloud Firestore могут обновляться не чаще одного раза в секунду. Кроме того, если транзакция считывает документ, измененный вне транзакции, она повторяет попытку ограниченное количество раз , а затем завершается неудачей. Для решения проблемы с агрегированными данными, требующими более частых обновлений, можно использовать распределенные счетчики .

Решение: Агрегация во время записи с помощью Cloud Functions.

Если клиентские транзакции не подходят для вашего приложения, вы можете использовать облачную функцию для обновления сводной информации каждый раз, когда к ресторану добавляется новый рейтинг:

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

Это решение переносит работу с клиента на размещенную функцию, а это значит, что ваше мобильное приложение может добавлять оценки, не дожидаясь завершения транзакции. Код, выполняемый в облачной функции, не ограничен правилами безопасности, а это значит, что вам больше не нужно предоставлять клиентам доступ на запись к агрегированным данным.

Ограничения

Использование облачных функций для агрегирования позволяет избежать некоторых проблем, связанных с транзакциями на стороне клиента, но сопряжено с рядом других ограничений:

  • Стоимость — добавление каждого рейтинга приведет к вызову облачной функции, что может увеличить ваши затраты. Для получения дополнительной информации см. страницу с ценами на облачные функции.
  • Задержка — Перенося работу по агрегации данных в облачную функцию, ваше приложение не увидит обновленные данные до тех пор, пока облачная функция не завершит выполнение и клиент не получит уведомление о новых данных. В зависимости от скорости вашей облачной функции это может занять больше времени, чем выполнение транзакции локально.
  • Частота записи — это решение может не подойти для часто обновляемых агрегированных данных, поскольку документы Cloud Firestore могут обновляться не чаще одного раза в секунду. Кроме того, если транзакция считывает документ, измененный вне транзакции, она повторяет попытку ограниченное количество раз , а затем завершается неудачей. Для решения проблемы с агрегированными данными, требующими более частых обновлений, можно использовать распределенные счетчики .