צבירת נתונים בזמן כתיבה

שאילתות ב-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

Swift

הערה: המוצר הזה לא זמין ביעדים מסוגwatchOS ו-קליפ של אפליקציה.

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

Objective-C

הערה: המוצר הזה לא זמין ביעדים מסוגwatchOS ו-קליפ של אפליקציה.

FIRQuery *query = [[[self.db collectionWithPath:@"restaurants"]
    documentWithPath:@"arinell-pizza"] collectionWithPath:@"ratings"];
[query getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot,
                                    NSError * _Nullable error) {
  // ...
}];
FIRSolutionAggregationViewController.m

Kotlin+KTX

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

Swift

הערה: המוצר הזה לא זמין ביעדים מסוגwatchOS ו-קליפ של אפליקציה.

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 ו-קליפ של אפליקציה.

@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+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)
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

Swift

הערה: המוצר הזה לא זמין ביעדים מסוגwatchOS ו-קליפ של אפליקציה.

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

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

אם עסקאות בצד הלקוח לא מתאימות לאפליקציה שלכם, תוכלו להשתמש ב-Cloud Function כדי לעדכן את המידע המצטבר בכל פעם שמתווספת דירוג חדש למסעדה:

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 Function לא כפוף לכללי אבטחה, כלומר אין יותר צורך לתת ללקוחות הרשאת כתיבה לנתונים המצטברים.

מגבלות

השימוש בפונקציה של Cloud Functions לצבירת נתונים יכול למנוע חלק מהבעיות בטרנזקציות בצד הלקוח, אבל יש לו מגבלות שונות:

• עלות – כל דירוג נוסף יגרום להפעלה של Cloud Function, שעלולה להגדיל את העלויות. מידע נוסף זמין בדף התמחור של Cloud Functions.
• זמן אחזור – לאחר ביצוע העברה של עבודת הצבירה לפונקציה של Cloud Functions, האפליקציה לא תראה נתונים מעודכנים עד לסיום ההפעלה של הפונקציה של Cloud Functions והלקוח יקבל הודעה על הנתונים החדשים. בהתאם למהירות של Cloud Function, הפעולה הזו עשויה להימשך זמן רב יותר מביצוע העסקה באופן מקומי.
• שיעורי כתיבת – יכול להיות שהפתרון הזה לא יפעל עבור צבירות שמתעדכנות לעיתים קרובות, כי אפשר לעדכן מסמכים ב-Cloud Firestore רק פעם אחת בשנייה לכל היותר. בנוסף, אם טרנזקציה קוראת מסמך שהשתנה מחוץ לעסקה, היא מבצעת ניסיון חוזר מספר מוגבל של פעמים ואז נכשלת. לקבלת פתרון רלוונטי לפתרונות לצבירת נתונים שזקוקים לעדכונים תכופים יותר, תוכלו לעיין במונים מופצים.