Yazma zamanı toplamaları

Cloud Firestore'daki sorgular, büyük koleksiyonlardaki belgeleri bulmanızı sağlar. Koleksiyonun özelliklerine bir bütün olarak ilişkin fikir edinmek için verileri bir koleksiyon üzerinde toplayabilirsiniz.

Verileri okuma veya yazma sırasında toplayabilirsiniz:

  • Okuma zamanı toplamaları, istek anında bir sonuç hesaplar. Cloud Firestore, okuma sırasında count() , sum() ve average() toplama sorgularını destekler. Okuma zamanı toplama sorgularının uygulamanıza eklenmesi, yazma zamanı toplamalarına göre daha kolaydır. Toplama sorguları hakkında daha fazla bilgi için bkz . Verileri toplama sorgularıyla özetleme .

  • Yazma zamanı toplamaları, uygulamanın ilgili bir yazma işlemi gerçekleştirdiği her seferde bir sonuç hesaplar. Yazma zamanı toplamalarının uygulanması daha fazla iş gerektirir ancak aşağıdaki nedenlerden birinden dolayı okuma zamanı toplamaları yerine bunları kullanabilirsiniz:

    • Gerçek zamanlı güncellemeler için toplama sonucunu dinlemek istiyorsunuz. count() , sum() ve average() toplama sorguları gerçek zamanlı güncellemeleri desteklemez.
    • Toplama sonucunu istemci tarafı önbelleğinde depolamak istiyorsunuz. count() , sum() ve average() toplama sorguları önbelleğe almayı desteklemez.
    • Kullanıcılarınızın her biri için on binlerce belgeden veri topluyorsunuz ve maliyetleri değerlendiriyorsunuz. Daha az sayıda belgede okuma süresi toplamanın maliyeti daha düşük olur. Bir toplamalardaki çok sayıda belge için yazma süresi toplamalarının maliyeti daha düşük olabilir.

İstemci tarafı bir işlemi veya Cloud Functions'ı kullanarak bir yazma zamanı toplama uygulayabilirsiniz. Aşağıdaki bölümlerde yazma zamanı toplamalarının nasıl uygulanacağı açıklanmaktadır.

Çözüm: İstemci tarafı işlemiyle yazma zamanı toplama

Kullanıcıların harika restoranlar bulmasına yardımcı olan yerel öneriler uygulamasını düşünün. Aşağıdaki sorgu belirli bir restorana ilişkin tüm derecelendirmeleri alır:

db.collection("restaurants")
  .doc("arinell-pizza")
  .collection("ratings")
  .get();

Süratli

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
do {
  let snapshot = try await db.collection("restaurants")
    .document("arinell-pizza")
    .collection("ratings")
    .getDocuments()
  print(snapshot)
} catch {
  print(error)
}

Amaç-C

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
FIRQuery *query = [[[self.db collectionWithPath:@"restaurants"]
    documentWithPath:@"arinell-pizza"] collectionWithPath:@"ratings"];
[query getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot,
                                    NSError * _Nullable error) {
  // ...
}];

Kotlin+KTX

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

Java

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

Tüm derecelendirmeleri alıp ardından toplu bilgileri hesaplamak yerine, bu bilgileri restoran belgesinin kendisinde saklayabiliriz:

var arinellDoc = {
  name: 'Arinell Pizza',
  avgRating: 4.65,
  numRatings: 683
};

Süratli

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
struct Restaurant {

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

}

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

Amaç-C

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
@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+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)

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);

Bu toplamaların tutarlı kalmasını sağlamak için, alt koleksiyona her yeni derecelendirme eklendiğinde bunların güncellenmesi gerekir. Tutarlılığa ulaşmanın bir yolu, ekleme ve güncellemeyi tek bir işlemde gerçekleştirmektir:

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 });
        });
    });
}

Süratli

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
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 {
    // ...
  }
}

Amaç-C

Not: Bu ürün watchOS ve App Clip hedeflerinde mevcut değildir.
- (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+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
    }
}

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;
        }
    });
}

Bir işlemin kullanılması, toplu verilerinizin temel koleksiyonla tutarlı olmasını sağlar. Cloud Firestore'daki işlemler hakkında daha fazla bilgi edinmek için bkz. İşlemler ve Toplu Yazmalar .

Sınırlamalar

Yukarıda gösterilen çözüm, Cloud Firestore istemci kitaplığı kullanılarak verilerin toplanmasını göstermektedir ancak aşağıdaki sınırlamaların farkında olmalısınız:

  • Güvenlik - İstemci tarafı işlemleri, istemcilere veritabanınızdaki toplu verileri güncelleme izni verilmesini gerektirir. Gelişmiş güvenlik kuralları yazarak bu yaklaşımın risklerini azaltabilirsiniz ancak bu her durumda uygun olmayabilir.
  • Çevrimdışı destek - Kullanıcının cihazı çevrimdışı olduğunda istemci tarafı işlemleri başarısız olur; bu, bu durumu uygulamanızda ele almanız ve uygun zamanda yeniden denemeniz gerektiği anlamına gelir.
  • Performans - İşleminiz birden fazla okuma, yazma ve güncelleme işlemi içeriyorsa Cloud Firestore arka ucuna birden fazla istek yapılması gerekebilir. Bir mobil cihazda bu oldukça zaman alabilir.
  • Yazma hızları - Cloud Firestore belgeleri yalnızca saniyede en fazla bir kez güncellenebildiğinden bu çözüm sık sık güncellenen toplamalar için işe yaramayabilir. Ayrıca, bir işlem, işlemin dışında değiştirilmiş bir belgeyi okursa, sınırlı sayıda yeniden dener ve ardından başarısız olur. Daha sık güncelleme gerektiren toplamalara yönelik ilgili geçici çözüm için dağıtılmış sayaçlara göz atın.

Çözüm: Cloud Functions ile yazma zamanı toplama

İstemci tarafı işlemleri uygulamanız için uygun değilse, bir restorana her yeni derecelendirme eklendiğinde toplu bilgileri güncellemek için bir Bulut İşlevi kullanabilirsiniz:

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
        });
      });
    });

Bu çözüm, işi istemciden barındırılan bir işleve aktarır; bu, mobil uygulamanızın bir işlemin tamamlanmasını beklemeden derecelendirme ekleyebileceği anlamına gelir. Bulut İşlevinde yürütülen kod, güvenlik kurallarına bağlı değildir; bu, artık istemcilere toplu verilere yazma erişimi vermeniz gerekmediği anlamına gelir.

Sınırlamalar

Toplamalar için Bulut İşlevinin kullanılması, istemci tarafı işlemlerle ilgili bazı sorunları ortadan kaldırır ancak farklı sınırlamalarla birlikte gelir:

  • Maliyet - Eklenen her derecelendirme, Bulut İşlevinin başlatılmasına neden olur ve bu da maliyetlerinizi artırabilir. Daha fazla bilgi için Bulut İşlevleri fiyatlandırma sayfasına bakın.
  • Gecikme - Toplama işini bir Bulut İşlevine devrettiğinizde, Bulut İşlevinin yürütülmesi bitene ve istemciye yeni veriler bildirilinceye kadar uygulamanız güncellenmiş verileri görmez. Bulut İşlevinizin hızına bağlı olarak bu işlem, işlemin yerel olarak yürütülmesinden daha uzun sürebilir.
  • Yazma hızları - Cloud Firestore belgeleri yalnızca saniyede en fazla bir kez güncellenebildiğinden bu çözüm sık sık güncellenen toplamalar için işe yaramayabilir. Ayrıca, bir işlem, işlemin dışında değiştirilmiş bir belgeyi okursa, sınırlı sayıda yeniden dener ve ardından başarısız olur. Daha sık güncelleme gerektiren toplamalara yönelik ilgili geçici çözüm için dağıtılmış sayaçlara göz atın.