कुल

ब्यौरा

aggregate स्टेज में, पिछले स्टेज में मिले दस्तावेज़ों से एग्रीगेट किए गए नतीजे (जैसे कि गिनती, योग) मिलते हैं.

अगर ग्रुपिंग एक्सप्रेशन दिया जाता है, तो यह दिए गए एक्सप्रेशन के आधार पर दस्तावेज़ों को ग्रुप करता है. इसके बाद, हर ग्रुप पर ऐक्युमुलेटर फ़ंक्शन लागू करता है.

सिंटैक्स

ग्रुप-बाय के बिना एग्रीगेशन के लिए, aggregate स्टेज में एक या उससे ज़्यादा एलियास वाले एग्रीगेटर एक्सप्रेशन होते हैं:

const cities = await db.pipeline()
  .collection("/cities")
  .aggregate(
      countAll().as("total"),
      average("population").as("avg_population")
  )
  .execute();

ग्रुपिंग के साथ एग्रीगेशन के लिए, एग्रीगेटर के अलावा अन्य ग्रुप की ज़रूरत होती है:

const result = await db.pipeline()
  .collectionGroup('citites')
  .aggregate({
    accumulators: [
      countAll().as('cities'),
      field('population').sum().as('total_popoluation')
    ],
    groups: [field('location.state').as('state')]
  })
  .execute();

व्यवहार

ग्रुपिंग के बिना एग्रीगेशन

इन दस्तावेज़ों का cities कलेक्शन बनाओ:

await db.collection('cities').doc('SF').set({name: 'San Francisco', state: 'CA', country: 'USA', population: 870000});
await db.collection('cities').doc('LA').set({name: 'Los Angeles', state: 'CA', country: 'USA', population: 3970000});
await db.collection('cities').doc('NY').set({name: 'New York', state: 'NY', country: 'USA', population: 8530000});
await db.collection('cities').doc('TOR').set({name: 'Toronto', state: null, country: 'Canada', population: 2930000});
await db.collection('cities').doc('MEX').set({name: 'Mexico City', state: null, country: 'Mexico', population: 9200000});

शहरों की कुल संख्या और उनकी औसत जनसंख्या जानने के लिए:

const cities = await db.pipeline()
  .collection("/cities")
  .aggregate(
      countAll().as("total"),
      average("population").as("avg_population")
  )
  .execute();

जिससे यह नतीजा मिलता है:

{avg_population: 5100000, total: 5}

ग्रुप पर एग्रीगेशन करना

groups आर्ग्युमेंट देकर, हर अलग ग्रुप पर एग्रीगेशन किया जा सकता है.

उदाहरण के लिए, हर देश और हर राज्य में सबसे ज़्यादा जनसंख्या वाले शहर का पता लगाने के लिए:

const cities = await db.pipeline()
  .collection("/cities")
  .aggregate({
      accumulators: [
          countAll().as("number_of_cities"),
          maximum("population").as("max_population")
      ],
      groups: ["country", "state"]
  })
  .execute();

जिससे यह मिलता है:

{country: "USA", state: "CA", max_population: 3970000, number_of_cities: 2},
{country: "USA", state: "NY", max_population: 8530000, number_of_cities: 1},
{country: "Canada", state: null, max_population: 2930000, number_of_cities: 1},
{country: "Mexico", state: null,  max_population: 9200000, number_of_cities: 1}

ग्रुपिंग पर आधारित जटिल एक्सप्रेशन

aggregate स्टेज में, सिर्फ़ फ़ील्ड वैल्यू के हिसाब से ग्रुप बनाने के अलावा, जटिल एक्सप्रेशन के नतीजों के हिसाब से भी ग्रुप बनाए जा सकते हैं. select स्टेज में मान्य किसी भी एक्सप्रेशन को ग्रुपिंग कुंजी के तौर पर इस्तेमाल किया जा सकता है. इससे कैलकुलेट की गई वैल्यू या शर्तों के आधार पर, ग्रुप बनाने की सुविधा मिलती है.

उदाहरण के लिए, अगर आपको यह ग्रुप बनाना है कि राज्य फ़ील्ड शून्य है या नहीं और हर ग्रुप में कुल जनसंख्या का पता लगाना है, तो यह क्वेरी इस्तेमाल करें:

const cities = await db.pipeline()
  .collection("/cities")
  .aggregate({
      accumulators: [
         sum("population").as("total_population")
      ],
      groups: [equal(field("state"), null).as("state_is_null")]
  })
  .execute();

यह जवाब देगा:

{state_is_null: true, total_population: 12130000}
{state_is_null: false, total_population: 13370000}

एग्रीगेटर के व्यवहार

हर फ़ंक्शन (जैसे, count, sum, avg) के एग्रीगेशन के तरीके के बारे में जानने के लिए, एग्रीगेट फ़ंक्शन के बारे में जानकारी देने वाला पेज देखें.

ग्रुप की के काम करने की प्राथमिकताएं

दस्तावेज़ों को ग्रुप करते समय, Firestore यह तय करने के लिए समानता के सिमैंटिक का इस्तेमाल करता है कि वैल्यू एक ही ग्रुप से जुड़ी हैं या नहीं.

इसका मतलब है कि एक जैसी वैल्यू, जैसे कि गणित के हिसाब से एक जैसी संख्या वाली वैल्यू, मूल टाइप (32-बिट पूर्णांक, 64-बिट पूर्णांक, फ़्लोटिंग पॉइंट नंबर, decimal128 वगैरह) के बावजूद, सभी को एक साथ ग्रुप किया जाता है.

उदाहरण के लिए, अलग-अलग दस्तावेज़ों वाले numerics कलेक्शन में, 32-बिट पूर्णांक 1, 64-बिट पूर्णांक 1L, और फ़्लोटिंग-पॉइंट नंबर 1.0 की वैल्यू शामिल हैं. इन सभी वैल्यू को एक ही ग्रुप में इकट्ठा किया जाएगा.foo foo के हिसाब से ग्रुप करके गिनती करने पर, यह नतीजा मिलेगा:

{foo: 1.0, count: 3}

डेटासेट में एक जैसी अलग-अलग वैल्यू मौजूद होने पर, ग्रुप की आउटपुट वैल्यू इनमें से कोई भी वैल्यू हो सकती है. इस उदाहरण में, foo, 1, 1L या 1.0 हो सकता है.

भले ही, यह तय किया जा सकता हो कि कौनसी वैल्यू चुनी जाएगी, लेकिन आपको यह नहीं मानना चाहिए कि हमेशा एक ही वैल्यू चुनी जाएगी.

मेमोरी का उपयोग

एग्रीगेशन कैसे किया जाएगा, यह उपलब्ध इंडेक्स पर निर्भर करता है. जब क्वेरी ऑप्टिमाइज़र कोई सही इंडेक्स नहीं चुनता है, तो एग्रीगेट को मेमोरी में सभी ग्रुप को बफ़र करना पड़ता है.

अगर ग्रुप की संख्या बहुत ज़्यादा है या हर ग्रुप बहुत बड़ा है (जैसे, बड़ी वैल्यू के हिसाब से ग्रुप बनाना), तो इस स्टेज में मेमोरी खत्म हो सकती है.

ऐसे मामलों में, आपको फ़िल्टर लागू करने चाहिए, ताकि डेटासेट को एग्रीगेट किया जा सके. इसके अलावा, छोटे/कम फ़ील्ड पर ग्रुपिंग करें या ज़्यादा मेमोरी इस्तेमाल से बचने के लिए, सुझाए गए इंडेक्स बनाएं. 'क्वेरी के बारे में जानकारी' सुविधा, क्वेरी के एक्ज़ीक्यूशन प्लान और प्रोफ़ाइलिंग डेटा के बारे में जानकारी देगी. इससे डीबग करने में मदद मिलेगी.