अलग-अलग

ब्यौरा

एक्सप्रेशन की सीरीज़ के लिए, वैल्यू के सभी अलग-अलग कॉम्बिनेशन ढूंढें.

distinct(...) स्टेज का सिंटैक्स, select(...) जैसा ही होता है. ऐसा इसलिए, क्योंकि इसमें एक या से ज़्यादा चुने जा सकने वाले एक्सप्रेशन शामिल होते हैं. अगर एक्सप्रेशन सिर्फ़ फ़ील्ड का रेफ़रंस है, तो स्ट्रिंग का इस्तेमाल किया जा सकता है:

उदाहरण

Node.js
let cities = await db.pipeline()
  .collection("cities")
  .distinct("country")
  .execute();

cities = await db.pipeline()
  .collection("cities")
  .distinct(
    field("state").toLower().as("normalizedState"),
    field("country"))
  .execute();

Web

let cities = await execute(db.pipeline()
  .collection("cities")
  .distinct("country"));

cities = await execute(db.pipeline()
  .collection("cities")
  .distinct(
    field("state").toLower().as("normalizedState"),
    field("country")));
Swift
let results = try await db.pipeline()
  .collection("books")
  .distinct([
    Field("author").toUpper().as("author"),
    Field("genre")
  ])
  .execute()

Kotlin

var cities = db.pipeline()
    .collection("cities")
    .distinct("country")
    .execute()

cities = db.pipeline()
    .collection("cities")
    .distinct(
        field("state").toLower().alias("normalizedState"),
        field("country")
    )
    .execute()

Java

Task<Pipeline.Snapshot> cities;
cities = db.pipeline()
        .collection("cities")
        .distinct("country")
        .execute();

cities = db.pipeline()
        .collection("cities")
        .distinct(
                field("state").toLower().alias("normalizedState"),
                field("country"))
        .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

cities = client.pipeline().collection("cities").distinct("country").execute()

cities = (
    client.pipeline()
    .collection("cities")
    .distinct(Field.of("state").to_lower().as_("normalizedState"), "country")
    .execute()
)
Java
Pipeline.Snapshot cities1 =
    firestore.pipeline().collection("cities").distinct("country").execute().get();

Pipeline.Snapshot cities2 =
    firestore
        .pipeline()
        .collection("cities")
        .distinct(toLower(field("state")).as("normalizedState"), field("country"))
        .execute()
        .get();

व्यवहार

distinct(...) स्टेज, ग्रुप के बिना aggregate(...) स्टेज की तरह काम करती है. aggregate(...) और select(...) के बारे में भी पढ़ें.

फ़ील्ड की अलग-अलग वैल्यू ढूंढना

उदाहरण के लिए, cities कलेक्शन में मौजूद हर देश की सूची पाने के लिए:

Node.js

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

अलग-अलग देशों को ढूंढने के लिए, इसका इस्तेमाल किया जा सकता है:

Node.js

const cities = await db.pipeline()
  .collection("/cities")
  .distinct("country")
  .execute();

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

{ country: "USA" }
{ country: "Canada" }
{ country: "Mexico" }

एक्सप्रेशन का अलग-अलग आउटपुट

आपके पास एक से ज़्यादा फ़ील्ड या ज़्यादा मुश्किल एक्सप्रेशन के अलग-अलग कॉम्बिनेशन ढूंढने का विकल्प भी होता है. उदाहरण के लिए:

Node.js

const cities = await db.pipeline()
  .collection("/cities")
  .distinct(
    field("state").toLower().as("normalized_state"),
    field("country"))
  .execute();

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

{ country: "USA", normalized_state: "ca" }
{ country: "USA", normalized_state: "ny" }
{ country: "Canada", normalized_state: null }
{ country: "Mexico", normalized_state: null }

समानता का व्यवहार

अलग-अलग वैल्यू पर समानता का व्यवहार, समानता के सिमैंटिक जैसा ही होता है.

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

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

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

भले ही, यह तय लग रहा हो, लेकिन आपको चुनी गई किसी खास वैल्यू के व्यवहार पर भरोसा नहीं करना चाहिए.

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

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

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

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

क्वेरी के एक्ज़ीक्यूशन प्लान और प्रोफ़ाइलिंग डेटा के बारे में जानकारी पाने के लिए, क्वेरी की जानकारी देखें. इससे डीबग करने में मदद मिलेगी.