বিতরণ কাউন্টার

অনেক রিয়েলটাইম অ্যাপের নথি আছে যা কাউন্টার হিসেবে কাজ করে। উদাহরণস্বরূপ, আপনি একটি পোস্টে 'লাইক' বা একটি নির্দিষ্ট আইটেমের 'প্রিয়' গণনা করতে পারেন।

Cloud Firestore , আপনি সীমাহীন হারে একটি একক নথি আপডেট করতে পারবেন না। আপনার যদি একক নথির উপর ভিত্তি করে একটি কাউন্টার থাকে এবং এতে ঘন ঘন পর্যাপ্ত পরিমাণ বৃদ্ধি পায় তাহলে আপনি শেষ পর্যন্ত নথির আপডেট নিয়ে বিতর্ক দেখতে পাবেন। একটি একক নথির আপডেট দেখুন।

সমাধান: বিতরণ কাউন্টার

আরও ঘন ঘন কাউন্টার আপডেট সমর্থন করতে, একটি বিতরণ কাউন্টার তৈরি করুন। প্রতিটি কাউন্টার হল একটি নথি যার একটি উপ-সংগ্রহ "শার্ডস" এবং কাউন্টারের মান হল শার্ডগুলির মানের সমষ্টি।

থ্রুপুট লিখুন শার্ডের সংখ্যার সাথে রৈখিকভাবে বৃদ্ধি পায়, তাই 10 টি শার্ড সহ একটি বিতরণ করা কাউন্টার একটি ঐতিহ্যগত কাউন্টার হিসাবে 10x রাইটিং পরিচালনা করতে পারে।

ওয়েব

// counters/${ID}
{
  "num_shards": NUM_SHARDS,
  "shards": [subcollection]
}

// counters/${ID}/shards/${NUM}
{
  "count": 123
}

সুইফট

দ্রষ্টব্য: এই পণ্যটি watchOS এবং অ্যাপ ক্লিপ লক্ষ্যে উপলব্ধ নয়।

// 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
  }
}
SolutionCountersViewController.swift

উদ্দেশ্য-C

দ্রষ্টব্য: এই পণ্যটি watchOS এবং অ্যাপ ক্লিপ লক্ষ্যে উপলব্ধ নয়।

// 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
FIRSolutionCountersViewController.m

Kotlin

// counters/${ID}
data class Counter(var numShards: Int)

// counters/${ID}/shards/${NUM}
data class Shard(var count: Int)
SolutionCounters.kt

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;
    }
}
SolutionCounters.java

পাইথন

import random

from google.cloud import firestore


class Shard:
    """
    A shard is a distributed counter. Each shard can support being incremented
    once per second. Multiple shards are needed within a Counter to allow
    more frequent incrementing.
    """

    def __init__(self):
        self._count = 0

    def to_dict(self):
        return {"count": self._count}


class Counter:
    """
    A counter stores a collection of shards which are
    summed to return a total count. This allows for more
    frequent incrementing than a single document.
    """

    def __init__(self, num_shards):
        self._num_shards = num_shards
distributed_counters.py

Python

import random

from google.cloud import firestore


class Shard:
    """
    A shard is a distributed counter. Each shard can support being incremented
    once per second. Multiple shards are needed within a Counter to allow
    more frequent incrementing.
    """

    def __init__(self):
        self._count = 0

    def to_dict(self):
        return {"count": self._count}


class Counter:
    """
    A counter stores a collection of shards which are
    summed to return a total count. This allows for more
    frequent incrementing than a single document.
    """

    def __init__(self, num_shards):
        self._num_shards = num_shards
distributed_counters.py

Node.js

প্রযোজ্য নয়, নীচে কাউন্টার ইনক্রিমেন্ট স্নিপেট দেখুন।

যাও

import (
	"context"
	"fmt"
	"math/rand"
	"strconv"

	"cloud.google.com/go/firestore"
	"google.golang.org/api/iterator"
)

// Counter is a collection of documents (shards)
// to realize counter with high frequency.
type Counter struct {
	numShards int
}

// Shard is a single counter, which is used in a group
// of other shards within Counter.
type Shard struct {
	Count int
}
solution_counters.go

পিএইচপি

প্রযোজ্য নয়, নীচের কাউন্টার ইনিশিয়ালাইজেশন স্নিপেটটি দেখুন।

সি#

/// <summary>
/// Shard is a document that contains the count.
/// </summary>
[FirestoreData]
public class Shard
{
    [FirestoreProperty(name: "count")]
    public int Count { get; set; }
}
Program.cs

নিম্নলিখিত কোড একটি বিতরণ কাউন্টার আরম্ভ করে:

ওয়েব

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();
}
test.solution-counters.js

সুইফট

দ্রষ্টব্য: এই পণ্যটি watchOS এবং অ্যাপ ক্লিপ লক্ষ্যে উপলব্ধ নয়।

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 {
    // ...
  }
}
SolutionCountersViewController.swift

উদ্দেশ্য-C

দ্রষ্টব্য: এই পণ্যটি watchOS এবং অ্যাপ ক্লিপ লক্ষ্যে উপলব্ধ নয়।

- (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) }];
    }
  }];
}
FIRSolutionCountersViewController.m

Kotlin

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)
        }
}
SolutionCounters.kt

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);
                }
            });
}
SolutionCounters.java

পাইথন

def init_counter(self, doc_ref):
    """
    Create a given number of shards as
    subcollection of specified document.
    """
    col_ref = doc_ref.collection("shards")

    # Initialize each shard with count=0
    for num in range(self._num_shards):
        shard = Shard()
        col_ref.document(str(num)).set(shard.to_dict())
distributed_counters.py

Python

async def init_counter(self, doc_ref):
    """
    Create a given number of shards as
    subcollection of specified document.
    """
    col_ref = doc_ref.collection("shards")

    # Initialize each shard with count=0
    for num in range(self._num_shards):
        shard = Shard()
        await col_ref.document(str(num)).set(shard.to_dict())
distributed_counters.py

Node.js

প্রযোজ্য নয়, নীচে কাউন্টার ইনক্রিমেন্ট স্নিপেট দেখুন।

যাও

// initCounter creates a given number of shards as
// subcollection of specified document.
func (c *Counter) initCounter(ctx context.Context, docRef *firestore.DocumentRef) error {
	colRef := docRef.Collection("shards")

	// Initialize each shard with count=0
	for num := 0; num < c.numShards; num++ {
		shard := Shard{0}

		if _, err := colRef.Doc(strconv.Itoa(num)).Set(ctx, shard); err != nil {
			return fmt.Errorf("Set: %w", err)
		}
	}
	return nil
}
solution_counters.go

পিএইচপি

$numShards = 10;
$ref = $db->collection('samples/php/distributedCounters');
for ($i = 0; $i < $numShards; $i++) {
    $doc = $ref->document((string) $i);
    $doc->set(['Cnt' => 0]);
}
solution_sharded_counter_create.php

সি#

/// <summary>
/// Create a given number of shards as a
/// subcollection of specified document.
/// </summary>
/// <param name="docRef">The document reference <see cref="DocumentReference"/></param>
private static async Task CreateCounterAsync(DocumentReference docRef, int numOfShards)
{
    CollectionReference colRef = docRef.Collection("shards");
    var tasks = new List<Task>();
    // Initialize each shard with Count=0
    for (var i = 0; i < numOfShards; i++)
    {
        tasks.Add(colRef.Document(i.ToString()).SetAsync(new Shard() { Count = 0 }));
    }
    await Task.WhenAll(tasks);
}
Program.cs

রুবি

# project_id = "Your Google Cloud Project ID"
# num_shards = "Number of shards for distributed counter"
# collection_path = "shards"

require "google/cloud/firestore"

firestore = Google::Cloud::Firestore.new project_id: project_id

shards_ref = firestore.col collection_path

# Initialize each shard with count=0
num_shards.times do |i|
  shards_ref.doc(i).set({ count: 0 })
end

puts "Distributed counter shards collection created."
distributed_counters.rb

কাউন্টার বৃদ্ধি করতে, একটি র্যান্ডম শার্ড চয়ন করুন এবং গণনা বৃদ্ধি করুন:

ওয়েব

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));
}
test.solution-counters.js

সুইফট

দ্রষ্টব্য: এই পণ্যটি watchOS এবং অ্যাপ ক্লিপ লক্ষ্যে উপলব্ধ নয়।

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))
  ])
}
SolutionCountersViewController.swift

উদ্দেশ্য-C

দ্রষ্টব্য: এই পণ্যটি watchOS এবং অ্যাপ ক্লিপ লক্ষ্যে উপলব্ধ নয়।

- (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]
  }];
}
FIRSolutionCountersViewController.m

Kotlin

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))
}
SolutionCounters.kt

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));
}
SolutionCounters.java

পাইথন

def increment_counter(self, doc_ref):
    """Increment a randomly picked shard."""
    doc_id = random.randint(0, self._num_shards - 1)

    shard_ref = doc_ref.collection("shards").document(str(doc_id))
    return shard_ref.update({"count": firestore.Increment(1)})
distributed_counters.py

Python

async def increment_counter(self, doc_ref):
    """Increment a randomly picked shard."""
    doc_id = random.randint(0, self._num_shards - 1)

    shard_ref = doc_ref.collection("shards").document(str(doc_id))
    return await shard_ref.update({"count": firestore.Increment(1)})
distributed_counters.py

Node.js

function incrementCounter(docRef, numShards) {
  const shardId = Math.floor(Math.random() * numShards);
  const shardRef = docRef.collection('shards').doc(shardId.toString());
  return shardRef.set({count: FieldValue.increment(1)}, {merge: true});
}
solution-counters.js

যাও

// incrementCounter increments a randomly picked shard.
func (c *Counter) incrementCounter(ctx context.Context, docRef *firestore.DocumentRef) (*firestore.WriteResult, error) {
	docID := strconv.Itoa(rand.Intn(c.numShards))

	shardRef := docRef.Collection("shards").Doc(docID)
	return shardRef.Update(ctx, []firestore.Update{
		{Path: "Count", Value: firestore.Increment(1)},
	})
}
solution_counters.go

পিএইচপি

$ref = $db->collection('samples/php/distributedCounters');
$numShards = 0;
$docCollection = $ref->documents();
foreach ($docCollection as $doc) {
    $numShards++;
}
$shardIdx = random_int(0, max(1, $numShards) - 1);
$doc = $ref->document((string) $shardIdx);
$doc->update([
    ['path' => 'Cnt', 'value' => FieldValue::increment(1)]
]);
solution_sharded_counter_increment.php

সি#

/// <summary>
/// Increment a randomly picked shard by 1.
/// </summary>
/// <param name="docRef">The document reference <see cref="DocumentReference"/></param>
/// <returns>The <see cref="Task"/></returns>
private static async Task IncrementCounterAsync(DocumentReference docRef, int numOfShards)
{
    int documentId;
    lock (s_randLock)
    {
        documentId = s_rand.Next(numOfShards);
    }
    var shardRef = docRef.Collection("shards").Document(documentId.ToString());
    await shardRef.UpdateAsync("count", FieldValue.Increment(1));
}
Program.cs

রুবি

# project_id = "Your Google Cloud Project ID"
# num_shards = "Number of shards for distributed counter"
# collection_path = "shards"

require "google/cloud/firestore"

firestore = Google::Cloud::Firestore.new project_id: project_id

# Select a shard of the counter at random
shard_id = rand 0...num_shards
shard_ref = firestore.doc "#{collection_path}/#{shard_id}"

# increment counter
shard_ref.update({ count: firestore.field_increment(1) })

puts "Counter incremented."
distributed_counters.rb

মোট গণনা পেতে, সমস্ত শার্ডের জন্য প্রশ্ন করুন এবং তাদের count ক্ষেত্রের যোগফল করুন:

ওয়েব

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;
    });
}
test.solution-counters.js

সুইফট

দ্রষ্টব্য: এই পণ্যটি watchOS এবং অ্যাপ ক্লিপ লক্ষ্যে উপলব্ধ নয়।

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
  }
}
SolutionCountersViewController.swift

উদ্দেশ্য-C

দ্রষ্টব্য: এই পণ্যটি watchOS এবং অ্যাপ ক্লিপ লক্ষ্যে উপলব্ধ নয়।

- (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);
        }
  }];
}
FIRSolutionCountersViewController.m

Kotlin

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

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;
                }
            });
}
SolutionCounters.java

পাইথন

def get_count(self, doc_ref):
    """Return a total count across all shards."""
    total = 0
    shards = doc_ref.collection("shards").list_documents()
    for shard in shards:
        total += shard.get().to_dict().get("count", 0)
    return total
distributed_counters.py

Python

async def get_count(self, doc_ref):
    """Return a total count across all shards."""
    total = 0
    shards = doc_ref.collection("shards").list_documents()
    async for shard in shards:
        total += (await shard.get()).to_dict().get("count", 0)
    return total
distributed_counters.py

Node.js

async function getCount(docRef) {
  const querySnapshot = await docRef.collection('shards').get();
  const documents = querySnapshot.docs;

  let count = 0;
  for (const doc of documents) {
    count += doc.get('count');
  }
  return count;
}
solution-counters.js

যাও

// getCount returns a total count across all shards.
func (c *Counter) getCount(ctx context.Context, docRef *firestore.DocumentRef) (int64, error) {
	var total int64
	shards := docRef.Collection("shards").Documents(ctx)
	for {
		doc, err := shards.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return 0, fmt.Errorf("Next: %w", err)
		}

		vTotal := doc.Data()["Count"]
		shardCount, ok := vTotal.(int64)
		if !ok {
			return 0, fmt.Errorf("firestore: invalid dataType %T, want int64", vTotal)
		}
		total += shardCount
	}
	return total, nil
}
solution_counters.go

পিএইচপি

$result = 0;
$docCollection = $db->collection('samples/php/distributedCounters')->documents();
foreach ($docCollection as $doc) {
    $result += $doc->data()['Cnt'];
}
solution_sharded_counter_get.php

সি#

/// <summary>
/// Get total count across all shards.
/// </summary>
/// <param name="docRef">The document reference <see cref="DocumentReference"/></param>
/// <returns>The <see cref="int"/></returns>
private static async Task<int> GetCountAsync(DocumentReference docRef)
{
    var snapshotList = await docRef.Collection("shards").GetSnapshotAsync();
    return snapshotList.Sum(shard => shard.GetValue<int>("count"));
}
Program.cs

রুবি

# project_id = "Your Google Cloud Project ID"
# collection_path = "shards"

require "google/cloud/firestore"

firestore = Google::Cloud::Firestore.new project_id: project_id

shards_ref = firestore.col_group collection_path

count = 0
shards_ref.get do |doc_ref|
  count += doc_ref[:count]
end

puts "Count value is #{count}."
distributed_counters.rb

সীমাবদ্ধতা

উপরে দেখানো সমাধানটি Cloud Firestore শেয়ার্ড কাউন্টার তৈরি করার একটি মাপযোগ্য উপায়, তবে আপনাকে নিম্নলিখিত সীমাবদ্ধতা সম্পর্কে সচেতন হতে হবে:

• শার্ডের সংখ্যা - শার্ডের সংখ্যা বিতরণ করা কাউন্টারের কার্যকারিতা নিয়ন্ত্রণ করে। খুব কম শার্ডের সাথে, কিছু লেনদেন সফল হওয়ার আগে আবার চেষ্টা করতে হতে পারে, যা লেখার গতি কমিয়ে দেবে। অত্যধিক শার্ডের সাথে, পঠনগুলি ধীর এবং আরও ব্যয়বহুল হয়ে ওঠে। আপনি একটি পৃথক রোল-আপ নথিতে কাউন্টার টোটাল রেখে যা ধীর গতিতে আপডেট করা হয় এবং ক্লায়েন্টদের টোটাল পেতে সেই ডকুমেন্ট থেকে পড়ার মাধ্যমে পড়ার খরচ অফসেট করতে পারেন। ট্রেডঅফ হল যে ক্লায়েন্টদের রোল-আপ ডকুমেন্ট আপডেট হওয়ার জন্য অপেক্ষা করতে হবে, যেকোনো আপডেটের সাথে সাথেই সমস্ত শার্ড পড়ে মোট গণনা করার পরিবর্তে।
• খরচ - একটি পাল্টা মান পড়ার খরচ শার্ডের সংখ্যার সাথে রৈখিকভাবে বৃদ্ধি পায়, কারণ পুরো শার্ডের উপ-সংগ্রহ লোড করা আবশ্যক।