การรวมเวลาเขียน

การค้นหาใน 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 และ 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+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 และ 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+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 และ 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+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 อัปเดตได้สูงสุดเท่านั้น 1 ครั้งต่อวินาที นอกจากนี้ หากธุรกรรมอ่านเอกสารที่ ถูกแก้ไขภายนอกธุรกรรม และลองใหม่ตามจำนวนครั้งที่จำกัด จากนั้นก็ล้มเหลว ดูตัวนับแบบกระจาย สำหรับวิธีแก้ไขปัญหาชั่วคราวที่เกี่ยวข้องสำหรับการรวบรวมข้อมูลที่ต้องมีการอัปเดตบ่อยขึ้น

โซลูชัน: การรวมเวลาเขียนด้วย 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 Function สำหรับการรวมจะหลีกเลี่ยงปัญหาบางประการเกี่ยวกับ ธุรกรรมฝั่งไคลเอ็นต์ แต่มาพร้อมกับชุดข้อจำกัดที่แตกต่างกัน

• ค่าใช้จ่าย - การจัดประเภทแต่ละรายการที่เพิ่มจะก่อให้เกิดการเรียกใช้ Cloud Function ซึ่ง อาจเพิ่มค่าใช้จ่ายของคุณ ดูข้อมูลเพิ่มเติมได้ที่ Cloud Functions หน้าราคา
• เวลาในการตอบสนอง - การลดภาระงานการรวมไปยัง Cloud Function แอปจะไม่เห็นข้อมูลที่อัปเดตจนกว่า Cloud Function จะเสร็จสิ้น ขณะดำเนินการ และลูกค้าได้รับแจ้งข้อมูลใหม่แล้ว ขึ้นอยู่กับ ความเร็วของ Cloud Function ซึ่งอาจใช้เวลานานกว่าการเรียกใช้ฟังก์ชัน ธุรกรรมภายในเครื่อง
• อัตราการเขียน - โซลูชันนี้อาจใช้งานไม่ได้กับการอัปเดตบ่อย การรวมเนื่องจากเอกสาร Cloud Firestore อัปเดตได้สูงสุดเท่านั้น 1 ครั้งต่อวินาที นอกจากนี้ หากธุรกรรมอ่านเอกสารที่ ถูกแก้ไขภายนอกธุรกรรม และลองใหม่จำนวนครั้งที่จำกัด จากนั้นก็ล้มเหลว ดูตัวนับแบบกระจาย สำหรับวิธีแก้ไขปัญหาชั่วคราวที่เกี่ยวข้องสำหรับการรวบรวมข้อมูลที่ต้องมีการอัปเดตบ่อยขึ้น