Yazma zamanı toplamaları

Cloud Firestore'daki sorgular, büyük koleksiyonlardaki dokümanları bulmanıza olanak tanır. Koleksiyonun genel özellikleri hakkında bilgi edinmek için koleksiyon genelinde verileri toplayabilirsiniz.

Verileri okuma veya yazma sırasında toplayabilirsiniz:

• Okuma süresi toplamaları, istek sırasında bir sonuç hesaplar. Cloud Firestore, okuma sırasında count(), sum() ve average() toplama sorgularını destekler. Okuma zamanı toplama sorgularını, yazma zamanı toplamalarına kıyasla uygulamanıza eklemek daha kolaydır. Toplama sorguları hakkında daha fazla bilgi için Toplama sorgularıyla verileri özetleme başlıklı makaleyi inceleyin.

• Yazma zamanı toplamaları, uygulama her alakalı yazma işlemi gerçekleştirdiğinde bir sonuç hesaplar. Yazma zamanı toplamalarının uygulanması daha fazla iş gerektirir ancak aşağıdaki nedenlerden biriyle okuma zamanı toplamaları yerine bunları kullanabilirsiniz:

  • Anlık güncellemeler için toplama sonucunu dinlemek istiyorsunuz. count(), sum() ve average() toplama sorguları, anlık güncellemeleri desteklemez.
  • Toplama sonucunu istemci tarafı önbelleğinde saklamak istiyorsanız. count(), sum() ve average() toplama sorguları önbelleğe almayı desteklemez.
  • Her bir kullanıcınız için on binlerce dokümandaki verileri topluyor ve maliyetleri göz önünde bulunduruyorsunuz. Daha az sayıda belgede okuma süresi toplamaları daha az maliyetlidir. Toplamalarda çok sayıda belge varsa yazma zamanı toplamaları daha az maliyetli olabilir.

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

Çözüm: İstemci tarafı işlemle 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 ait tüm puanları alır:

Web

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

Swift

Not: Bu ürün, watchOS ve App Clip hedeflerinde kullanılamaz.

do {
  let snapshot = try await db.collection("restaurants")
    .document("arinell-pizza")
    .collection("ratings")
    .getDocuments()
  print(snapshot)
} catch {
  print(error)
}
SolutionAggregationViewController.swift

Objective-C

Not: Bu ürün, watchOS ve App Clip hedeflerinde kullanılamaz.

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

Tüm puanları getirip toplu bilgileri hesaplamak yerine bu bilgileri restoran belgesinde saklayabiliriz:

Web

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

Swift

Not: Bu ürün, watchOS ve App Clip hedeflerinde kullanılamaz.

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

Not: Bu ürün, watchOS ve App Clip hedeflerinde kullanılamaz.

@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

Bu toplamaların tutarlı kalması için, alt koleksiyona yeni bir derecelendirme eklendiğinde güncellenmeleri gerekir. Tutarlılık sağlamanın bir yolu, ekleme ve güncelleme işlemlerini tek bir işlemde gerçekleştirmektir:

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

Not: Bu ürün, watchOS ve App Clip hedeflerinde kullanılamaz.

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

Not: Bu ürün, watchOS ve App Clip hedeflerinde kullanılamaz.

- (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

İşlem kullanmak, toplu verilerinizin temel koleksiyonla tutarlı olmasını sağlar. Cloud Firestore işlemler hakkında daha fazla bilgi edinmek için İşlemler ve Toplu Yazmalar başlıklı makaleyi inceleyin.

Sınırlamalar

Yukarıda gösterilen çözümde, verilerin Cloud Firestore istemci kitaplığı kullanılarak nasıl toplandığı gösterilmektedir. Ancak aşağıdaki sınırlamaları göz önünde bulundurmanız gerekir:

• Güvenlik: İstemci tarafı işlemler, müşterilere veritabanınızdaki toplu verileri güncelleme izni vermenizi gerektirir. Gelişmiş güvenlik kuralları yazarak bu yaklaşımın risklerini azaltabilirsiniz ancak bu yöntem her durumda uygun olmayabilir.
• Çevrimdışı destek: Kullanıcının cihazı çevrimdışı olduğunda istemci tarafı işlemler başarısız olur. Bu durumda, bu durumu uygulamanızda ele almanız ve uygun zamanda yeniden denemeniz gerekir.
• Performans: İşleminiz birden fazla okuma, yazma ve güncelleme işlemi içeriyorsa Cloud Firestore arka ucuna birden fazla istek gönderilmesi gerekebilir. Mobil cihazlarda bu işlem önemli ölçüde zaman alabilir.
• Yazma sıklığı: Cloud Firestore belgeleri en fazla saniyede bir kez güncellenebildiğinden bu çözüm, sık güncellenen toplamalarda işe yaramayabilir. Ayrıca, bir işlem, işlem dışında değiştirilmiş bir dokümanı okursa sınırlı sayıda yeniden denenir ve ardından başarısız olur. Daha sık güncellenmesi gereken toplamalar için ilgili geçici çözümü dağıtılmış sayaçlar bölümünde bulabilirsiniz.

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

İstemci tarafı işlemleri uygulamanız için uygun değilse bir Cloud Function kullanarak bir restorana her yeni puan eklendiğinde toplu bilgileri güncelleyebilirsiniz:

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

Bu çözüm, işi istemciden barındırılan bir işleve aktarır. Bu sayede mobil uygulamanız, işlemin tamamlanmasını beklemeden derecelendirme ekleyebilir. Cloud Functions'da yürütülen kod, güvenlik kurallarına bağlı değildir. Bu nedenle, artık istemcilere toplu veriler için yazma erişimi vermeniz gerekmez.

Sınırlamalar

Toplamalar için Cloud Functions kullanmak, istemci tarafı işlemlerle ilgili bazı sorunları önler ancak farklı bir sınırlama grubuyla birlikte gelir:

• Maliyet: Eklenen her puan, Cloud Function çağrılmasına neden olur. Bu durum maliyetlerinizi artırabilir. Daha fazla bilgi için Cloud Functions fiyatlandırma sayfasına bakın.
• Gecikme: Toplama işini bir Cloud Functions işlevine devrederek uygulamanız, Cloud Functions işlevi yürütmeyi bitirene ve istemci yeni veriler hakkında bilgilendirilene kadar güncellenmiş verileri görmez. Cloud Functions işlevinizin hızına bağlı olarak bu işlem, işlemi yerel olarak yürütmekten daha uzun sürebilir.
• Yazma sıklığı: Cloud Firestore belgeleri en fazla saniyede bir kez güncellenebildiğinden bu çözüm, sık güncellenen toplamalarda işe yaramayabilir. Ayrıca, bir işlem, işlem dışında değiştirilmiş bir dokümanı okursa sınırlı sayıda yeniden denenir ve ardından başarısız olur. Daha sık güncellenmesi gereken toplamalar için ilgili geçici çözümü dağıtılmış sayaçlar bölümünde bulabilirsiniz.