Check out what’s new from Firebase at Google I/O 2022. Learn more

Toplama sorguları

Cloud Firestore'daki gelişmiş sorgular, büyük koleksiyonlardaki belgeleri hızla bulmanızı sağlar. Bir bütün olarak koleksiyonun özellikleri hakkında fikir edinmek istiyorsanız, bir koleksiyon üzerinde toplamaya ihtiyacınız olacaktır.

Cloud Firestore, yerel toplama sorgularını desteklemez. Ancak, verileriniz hakkında toplu bilgileri kolayca korumak için istemci tarafı işlemleri veya Bulut İşlevlerini kullanabilirsiniz.

Devam etmeden önce sorgular ve Cloud Firestore veri modeli hakkında bilgi edindiğinizden emin olun.

Çözüm: İstemci tarafı işlemler

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

ağ

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

Süratli

Not: Bu ürün, watchOS ve App Clip hedeflerinde mevcut değildir.
db.collection("restaurants")
    .document("arinell-pizza")
    .collection("ratings")
    .getDocuments() { (querySnapshot, err) in

        // ...

}
SolutionAggregationViewController.swift

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) {
  // ...
}];
FIRSolutionAggregationViewController.m

Java

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

Kotlin+KTX

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

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

ağ

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

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

    init(name: String, avgRating: Float, numRatings: Int) {
        self.name = name
        self.avgRating = avgRating
        self.numRatings = numRatings
    }

}

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

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
FIRSolutionAggregationViewController.m

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;
    }
}
tutucu9 l10n-yer
Restaurant arinell = new Restaurant("Arinell Pizza", 4.65, 683);
SolutionAggregation.java

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
)
tutucu11 l10n-yer
val arinell = Restaurant("Arinell Pizza", 4.65, 683)
SolutionAggregation.kt

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

ağ

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

Süratli

Not: Bu ürün, watchOS ve App Clip hedeflerinde mevcut değildir.
func addRatingTransaction(restaurantRef: DocumentReference, rating: Float) {
    let ratingRef: DocumentReference = restaurantRef.collection("ratings").document()

    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
    }) { (object, err) in
        // ...
    }
}
SolutionAggregationViewController.swift

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) {
    // ...
  }];
}
FIRSolutionAggregationViewController.m

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

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
    }
}
SolutionAggregation.kt

Bir işlemin kullanılması, toplu verilerinizin temel alınan koleksiyonla tutarlı olmasını sağlar. Cloud Firestore'daki işlemler hakkında daha fazla bilgi edinmek için İşlemler ve Toplu Yazmalar bölümüne bakın.

sınırlamalar

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

  • Güvenlik - İstemci tarafı işlemler, müşterilere 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şlemler 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 çok okuma, yazma ve güncelleme işlemi içeriyorsa, Cloud Firestore arka ucuna birden çok istek gerektirebilir. Bir mobil cihazda bu işlem önemli ölçüde zaman alabilir.
  • Yazma oranları - Cloud Firestore belgeleri yalnızca saniyede en fazla bir kez güncellenebildiğinden, bu çözüm sık güncellenen toplamalar için çalışmayabilir. 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 toplamalar için ilgili bir geçici çözüm için dağıtılmış sayaçlara göz atın.

Çözüm: Bulut İşlevleri

İstemci tarafı işlemler 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
        });
      });
    });
index.js

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. Bir 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 bir Bulut İşlevi kullanmak, istemci tarafı işlemlerle ilgili bazı sorunları önler, ancak farklı bir dizi sınırlama ile birlikte gelir:

  • Maliyet - Eklenen her derecelendirme, maliyetlerinizi artırabilecek bir Bulut İşlevi çağrısına neden olur. Daha fazla bilgi için Cloud Functions fiyatlandırma sayfasına bakın .
  • Gecikme - Toplama çalışmasını bir Bulut İşlevine devrederek, uygulamanız Bulut İşlevi yürütmeyi bitirene ve müşteriye yeni veriler konusunda bilgilendirilene kadar güncellenmiş verileri görmez. Bulut İşlevinizin hızına bağlı olarak bu, işlemi yerel olarak yürütmekten daha uzun sürebilir.
  • Yazma oranları - Cloud Firestore belgeleri yalnızca saniyede en fazla bir kez güncellenebildiğinden, bu çözüm sık güncellenen toplamalar için çalışmayabilir. 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 toplamalar için ilgili bir geçici çözüm için dağıtılmış sayaçlara göz atın.