原生模式下的 Cloud Firestore 企业版现已推出！了解详情。

আপনার পছন্দের ভাষায় কন্টেন্ট অনুবাদ করতে Google তার AI প্রযুক্তি ব্যবহার করে। AI-এর মাধ্যমে করা অনুবাদে ভুল থাকতে পারে।

অ্যাগ্রিগেশন কোয়েরির মাধ্যমে ডেটার সারসংক্ষেপ তৈরি করো

এগ্রিগেশন কোয়েরি একাধিক ইনডেক্স এন্ট্রি থেকে ডেটা প্রসেস করে একটি সারসংক্ষেপ ভ্যালু প্রদান করে।

Cloud Firestore নিম্নলিখিত অ্যাগ্রিগেশন কোয়েরি সাপোর্ট করে:

count()
sum()
average()

Cloud Firestore এগ্রিগেশন হিসেব করে এবং শুধুমাত্র ফলাফল আপনার অ্যাপ্লিকেশনে ফেরত পাঠায়। আপনার অ্যাপে সম্পূর্ণ কোয়েরি এক্সিকিউট করা এবং অ্যাগ্রিগেশন হিসেব করার তুলনায়, অ্যাগ্রিগেশন কোয়েরি বিল করা ডকুমেন্ট রিড এবং ট্রান্সফার করা বাইট, দুটির ক্ষেত্রেই সাশ্রয় করে।

অ্যাগ্রিগেশন কোয়েরি আগে থেকে থাকা ইনডেক্স কনফিগারেশনের উপর নির্ভর করে যা আপনার কোয়েরি আগে থেকেই ব্যবহার করে এবং স্ক্যান করা ইনডেক্স এন্ট্রির সংখ্যার অনুপাতে স্কেল করে। অ্যাগ্রিগেশনে আইটেমের সংখ্যা বাড়ার সাথে সাথে লেটেন্সিও বাড়ে।

`count()` অ্যাগ্রিগেশন ব্যবহার করুন

count() অ্যাগ্রিগেশন কোয়েরি আপনাকে কোনও কালেকশন বা কোয়েরিতে ডকুমেন্টের সংখ্যা নির্ধারণ করতে দেয়।

উদাহরণ ডেটা সম্পর্কে আরও তথ্যের জন্য, ডেটা পাওয়া দেখুন।

নিম্নলিখিত count() এগ্রিগেশন cities সংগ্রহে থাকা শহরের মোট সংখ্যা ফেরত দেয়।

Web

const coll = collection(db, "cities");
const snapshot = await getCountFromServer(coll);
console.log('count: ', snapshot.data().count);count_aggregate_collection.js

Swift

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

let query = db.collection("cities")
let countQuery = query.count
do {
  let snapshot = try await countQuery.getAggregation(source: .server)
  print(snapshot.count)
} catch {
  print(error)
}ViewController.swift

Objective-C

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

FIRCollectionReference *query = [self.db collectionWithPath:@"cities"];
[query.count aggregationWithSource:FIRAggregateSourceServer
                        completion:^(FIRAggregateQuerySnapshot *snapshot,
                                     NSError *error) {
    if (error != nil) {
        NSLog(@"Error fetching count: %@", error);
    } else {
        NSLog(@"Cities count: %@", snapshot.count);
    }
}];ViewController.m

Java

Query query = db.collection("cities");
AggregateQuery countQuery = query.count();
countQuery.get(AggregateSource.SERVER).addOnCompleteListener(new OnCompleteListener<AggregateQuerySnapshot>() {
    @Override
    public void onComplete(@NonNull Task<AggregateQuerySnapshot> task) {
        if (task.isSuccessful()) {
            // Count fetched successfully
            AggregateQuerySnapshot snapshot = task.getResult();
            Log.d(TAG, "Count: " + snapshot.getCount());
        } else {
            Log.d(TAG, "Count failed: ", task.getException());
        }
    }
});DocSnippets.java

Kotlin

val query = db.collection("cities")
val countQuery = query.count()
countQuery.get(AggregateSource.SERVER).addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Count fetched successfully
        val snapshot = task.result
        Log.d(TAG, "Count: ${snapshot.count}")
    } else {
        Log.d(TAG, "Count failed: ", task.getException())
    }
}DocSnippets.kt

Dart

// Returns number of documents in users collection
db.collection("cities").count().get().then(
      (res) => print(res.count),
      onError: (e) => print("Error completing: $e"),
    );firestore.dart

Go

package firestore

import (
	"context"
	"errors"
	"fmt"
	"io"

	"cloud.google.com/go/firestore"
	firestorepb "cloud.google.com/go/firestore/apiv1/firestorepb"
)

func createCountQuery(w io.Writer, projectID string) error {

	// Instantiate the client
	ctx := context.Background()
	client, err := firestore.NewClient(ctx, projectID)
	if err != nil {
		return err
	}
	defer client.Close()

	collection := client.Collection("users")
	query := collection.Where("born", ">", 1850)

	// `alias` argument--"all"--provides a key for accessing the aggregate query
	// results. The alias value must be unique across all aggregation aliases in
	// an aggregation query and must conform to allowed Document field names.
	//
	// See https://cloud.google.com/firestore/docs/reference/rpc/google.firestore.v1#document for details.
	aggregationQuery := query.NewAggregationQuery().WithCount("all")
	results, err := aggregationQuery.Get(ctx)
	if err != nil {
		return err
	}

	count, ok := results["all"]
	if !ok {
		return errors.New("firestore: couldn't get alias for COUNT from results")
	}

	countValue := count.(*firestorepb.Value)
	fmt.Fprintf(w, "Number of results from query: %d\n", countValue.GetIntegerValue())
	return nil
}
aggregate_query_count.go

জাভা

CollectionReference collection = db.collection("cities");
AggregateQuerySnapshot snapshot = collection.count().get().get();
System.out.println("Count: " + snapshot.getCount());

Node.js

const collectionRef = db.collection('cities');
const snapshot = await collectionRef.count().get();
console.log(snapshot.data().count);

Python

from google.cloud import firestore
from google.cloud.firestore_v1 import aggregation
from google.cloud.firestore_v1.base_query import FieldFilter


def create_count_query(project_id: str) -> None:
    """Builds an aggregate query that returns the number of results in the query.

    Arguments:
      project_id: your Google Cloud Project ID
    """
    client = firestore.Client(project=project_id)

    collection_ref = client.collection("users")
    query = collection_ref.where(filter=FieldFilter("born", ">", 1800))
    aggregate_query = aggregation.AggregationQuery(query)

    # `alias` to provides a key for accessing the aggregate query results
    aggregate_query.count(alias="all")

    results = aggregate_query.get()
    for result in results:
        print(f"Alias of results from query: {result[0].alias}")
        print(f"Number of results from query: {result[0].value}")

aggregate_query_count.py

count() অ্যাগ্রিগেশন কোয়েরির যেকোনও ফিল্টার এবং যেকোনও limit ক্লজ বিবেচনা করে।

Web

const coll = collection(db, "cities");
const q = query(coll, where("state", "==", "CA"));
const snapshot = await getCountFromServer(q);
console.log('count: ', snapshot.data().count);count_aggregate_query.js

Swift

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

let query = db.collection("cities").whereField("state", isEqualTo: "CA")
let countQuery = query.count
do {
  let snapshot = try await countQuery.getAggregation(source: .server)
  print(snapshot.count)
} catch {
  print(error)
}ViewController.swift

Objective-C

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

FIRQuery *query =
    [[self.db collectionWithPath:@"cities"]
                 queryWhereField:@"state"
                       isEqualTo:@"CA"];
[query.count aggregationWithSource:FIRAggregateSourceServer
                        completion:^(FIRAggregateQuerySnapshot *snapshot,
                                      NSError *error) {
    if (error != nil) {
        NSLog(@"Error fetching count: %@", error);
    } else {
        NSLog(@"Cities count: %@", snapshot.count);
    }
}];ViewController.m

Java

Query query = db.collection("cities").whereEqualTo("state", "CA");
AggregateQuery countQuery = query.count();
countQuery.get(AggregateSource.SERVER).addOnCompleteListener(new OnCompleteListener<AggregateQuerySnapshot>() {
    @Override
    public void onComplete(@NonNull Task<AggregateQuerySnapshot> task) {
        if (task.isSuccessful()) {
            // Count fetched successfully
            AggregateQuerySnapshot snapshot = task.getResult();
            Log.d(TAG, "Count: " + snapshot.getCount());
        } else {
            Log.d(TAG, "Count failed: ", task.getException());
        }
    }
});DocSnippets.java

Kotlin

val query = db.collection("cities").whereEqualTo("state", "CA")
val countQuery = query.count()
countQuery.get(AggregateSource.SERVER).addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Count fetched successfully
        val snapshot = task.result
        Log.d(TAG, "Count: ${snapshot.count}")
    } else {
        Log.d(TAG, "Count failed: ", task.getException())
    }
}DocSnippets.kt

Dart

// This also works with collection queries.
db.collection("cities").where("capital", isEqualTo: 10).count().get().then(
      (res) => print(res.count),
      onError: (e) => print("Error completing: $e"),
    );firestore.dart

Go

package firestore

import (
	"context"
	"errors"
	"fmt"
	"io"

	"cloud.google.com/go/firestore"
	firestorepb "cloud.google.com/go/firestore/apiv1/firestorepb"
)

func createCountQuery(w io.Writer, projectID string) error {

	// Instantiate the client
	ctx := context.Background()
	client, err := firestore.NewClient(ctx, projectID)
	if err != nil {
		return err
	}
	defer client.Close()

	collection := client.Collection("users")
	query := collection.Where("born", ">", 1850)

	// `alias` argument--"all"--provides a key for accessing the aggregate query
	// results. The alias value must be unique across all aggregation aliases in
	// an aggregation query and must conform to allowed Document field names.
	//
	// See https://cloud.google.com/firestore/docs/reference/rpc/google.firestore.v1#document for details.
	aggregationQuery := query.NewAggregationQuery().WithCount("all")
	results, err := aggregationQuery.Get(ctx)
	if err != nil {
		return err
	}

	count, ok := results["all"]
	if !ok {
		return errors.New("firestore: couldn't get alias for COUNT from results")
	}

	countValue := count.(*firestorepb.Value)
	fmt.Fprintf(w, "Number of results from query: %d\n", countValue.GetIntegerValue())
	return nil
}
aggregate_query_count.go

জাভা

CollectionReference collection = db.collection("cities");
Query query = collection.whereEqualTo("state", "CA");
AggregateQuerySnapshot snapshot = query.count().get().get();
System.out.println("Count: " + snapshot.getCount());

Node.js

const collectionRef = db.collection('cities');
const query = collectionRef.where('state', '==', 'CA');
const snapshot = await query.count().get();
console.log(snapshot.data().count);

Python

from google.cloud import firestore
from google.cloud.firestore_v1 import aggregation
from google.cloud.firestore_v1.base_query import FieldFilter


def create_count_query(project_id: str) -> None:
    """Builds an aggregate query that returns the number of results in the query.

    Arguments:
      project_id: your Google Cloud Project ID
    """
    client = firestore.Client(project=project_id)

    collection_ref = client.collection("users")
    query = collection_ref.where(filter=FieldFilter("born", ">", 1800))
    aggregate_query = aggregation.AggregationQuery(query)

    # `alias` to provides a key for accessing the aggregate query results
    aggregate_query.count(alias="all")

    results = aggregate_query.get()
    for result in results:
        print(f"Alias of results from query: {result[0].alias}")
        print(f"Number of results from query: {result[0].value}")

aggregate_query_count.py

`sum()` অ্যাগ্রিগেশন ব্যবহার করুন

প্রদত্ত কোয়েরির সাথে মেলে এমন সংখ্যার মোট যোগফল পেতে sum() এগ্রিগেশন ব্যবহার করুন—যেমন:

Web

const coll = collection(firestore, 'cities');
const snapshot = await getAggregateFromServer(coll, {
  totalPopulation: sum('population')
});

console.log('totalPopulation: ', snapshot.data().totalPopulation);

Swift

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

let query = db.collection("cities")
let aggregateQuery = query.aggregate([AggregateField.sum("population")])
do {
  let snapshot = try await aggregateQuery.getAggregation(source: .server)
  print(snapshot.get(AggregateField.sum("population")))
} catch {
  print(error)
}ViewController.swift

Objective-C

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

FIRQuery *query = [self.db collectionWithPath:@"cities"];
FIRAggregateQuery *aggregateQuery = [query aggregate:@[
    [FIRAggregateField aggregateFieldForSumOfField:@"population"]]];
[aggregateQuery aggregationWithSource:FIRAggregateSourceServer
                           completion:^(FIRAggregateQuerySnapshot *snapshot,
                                        NSError *error) {
    if (error != nil) {
        NSLog(@"Error fetching aggregate: %@", error);
    } else {
        NSLog(@"Sum: %@", [snapshot valueForAggregateField:[FIRAggregateField aggregateFieldForSumOfField:@"population"]]);
    }
}];ViewController.m

Java

Query query = db.collection("cities");
AggregateQuery aggregateQuery = query.aggregate(AggregateField.sum("population"));
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener(new OnCompleteListener<AggregateQuerySnapshot>() {
    @Override
    public void onComplete(@NonNull Task<AggregateQuerySnapshot> task) {
        if (task.isSuccessful()) {
            // Aggregate fetched successfully
            AggregateQuerySnapshot snapshot = task.getResult();
            Log.d(TAG, "Sum: " + snapshot.get(AggregateField.sum("population")));
        } else {
            Log.d(TAG, "Aggregation failed: ", task.getException());
        }
    }
});DocSnippets.java

Kotlin

val query = db.collection("cities")
val aggregateQuery = query.aggregate(AggregateField.sum("population"))
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Aggregate fetched successfully
        val snapshot = task.result
        Log.d(TAG, "Sum: ${snapshot.get(AggregateField.sum("population"))}")
    } else {
        Log.d(TAG, "Aggregate failed: ", task.getException())
    }
}DocSnippets.kt

Dart

db.collection("cities").aggregate(sum("population")).get().then(
      (res) => print(res.getAverage("population")),
      onError: (e) => print("Error completing: $e"),
    );firestore.dart

জাভা

collection = db.collection("cities");
snapshot = collection.aggregate(sum("population")).get().get();
System.out.println("Sum: " + snapshot.get(sum("population")));

Node.js

const coll = firestore.collection('cities');
const sumAggregateQuery = coll.aggregate({
         totalPopulation: AggregateField.sum('population'),
       });

const snapshot = await sumAggregateQuery.get();
console.log('totalPopulation: ', snapshot.data().totalPopulation);

Python

collection_ref = client.collection("users")
aggregate_query = aggregation.AggregationQuery(collection_ref)

aggregate_query.sum("coins", alias="sum")

results = aggregate_query.get()
for result in results:
    print(f"Alias of results from query: {result[0].alias}")
    print(f"Sum of results from query: {result[0].value}")

Go

func createSumQuery(w io.Writer, projectID string) error {
  ctx := context.Background()
  client, err := firestore.NewClient(ctx, projectID)
  if err != nil {
    return err
  }
  defer client.Close()

  collection := client.Collection("users")
  query := collection.Where("born", ">", 1850)

  aggregationQuery := query.NewAggregationQuery().WithSum("coins", "sum_coins")
  results, err := aggregationQuery.Get(ctx)
  if err != nil {
    return err
  }

  sum, ok := results["sum_coins"]
  if !ok {
    return errors.New("firestore: couldn't get alias for SUM from results")
  }

  sumValue := sum.(*firestorepb.Value)
  fmt.Fprintf(w, "Sum of results from query: %d\n", sumValue.GetIntegerValue())
  return nil
}

sum() অ্যাগ্রিগেশন কোয়েরির যেকোনও ফিল্টার এবং যেকোনও লিমিট ক্লজ বিবেচনা করে—যেমন:

Web

const coll = collection(firestore, 'cities');
const q = query(coll, where('capital', '==', true));
const snapshot = await getAggregateFromServer(q, {
  totalPopulation: sum('population')
});

console.log('totalPopulation: ', snapshot.data().totalPopulation);

Swift

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

let query = db.collection("cities").whereField("capital", isEqualTo: true)
let aggregateQuery = query.aggregate([AggregateField.sum("population")])
do {
  let snapshot = try await aggregateQuery.getAggregation(source: .server)
  print(snapshot.get(AggregateField.sum("population")))
} catch {
  print(error)
}ViewController.swift

Objective-C

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

FIRQuery *query = [[self.db collectionWithPath:@"cities"]
                   queryWhereFilter:[FIRFilter filterWhereField:@"capital" isEqualTo:@YES]];
FIRAggregateQuery *aggregateQuery = [query aggregate:@[
    [FIRAggregateField aggregateFieldForSumOfField:@"population"]]];
[aggregateQuery aggregationWithSource:FIRAggregateSourceServer
                           completion:^(FIRAggregateQuerySnapshot *snapshot,
                                        NSError *error) {
    if (error != nil) {
        NSLog(@"Error fetching aggregate: %@", error);
    } else {
        NSLog(@"Sum: %@", [snapshot valueForAggregateField:[FIRAggregateField aggregateFieldForSumOfField:@"population"]]);
    }
}];ViewController.m

Java

Query query = db.collection("cities").whereEqualTo("capital", true);
AggregateQuery aggregateQuery = query.aggregate(AggregateField.sum("population"));
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener(new OnCompleteListener<AggregateQuerySnapshot>() {
    @Override
    public void onComplete(@NonNull Task<AggregateQuerySnapshot> task) {
        if (task.isSuccessful()) {
            // Aggregate fetched successfully
            AggregateQuerySnapshot snapshot = task.getResult();
            Log.d(TAG, "Sum: " + snapshot.get(AggregateField.sum("population")));
        } else {
            Log.d(TAG, "Aggregation failed: ", task.getException());
        }
    }
});DocSnippets.java

Kotlin

val query = db.collection("cities").whereEqualTo("capital", true)
val aggregateQuery = query.aggregate(AggregateField.sum("population"))
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Aggregate fetched successfully
        val snapshot = task.result
        Log.d(TAG, "Sum: ${snapshot.get(AggregateField.sum("population"))}")
    } else {
        Log.d(TAG, "Aggregate failed: ", task.getException())
    }
}DocSnippets.kt

Dart

db
    .collection("cities")
    .where("capital", isEqualTo: true)
    .aggregate(sum("population"))
    .get()
    .then(
      (res) => print(res.getAverage("population")),
      onError: (e) => print("Error completing: $e"),
    );firestore.dart

জাভা

collection = db.collection("cities");
query = collection.whereEqualTo("state", "CA");
snapshot = query.aggregate(sum("population")).get().get();
System.out.println("Sum: " + snapshot.get(sum("population")));

Node.js

const coll = firestore.collection('cities');
const q = coll.where("capital", "==", true);
const sumAggregateQuery = q.aggregate({
        totalPopulation: AggregateField.sum('population'),
      });

const snapshot = await sumAggregateQuery.get();
console.log('totalPopulation: ', snapshot.data().totalPopulation);

Python

collection_ref = client.collection("users")
query = collection_ref.where(filter=FieldFilter("people", "==", "Matthew"))
aggregate_query = aggregation.AggregationQuery(query)

aggregate_query.sum("coins", alias="sum")

results = aggregate_query.get()
for result in results:
    print(f"Alias of results from query: {result[0].alias}")
    print(f"Sum of results from query: {result[0].value}")

Go

func createSumQuery(w io.Writer, projectID string) error {
  ctx := context.Background()
  client, err := firestore.NewClient(ctx, projectID)
  if err != nil {
    return err
  }
  defer client.Close()

  collection := client.Collection("users")
  query := collection.Where("born", ">", 1850).Limit(5)

  aggregationQuery := query.NewAggregationQuery().WithSum("coins", "sum_coins")
  results, err := aggregationQuery.Get(ctx)
  if err != nil {
    return err
  }

  sum, ok := results["sum_coins"]
  if !ok {
    return errors.New("firestore: couldn't get alias for SUM from results")
  }

  sumValue := sum.(*firestorepb.Value)
  fmt.Fprintf(w, "Sum of results from query: %d\n", sumValue.GetIntegerValue())
  return nil
}

`average()` অ্যাগ্রিগেশন ব্যবহার করুন

প্রদত্ত কোয়েরির সাথে মেলে এমন সংখ্যার গড় মান পেতে average() অ্যাগ্রিগেশন ব্যবহার করুন, যেমন:

Web

const coll = collection(firestore, 'cities');
const snapshot = await getAggregateFromServer(coll, {
  averagePopulation: average('population')
});

console.log('averagePopulation: ', snapshot.data().averagePopulation);

Swift

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

let query = db.collection("cities")
let aggregateQuery = query.aggregate([AggregateField.average("population")])
do {
  let snapshot = try await aggregateQuery.getAggregation(source: .server)
  print(snapshot.get(AggregateField.average("population")))
} catch {
  print(error)
}ViewController.swift

Objective-C

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

FIRQuery *query = [self.db collectionWithPath:@"cities"];
FIRAggregateQuery *aggregateQuery = [query aggregate:@[
    [FIRAggregateField aggregateFieldForAverageOfField:@"population"]]];
[aggregateQuery aggregationWithSource:FIRAggregateSourceServer
                           completion:^(FIRAggregateQuerySnapshot *snapshot,
                                        NSError *error) {
    if (error != nil) {
        NSLog(@"Error fetching aggregate: %@", error);
    } else {
        NSLog(@"Avg: %@", [snapshot valueForAggregateField:[FIRAggregateField aggregateFieldForAverageOfField:@"population"]]);
    }
}];ViewController.m

Java

Query query = db.collection("cities");
AggregateQuery aggregateQuery = query.aggregate(AggregateField.average("population"));
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener(new OnCompleteListener<AggregateQuerySnapshot>() {
    @Override
    public void onComplete(@NonNull Task<AggregateQuerySnapshot> task) {
        if (task.isSuccessful()) {
            // Aggregate fetched successfully
            AggregateQuerySnapshot snapshot = task.getResult();
            Log.d(TAG, "Average: " + snapshot.get(AggregateField.average("population")));
        } else {
            Log.d(TAG, "Aggregation failed: ", task.getException());
        }
    }
});DocSnippets.java

Kotlin

val query = db.collection("cities")
val aggregateQuery = query.aggregate(AggregateField.average("population"))
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Aggregate fetched successfully
        val snapshot = task.result
        Log.d(TAG, "Average: ${snapshot.get(AggregateField.average("population"))}")
    } else {
        Log.d(TAG, "Aggregate failed: ", task.getException())
    }
}DocSnippets.kt

Dart

db.collection("cities").aggregate(average("population")).get().then(
      (res) => print(res.getAverage("population")),
      onError: (e) => print("Error completing: $e"),
    );firestore.dart

জাভা

collection = db.collection("cities");
snapshot = collection.aggregate(average("population")).get().get();
System.out.println("Average: " + snapshot.get(average("population")));

Node.js

const coll = firestore.collection('cities');
const averageAggregateQuery = coll.aggregate({
        averagePopulation: AggregateField.average('population'),
      });

const snapshot = await averageAggregateQuery.get();
console.log('averagePopulation: ', snapshot.data().averagePopulation);

Python

collection_ref = client.collection("users")
aggregate_query = aggregation.AggregationQuery(collection_ref)

aggregate_query.avg("coins", alias="avg")

results = aggregate_query.get()
for result in results:
    print(f"Alias of results from query: {result[0].alias}")
    print(f"Average of results from query: {result[0].value}")

Go

func createAvgQuery(w io.Writer, projectID string) error {
  ctx := context.Background()
  client, err := firestore.NewClient(ctx, projectID)
  if err != nil {
          return err
  }
  defer client.Close()

  collection := client.Collection("users")
  query := collection.Where("born", ">", 1850)

  aggregationQuery := query.NewAggregationQuery().WithAvg("coins", "avg_coins")
  results, err := aggregationQuery.Get(ctx)
  if err != nil {
    return err
  }

  avg, ok := results["avg_coins"]
  if !ok {
    return errors.New("firestore: couldn't get alias for AVG from results")
  }

  avgValue := avg.(*firestorepb.Value)
  fmt.Fprintf(w, "Avg of results from query: %d\n", avgValue.GetDoubleValue())
  return nil
}

average() অ্যাগ্রিগেশন কোয়েরির যেকোনও ফিল্টার এবং যেকোনও সীমা ক্লজ বিবেচনা করে, যেমন:

Web

const coll = collection(firestore, 'cities');
const q = query(coll, where('capital', '==', true));
const snapshot = await getAggregateFromServer(q, {
  averagePopulation: average('population')
});

console.log('averagePopulation: ', snapshot.data().averagePopulation);

Swift

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

let query = db.collection("cities").whereField("capital", isEqualTo: true)
let aggregateQuery = query.aggregate([AggregateField.average("population")])
do {
  let snapshot = try await aggregateQuery.getAggregation(source: .server)
  print(snapshot.get(AggregateField.average("population")))
} catch {
  print(error)
}ViewController.swift

Objective-C

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

FIRQuery *query = [[self.db collectionWithPath:@"cities"]
                   queryWhereFilter:[FIRFilter filterWhereField:@"capital" isEqualTo:@YES]];
FIRAggregateQuery *aggregateQuery = [query aggregate:@[
    [FIRAggregateField aggregateFieldForAverageOfField:@"population"]]];
[aggregateQuery aggregationWithSource:FIRAggregateSourceServer
                           completion:^(FIRAggregateQuerySnapshot *snapshot,
                                        NSError *error) {
    if (error != nil) {
        NSLog(@"Error fetching aggregate: %@", error);
    } else {
        NSLog(@"Avg: %@", [snapshot valueForAggregateField:[FIRAggregateField aggregateFieldForAverageOfField:@"population"]]);
    }
}];ViewController.m

Java

Query query = db.collection("cities").whereEqualTo("capital", true);
AggregateQuery aggregateQuery = query.aggregate(AggregateField.average("population"));
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener(new OnCompleteListener<AggregateQuerySnapshot>() {
    @Override
    public void onComplete(@NonNull Task<AggregateQuerySnapshot> task) {
        if (task.isSuccessful()) {
            // Aggregate fetched successfully
            AggregateQuerySnapshot snapshot = task.getResult();
            Log.d(TAG, "Average: " + snapshot.get(AggregateField.average("population")));
        } else {
            Log.d(TAG, "Aggregation failed: ", task.getException());
        }
    }
});DocSnippets.java

Kotlin

val query = db.collection("cities").whereEqualTo("capital", true)
val aggregateQuery = query.aggregate(AggregateField.average("population"))
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Aggregate fetched successfully
        val snapshot = task.result
        Log.d(TAG, "Average: ${snapshot.get(AggregateField.average("population"))}")
    } else {
        Log.d(TAG, "Aggregate failed: ", task.getException())
    }
}DocSnippets.kt

Dart

db
    .collection("cities")
    .where("capital", isEqualTo: true)
    .aggregate(average("population"))
    .get()
    .then(
      (res) => print(res.getAverage("population")),
      onError: (e) => print("Error completing: $e"),
    );firestore.dart

জাভা

collection = db.collection("cities");
query = collection.whereEqualTo("state", "CA");
snapshot = query.aggregate(average("population")).get().get();
System.out.println("Average: " + snapshot.get(average("population")));

Node.js

const coll = firestore.collection('cities');
const q = coll.where("capital", "==", true);
const averageAggregateQuery = q.aggregate({
        averagePopulation: AggregateField.average('population'),
      });

const snapshot = await averageAggregateQuery.get();
console.log('averagePopulation: ', snapshot.data().averagePopulation);

Python

collection_ref = client.collection("users")
query = collection_ref.where(filter=FieldFilter("people", "==", "Matthew"))
aggregate_query = aggregation.AggregationQuery(query)

aggregate_query.avg("coins", alias="avg")

results = aggregate_query.get()
for result in results:
    print(f"Alias of results from query: {result[0].alias}")
    print(f"Average of results from query: {result[0].value}")

Go

func createAvgQuery(w io.Writer, projectID string) error {
  ctx := context.Background()
  client, err := firestore.NewClient(ctx, projectID)
  if err != nil {
        return err
  }
  defer client.Close()

  collection := client.Collection("users")
  query := collection.Where("born", ">", 1850).Limit(5)

  aggregationQuery := query.NewAggregationQuery().WithAvg("coins", "avg_coins")
  results, err := aggregationQuery.Get(ctx)
  if err != nil {
    return err
  }

  avg, ok := results["avg_coins"]
  if !ok {
    return errors.New("firestore: couldn't get alias for AVG from results")
  }

  avgValue := avg.(*firestorepb.Value)
  fmt.Fprintf(w, "Avg of results from query: %d\n", avgValue.GetDoubleValue())
  return nil
}

একটি কোয়েরিতে একাধিক অ্যাগ্রিগেশন গণনা করা

আপনি একটি অ্যাগ্রিগেশন পাইপলাইনে একাধিক অ্যাগ্রিগেশন একত্রিত করতে পারেন। এটি প্রয়োজনীয় ইন্ডেক্স রিডের সংখ্যা কমাতে পারে। কোয়েরিতে একাধিক ফিল্ডে অ্যাগ্রিগেশন থাকলে, কোয়েরির জন্য কম্পোজিট ইন্ডেক্সের প্রয়োজন হতে পারে। সেক্ষেত্রে, Cloud Firestore একটি ইনডেক্স সাজেস্ট করে।

নিম্নলিখিত উদাহরণটি একটি একক এগ্রিগেশন কোয়েরিতে একাধিক এগ্রিগেশন পারফর্ম করে:

Web

const coll = collection(firestore, 'cities');
const snapshot = await getAggregateFromServer(coll, {
  countOfDocs: count(),
  totalPopulation: sum('population'),
  averagePopulation: average('population')
});

console.log('countOfDocs: ', snapshot.data().countOfDocs);
console.log('totalPopulation: ', snapshot.data().totalPopulation);
console.log('averagePopulation: ', snapshot.data().averagePopulation);

Swift

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

let query = db.collection("cities")
let aggregateQuery = query.aggregate([
  AggregateField.count(),
  AggregateField.sum("population"),
  AggregateField.average("population")])
do {
  let snapshot = try await aggregateQuery.getAggregation(source: .server)
  print("Count: \(snapshot.get(AggregateField.count()))")
  print("Sum: \(snapshot.get(AggregateField.sum("population")))")
  print("Average: \(snapshot.get(AggregateField.average("population")))")
} catch {
  print(error)
}ViewController.swift

Objective-C

মনে রাখবেন: এই প্রোডাক্ট watchOS এবং অ্যাপ ক্লিপ টার্গেটে উপলভ্য নয়।

FIRQuery *query = [self.db collectionWithPath:@"cities"];
FIRAggregateQuery *aggregateQuery = [query aggregate:@[
  [FIRAggregateField aggregateFieldForCount],
  [FIRAggregateField aggregateFieldForSumOfField:@"population"],
  [FIRAggregateField aggregateFieldForAverageOfField:@"population"]]];
[aggregateQuery aggregationWithSource:FIRAggregateSourceServer
                           completion:^(FIRAggregateQuerySnapshot *snapshot,
                                        NSError *error) {
  if (error != nil) {
    NSLog(@"Error fetching aggregate: %@", error);
  } else {
    NSLog(@"Count: %@", [snapshot valueForAggregateField:[FIRAggregateField aggregateFieldForCount]]);
    NSLog(@"Sum: %@", [snapshot valueForAggregateField:[FIRAggregateField aggregateFieldForSumOfField:@"population"]]);
    NSLog(@"Avg: %@", [snapshot valueForAggregateField:[FIRAggregateField aggregateFieldForAverageOfField:@"population"]]);
  }
}];ViewController.m

Java

Query query = db.collection("cities");
AggregateQuery aggregateQuery = query.aggregate(
        AggregateField.count(),
        AggregateField.sum("population"),
        AggregateField.average("population"));
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener(new OnCompleteListener<AggregateQuerySnapshot>() {
    @Override
    public void onComplete(@NonNull Task<AggregateQuerySnapshot> task) {
        if (task.isSuccessful()) {
            // Aggregate fetched successfully
            AggregateQuerySnapshot snapshot = task.getResult();
            Log.d(TAG, "Count: " + snapshot.get(AggregateField.count()));
            Log.d(TAG, "Sum: " + snapshot.get(AggregateField.sum("population")));
            Log.d(TAG, "Average: " + snapshot.get(AggregateField.average("population")));
        } else {
            Log.d(TAG, "Aggregation failed: ", task.getException());
        }
    }
});DocSnippets.java

Kotlin

val query = db.collection("cities")
val aggregateQuery = query.aggregate(
    AggregateField.count(),
    AggregateField.sum("population"),
    AggregateField.average("population")
)
aggregateQuery.get(AggregateSource.SERVER).addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Aggregate fetched successfully
        val snapshot = task.result
        Log.d(TAG, "Count: ${snapshot.get(AggregateField.count())}")
        Log.d(TAG, "Sum: ${snapshot.get(AggregateField.sum("population"))}")
        Log.d(TAG, "Average: ${snapshot.get(AggregateField.average("population"))}")
    } else {
        Log.d(TAG, "Aggregate failed: ", task.getException())
    }
}DocSnippets.kt

Dart

db
    .collection("cities")
    .aggregate(
      count(),
      sum("population"),
      average("population"),
    )
    .get()
    .then(
  (res) {
    print(res.count);
    print(res.getSum("population"));
    print(res.getAverage("population"));
  },
  onError: (e) => print("Error completing: $e"),
);firestore.dart

জাভা

collection = db.collection("cities");
query = collection.whereEqualTo("state", "CA");
AggregateQuery aggregateQuery = query.aggregate(count(), sum("population"), average("population"));
snapshot = aggregateQuery.get().get();
System.out.println("Count: " + snapshot.getCount());
System.out.println("Sum: " + snapshot.get(sum("population")));
System.out.println("Average: " + snapshot.get(average("population")));

Node.js

const coll = firestore.collection('cities');
const aggregateQuery = coll.aggregate({
    countOfDocs: AggregateField.count(),
    totalPopulation: AggregateField.sum('population'),
    averagePopulation: AggregateField.average('population')
  });

const snapshot = await aggregateQuery.get();
console.log('countOfDocs: ', snapshot.data().countOfDocs);
console.log('totalPopulation: ', snapshot.data().totalPopulation);
console.log('averagePopulation: ', snapshot.data().averagePopulation);

Python

collection_ref = client.collection("users")
query = collection_ref.where(filter=FieldFilter("people", "==", "Matthew"))
aggregate_query = aggregation.AggregationQuery(query)

aggregate_query.sum("coins", alias="sum").avg("coins", alias="avg")

results = aggregate_query.get()
for result in results:
    print(f"Alias of results from query: {result[0].alias}")
    print(f"Aggregation of results from query: {result[0].value}")

Go

func createMultiAggregationQuery(w io.Writer, projectID string) error {
  ctx := context.Background()
  client, err := firestore.NewClient(ctx, projectID)
  if err != nil {
    return err
  }
  defer client.Close()

  collection := client.Collection("users")
  query := collection.Where("born", ">", 1850)

  aggregationQuery := query.NewAggregationQuery().WithCount("count").WithSum("coins", "sum_coins").WithAvg("coins", "avg_coins")
  results, err := aggregationQuery.Get(ctx)
  if err != nil {
    return err
  }
}

একাধিক অ্যাগ্রিগেশন সহ কোয়েরিতে শুধুমাত্র সেইসব ডকুমেন্ট অন্তর্ভুক্ত থাকে যেগুলিতে প্রতিটি অ্যাগ্রিগেশনের সব ফিল্ড থাকে। এর ফলে, প্রতিটি অ্যাগ্রিগেশন আলাদাভাবে পারফর্ম করার থেকে আলাদা ফলাফল পাওয়া যেতে পারে।

অ্যাগ্রিগেশন কোয়েরির জন্য নিরাপত্তা সংক্রান্ত নিয়ম

Cloud Firestore Security Rules এগ্রিগেশন কোয়েরিতেও একইভাবে কাজ করে, যেমনটা ডকুমেন্ট রিটার্ন করে এমন কোয়েরিতে করে। অন্যভাবে বলতে গেলে, আপনার নিয়ম যদি ক্লায়েন্টকে নির্দিষ্ট কালেকশন বা কালেকশন গ্রুপ কোয়েরি এক্সিকিউট করার অনুমতি দেয়, তাহলেই ক্লায়েন্ট সেইসব কোয়েরিতে অ্যাগ্রিগেশন পারফর্ম করতে পারবে। কীভাবে Cloud Firestore Security Rules কোয়েরির সাথে ইন্টার‍্যাক্ট করে সেই সম্পর্কে আরও জানুন।

ব্যবহার ও সীমাবদ্ধতা

অ্যাগ্রিগেশন কোয়েরি নিয়ে কাজ করার সময়, নিম্নলিখিত আচরণ ও সীমাবদ্ধতা মনে রাখবেন:

আপনি রিয়েল-টাইম লিসনার ও অফলাইন কোয়েরির সাথে অ্যাগ্রিগেশন কোয়েরি ব্যবহার করতে পারবেন না। এগ্রিগেশন কোয়েরি শুধুমাত্র সরাসরি সার্ভার রেসপন্সের মাধ্যমে কাজ করে। কোয়েরি শুধুমাত্র Cloud Firestore ব্যাকএন্ডের মাধ্যমে পরিবেশন করা হয়, লোকাল ক্যাশে এবং বাফার করা যেকোনও আপডেট বাদ দিয়ে। এই আচরণ Cloud Firestoreট্রানজ্যাকশনের মধ্যে করা অপারেশনের মতোই।
৬০ সেকেন্ডের মধ্যে অ্যাগ্রিগেশন সমাধান করতে না পারলে, এটি DEADLINE_EXCEEDED সমস্যা দেখায়। পারফর্ম্যান্স আপনার ইন্ডেক্স কনফিগারেশন এবং ডেটাসেটের সাইজের উপর নির্ভর করে।

মনে রাখবেন: বেশিরভাগ কোয়েরি, ডেটাসেটের উপর নয়, ফলাফল সেটের সাইজের উপর ভিত্তি করে স্কেল করা হয়। তবে, ডেটাসেটের সাইজ এবং স্ক্যান করা ইনডেক্স এন্ট্রির সংখ্যার উপর ভিত্তি করে অ্যাগ্রিগেশন কোয়েরি স্কেল করা হয়।

৬০ সেকেন্ডের সময়সীমার মধ্যে অপারেশন সম্পূর্ণ করা না গেলে, বড় ডেটাসেটের জন্য কাউন্টার ব্যবহার করা যেতে পারে।
অ্যাগ্রিগেশন কোয়েরি ইনডেক্স এন্ট্রি থেকে পড়ে এবং শুধুমাত্র ইনডেক্স করা ফিল্ড অন্তর্ভুক্ত করে।
এগ্রিগেশন কোয়েরিতে OrderBy ক্লজ যোগ করলে, এগ্রিগেশন সেইসব ডকুমেন্টে সীমাবদ্ধ থাকে যেখানে সর্টিং ফিল্ড আছে।
sum() এবং average() অ্যাগ্রিগেশনের জন্য, সংখ্যাসূচক নয় এমন ভ্যালু উপেক্ষা করা হয়। sum() এবং average() অ্যাগ্রিগেশন শুধুমাত্র পূর্ণসংখ্যা এবং ফ্লোটিং-পয়েন্ট নম্বর ভ্যালু বিবেচনা করে।
একটি কোয়েরিতে একাধিক অ্যাগ্রিগেশন একত্রিত করার সময় মনে রাখবেন যে sum() এবং average() সংখ্যাসূচক নয় এমন মান উপেক্ষা করে, যেখানে count() সংখ্যাসূচক নয় এমন মান অন্তর্ভুক্ত করে।
আপনি যদি বিভিন্ন ফিল্ডে থাকা এগ্রিগেশন একত্রিত করেন, তাহলে গণনার মধ্যে শুধুমাত্র সেইসব ডকুমেন্ট অন্তর্ভুক্ত থাকে যেগুলিতে এইসব ফিল্ড থাকে।

মূল্য

অ্যাগ্রিগেশন কোয়েরির জন্য প্রাইসিং নির্ভর করে ইনডেক্স এন্ট্রির সংখ্যার উপর যা কোয়েরির সাথে মেলে। অনেকগুলি মিলে যাওয়া এন্ট্রির জন্য আপনাকে অল্প সংখ্যক রিডের জন্য চার্জ করা হয়। প্রতিটি ব্যাচে সর্বাধিক ১০০০টি ইনডেক্স এন্ট্রি পড়ার জন্য আপনাকে একটি রিড অপারেশনের জন্য চার্জ করা হয়।

অ্যাগ্রিগেশন কোয়েরির দাম সম্পর্কে আরও জানতে, অ্যাগ্রিগেশন কোয়েরি দেখুন।

count() অ্যাগ্রিগেশন ব্যবহার করুন

Web

Swift

Objective-C

Java

Kotlin

Dart

Go

জাভা

Node.js

Python

Web

Swift

Objective-C

Java

Kotlin

Dart

Go

জাভা

Node.js

Python

sum() অ্যাগ্রিগেশন ব্যবহার করুন

Web

Swift

Objective-C

Java

Kotlin

Dart

জাভা

Node.js

Python

Go

Web

Swift

Objective-C

Java

Kotlin

Dart

জাভা

Node.js

Python

Go

average() অ্যাগ্রিগেশন ব্যবহার করুন

Web

Swift

Objective-C

Java

Kotlin

Dart

জাভা

Node.js

Python

Go

Web

Swift

Objective-C

Java

Kotlin

Dart

জাভা

Node.js

Python

Go

একটি কোয়েরিতে একাধিক অ্যাগ্রিগেশন গণনা করা

Web

Swift

Objective-C

Java

Kotlin

Dart

জাভা

Node.js

Python

Go

অ্যাগ্রিগেশন কোয়েরির জন্য নিরাপত্তা সংক্রান্ত নিয়ম

ব্যবহার ও সীমাবদ্ধতা

মূল্য

`count()` অ্যাগ্রিগেশন ব্যবহার করুন

`sum()` অ্যাগ্রিগেশন ব্যবহার করুন

`average()` অ্যাগ্রিগেশন ব্যবহার করুন