Nhiều ứng dụng theo thời gian thực có tài liệu đóng vai trò là bộ đếm. Ví dụ: bạn có thể số lượt 'lượt thích' về một bài đăng hoặc 'video yêu thích' của một mặt hàng cụ thể.
Trong Cloud Firestore, bạn không thể cập nhật một tài liệu với tốc độ không giới hạn. Nếu bạn có bộ đếm dựa trên một tài liệu duy nhất và số lần tăng đủ thường xuyên của bộ đếm đó, thì cuối cùng bạn sẽ thấy tranh chấp về các bản cập nhật cho tài liệu. Xem phần Nội dung cập nhật cho một tài liệu.
Giải pháp: Bộ đếm được phân phối
Để hỗ trợ việc cập nhật bộ đếm thường xuyên hơn, hãy tạo một bộ đếm được phân phối. Mỗi bộ đếm là một tài liệu có một tập hợp con "phân đoạn" và giá trị của bộ đếm là tổng giá trị của các phân đoạn.
Thông lượng ghi tăng tuyến tính với số lượng phân đoạn, do đó một phân đoạn được phân phối bộ đếm có 10 phân đoạn có thể xử lý số lần ghi gấp 10 lần so với bộ đếm truyền thống.
Web
// counters/${ID}
{
"num_shards": NUM_SHARDS,
"shards": [subcollection]
}
// counters/${ID}/shards/${NUM}
{
"count": 123
}
Swift
// counters/${ID} struct Counter { let numShards: Int init(numShards: Int) { self.numShards = numShards } } // counters/${ID}/shards/${NUM} struct Shard { let count: Int init(count: Int) { self.count = count } }
Objective-C
// counters/${ID} @interface FIRCounter : NSObject @property (nonatomic, readonly) NSInteger shardCount; @end @implementation FIRCounter - (instancetype)initWithShardCount:(NSInteger)shardCount { self = [super init]; if (self != nil) { _shardCount = shardCount; } return self; } @end // counters/${ID}/shards/${NUM} @interface FIRShard : NSObject @property (nonatomic, readonly) NSInteger count; @end @implementation FIRShard - (instancetype)initWithCount:(NSInteger)count { self = [super init]; if (self != nil) { _count = count; } return self; } @end
Kotlin+KTX
// counters/${ID} data class Counter(var numShards: Int) // counters/${ID}/shards/${NUM} data class Shard(var count: Int)
Java
// counters/${ID} public class Counter { int numShards; public Counter(int numShards) { this.numShards = numShards; } } // counters/${ID}/shards/${NUM} public class Shard { int count; public Shard(int count) { this.count = count; } }
Python
Python
Node.js
Không áp dụng, hãy xem đoạn mã tăng bộ đếm bên dưới.
Tiến hành
PHP
Không áp dụng, hãy xem đoạn mã khởi chạy bộ đếm bên dưới.
C#
Đoạn mã sau đây khởi chạy một bộ đếm phân phối:
Web
function createCounter(ref, num_shards) { var batch = db.batch(); // Initialize the counter document batch.set(ref, { num_shards: num_shards }); // Initialize each shard with count=0 for (let i = 0; i < num_shards; i++) { const shardRef = ref.collection('shards').doc(i.toString()); batch.set(shardRef, { count: 0 }); } // Commit the write batch return batch.commit(); }
Swift
func createCounter(ref: DocumentReference, numShards: Int) async { do { try await ref.setData(["numShards": numShards]) for i in 0...numShards { try await ref.collection("shards").document(String(i)).setData(["count": 0]) } } catch { // ... } }
Objective-C
- (void)createCounterAtReference:(FIRDocumentReference *)reference shardCount:(NSInteger)shardCount { [reference setData:@{ @"numShards": @(shardCount) } completion:^(NSError * _Nullable error) { for (NSInteger i = 0; i < shardCount; i++) { NSString *shardName = [NSString stringWithFormat:@"%ld", (long)shardCount]; [[[reference collectionWithPath:@"shards"] documentWithPath:shardName] setData:@{ @"count": @(0) }]; } }]; }
Kotlin+KTX
fun createCounter(ref: DocumentReference, numShards: Int): Task<Void> { // Initialize the counter document, then initialize each shard. return ref.set(Counter(numShards)) .continueWithTask { task -> if (!task.isSuccessful) { throw task.exception!! } val tasks = arrayListOf<Task<Void>>() // Initialize each shard with count=0 for (i in 0 until numShards) { val makeShard = ref.collection("shards") .document(i.toString()) .set(Shard(0)) tasks.add(makeShard) } Tasks.whenAll(tasks) } }
Java
public Task<Void> createCounter(final DocumentReference ref, final int numShards) { // Initialize the counter document, then initialize each shard. return ref.set(new Counter(numShards)) .continueWithTask(new Continuation<Void, Task<Void>>() { @Override public Task<Void> then(@NonNull Task<Void> task) throws Exception { if (!task.isSuccessful()) { throw task.getException(); } List<Task<Void>> tasks = new ArrayList<>(); // Initialize each shard with count=0 for (int i = 0; i < numShards; i++) { Task<Void> makeShard = ref.collection("shards") .document(String.valueOf(i)) .set(new Shard(0)); tasks.add(makeShard); } return Tasks.whenAll(tasks); } }); }
Python
Python
Node.js
Không áp dụng, hãy xem đoạn mã tăng bộ đếm bên dưới.
Tiến hành
PHP
C#
Ruby
Để tăng bộ đếm, hãy chọn một phân đoạn ngẫu nhiên và tăng dần số lượng:
Web
function incrementCounter(ref, num_shards) { // Select a shard of the counter at random const shard_id = Math.floor(Math.random() * num_shards).toString(); const shard_ref = ref.collection('shards').doc(shard_id); // Update count return shard_ref.update("count", firebase.firestore.FieldValue.increment(1)); }
Swift
func incrementCounter(ref: DocumentReference, numShards: Int) { // Select a shard of the counter at random let shardId = Int(arc4random_uniform(UInt32(numShards))) let shardRef = ref.collection("shards").document(String(shardId)) shardRef.updateData([ "count": FieldValue.increment(Int64(1)) ]) }
Objective-C
- (void)incrementCounterAtReference:(FIRDocumentReference *)reference shardCount:(NSInteger)shardCount { // Select a shard of the counter at random NSInteger shardID = (NSInteger)arc4random_uniform((uint32_t)shardCount); NSString *shardName = [NSString stringWithFormat:@"%ld", (long)shardID]; FIRDocumentReference *shardReference = [[reference collectionWithPath:@"shards"] documentWithPath:shardName]; [shardReference updateData:@{ @"count": [FIRFieldValue fieldValueForIntegerIncrement:1] }]; }
Kotlin+KTX
fun incrementCounter(ref: DocumentReference, numShards: Int): Task<Void> { val shardId = Math.floor(Math.random() * numShards).toInt() val shardRef = ref.collection("shards").document(shardId.toString()) return shardRef.update("count", FieldValue.increment(1)) }
Java
public Task<Void> incrementCounter(final DocumentReference ref, final int numShards) { int shardId = (int) Math.floor(Math.random() * numShards); DocumentReference shardRef = ref.collection("shards").document(String.valueOf(shardId)); return shardRef.update("count", FieldValue.increment(1)); }
Python
Python
Node.js
Tiến hành
PHP
C#
Ruby
Để biết tổng số lượng, hãy truy vấn tất cả phân đoạn và tính tổng các trường count
của các phân đoạn đó:
Web
function getCount(ref) { // Sum the count of each shard in the subcollection return ref.collection('shards').get().then((snapshot) => { let total_count = 0; snapshot.forEach((doc) => { total_count += doc.data().count; }); return total_count; }); }
Swift
func getCount(ref: DocumentReference) async { do { let querySnapshot = try await ref.collection("shards").getDocuments() var totalCount = 0 for document in querySnapshot.documents { let count = document.data()["count"] as! Int totalCount += count } print("Total count is \(totalCount)") } catch { // handle error } }
Objective-C
- (void)getCountWithReference:(FIRDocumentReference *)reference { [[reference collectionWithPath:@"shards"] getDocumentsWithCompletion:^(FIRQuerySnapshot *snapshot, NSError *error) { NSInteger totalCount = 0; if (error != nil) { // Error getting shards // ... } else { for (FIRDocumentSnapshot *document in snapshot.documents) { NSInteger count = [document[@"count"] integerValue]; totalCount += count; } NSLog(@"Total count is %ld", (long)totalCount); } }]; }
Kotlin+KTX
fun getCount(ref: DocumentReference): Task<Int> { // Sum the count of each shard in the subcollection return ref.collection("shards").get() .continueWith { task -> var count = 0 for (snap in task.result!!) { val shard = snap.toObject<Shard>() count += shard.count } count } }
Java
public Task<Integer> getCount(final DocumentReference ref) { // Sum the count of each shard in the subcollection return ref.collection("shards").get() .continueWith(new Continuation<QuerySnapshot, Integer>() { @Override public Integer then(@NonNull Task<QuerySnapshot> task) throws Exception { int count = 0; for (DocumentSnapshot snap : task.getResult()) { Shard shard = snap.toObject(Shard.class); count += shard.count; } return count; } }); }
Python
Python
Node.js
Tiến hành
PHP
C#
Ruby
Các điểm hạn chế
Giải pháp nêu trên là cách có thể mở rộng để tạo bộ đếm dùng chung trong Cloud Firestore, nhưng bạn cần lưu ý các hạn chế sau:
- Số lượng phân đoạn - Số lượng phân đoạn kiểm soát hiệu suất của bộ đếm phân phối. Với quá ít phân đoạn, một số giao dịch có thể phải thử lại thì mới thành công. Thao tác này sẽ làm chậm quá trình ghi. Có quá nhiều phân đoạn, việc đọc trở nên chậm hơn và tốn kém hơn. Bạn có thể bù trừ chi phí đọc bằng cách lưu tổng số bộ đếm trong một tài liệu tổng hợp riêng được cập nhật với tần suất chậm hơn và khách hàng đọc từ tài liệu đó để biết tổng số. Sự đánh đổi ở đây là khách hàng sẽ phải đợi tài liệu tổng hợp được cập nhật, thay vào đó, bằng cách đọc tất cả các phân đoạn ngay sau khi cập nhật.
- Chi phí – Chi phí đọc giá trị bộ đếm tăng tuyến tính với số lượng phân đoạn, vì phải tải toàn bộ bộ sưu tập con của phân đoạn.