Cloud Firestore में इंडेक्स टाइप

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

इस पेज पर, Cloud Firestore के इस्तेमाल किए जाने वाले दो तरह के इंडेक्स के बारे में बताया गया है: अपने-आप बनने वाले इंडेक्स और मैन्युअल इंडेक्स.

इंडेक्स की परिभाषा और स्ट्रक्चर

इंडेक्स को किसी दस्तावेज़ के फ़ील्ड की सूची के आधार पर तय किया जाता है. साथ ही, हर फ़ील्ड के लिए एक इंडेक्स मोड होता है.

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

इंडेक्स को फ़ील्ड वैल्यू के हिसाब से क्रम में लगाया जाता है. यह क्रम, इंडेक्स की परिभाषा में तय किए गए क्रम के मुताबिक होता है.

हर क्वेरी के पीछे एक इंडेक्स

अगर किसी क्वेरी के लिए कोई इंडेक्स मौजूद नहीं है, तो ज़्यादातर डेटाबेस अपने कॉन्टेंट को एक-एक करके क्रॉल करते हैं. यह एक धीमी प्रोसेस है, जो डेटाबेस के बढ़ने के साथ-साथ और धीमी हो जाती है. Cloud Firestore, सभी क्वेरी के लिए इंडेक्स का इस्तेमाल करके, क्वेरी की परफ़ॉर्मेंस को बेहतर बनाने में मदद करता है. इस वजह से, क्वेरी की परफ़ॉर्मेंस, डेटाबेस में मौजूद आइटम की संख्या के बजाय, नतीजे के सेट के साइज़ पर निर्भर करती है.

इंडेक्स मैनेजमेंट पर कम और ऐप्लिकेशन डेवलपमेंट पर ज़्यादा ध्यान देना

Cloud Firestore में ऐसी सुविधाएं शामिल हैं जिनकी मदद से, इंडेक्स मैनेजमेंट में लगने वाले समय को कम किया जा सकता है. सबसे बुनियादी क्वेरी के लिए ज़रूरी इंडेक्स, आपके लिए अपने-आप बन जाते हैं. ऐप्लिकेशन को इस्तेमाल और टेस्ट करने के दौरान, Cloud Firestore आपको उन अतिरिक्त इंडेक्स की पहचान करने और उन्हें बनाने में मदद करता है जिनकी आपके ऐप्लिकेशन को ज़रूरत होती है.

इंडेक्स के टाइप

Cloud Firestore दो तरह के इंडेक्स इस्तेमाल करता है: अपने-आप बनने वाले और मैन्युअल तरीके से बनने वाले. मैन्युअल और ऑटोमैटिक इंडेक्स को मैनेज करने का तरीका अलग-अलग होता है.

अपने-आप बनने वाले इंडेक्स

डिफ़ॉल्ट रूप से, Cloud Firestore किसी कलेक्शन में मौजूद दस्तावेज़ों के हर फ़ील्ड के लिए, इंडेक्स अपने-आप बनाता है. इन सिंगल-फ़ील्ड इंडेक्स की मदद से, कई बुनियादी क्वेरी की जा सकती हैं. अपने डेटाबेस की ऑटोमैटिक इंडेक्सिंग की सेटिंग और इंडेक्स से जुड़ी छूट को कॉन्फ़िगर करके, ऑटोमैटिक इंडेक्स को मैनेज किया जा सकता है.

अपने-आप इंडेक्स होने की डिफ़ॉल्ट सेटिंग

Cloud Firestore, अपने-आप इंडेक्स होने की सुविधा के लिए, इन डिफ़ॉल्ट सेटिंग का इस्तेमाल करता है:

• हर नॉन-ऐरे और नॉन-मैप फ़ील्ड के लिए, Cloud Firestore दो कलेक्शन-स्कोप इंडेक्स तय करता है. इनमें से एक इंडेक्स, बढ़ते क्रम में और दूसरा घटते क्रम में होता है.

• हर मैप फ़ील्ड के लिए, Cloud Firestore ये चीज़ें बनाता है:

  • हर नॉन-ऐरे और नॉन-मैप सबफ़ील्ड के लिए, कलेक्शन-स्कोप वाला एक असेंडिंग इंडेक्स.
  • हर नॉन-अरे और नॉन-मैप सबफ़ील्ड के लिए, कलेक्शन-स्कोप वाला एक डिसेंडिंग इंडेक्स.
  • पूरे मैप की वैल्यू के लिए, कलेक्शन-स्कोप वाला एक असेंडिंग इंडेक्स
  • पूरे मैप की वैल्यू के लिए, कलेक्शन-स्कोप वाला एक डिसेंडिंग इंडेक्स
  • कलेक्शन-स्कोप वाला एक कलेक्शन-इसमें हर कलेक्शन सबफ़ील्ड के लिए इंडेक्स होता है.
  • Cloud Firestore, हर मैप सबफ़ील्ड को बार-बार इंडेक्स करता है.

• किसी दस्तावेज़ में मौजूद हर कलेक्शन फ़ील्ड के लिए, Cloud Firestore ये इंडेक्स बनाता है:

  • पूरे कलेक्शन के लिए, कलेक्शन के स्कोप वाला एक इंडेक्स, जो बढ़ते क्रम में हो
  • पूरे कलेक्शन के लिए, कलेक्शन के स्कोप वाला एक डिसेंडिंग इंडेक्स
  • कलेक्शन-स्कोप वाला एक array-contains इंडेक्स.

• कलेक्शन ग्रुप के स्कोप वाले ऑटोमैटिक इंडेक्स, डिफ़ॉल्ट रूप से मैनेज नहीं किए जाते.

इंडेक्स करने की प्रोसेस अपने-आप होने से जुड़ी छूट

इंडेक्स करने की छूट बनाकर, किसी फ़ील्ड को अपने-आप इंडेक्स होने की सेटिंग से छूट दी जा सकती है. इंडेक्स करने से मिली छूट, पूरे डेटाबेस में अपने-आप इंडेक्स होने की सेटिंग को बदल देती है. छूट की मदद से, ऐसे इंडेक्स को चालू किया जा सकता है जिसे अपने-आप इंडेक्स होने की सेटिंग बंद कर देती. इसके अलावा, ऐसे इंडेक्स को बंद किया जा सकता है जिसे अपने-आप इंडेक्स होने की सेटिंग चालू कर देती. ऐसे मामलों में जहां छूट काम आ सकती है, इंडेक्स करने के सबसे सही तरीके देखें.

कलेक्शन ग्रुप के सभी फ़ील्ड पर कलेक्शन-लेवल के इंडेक्स से छूट जोड़ने के लिए, * फ़ील्ड पाथ वैल्यू का इस्तेमाल करें. उदाहरण के लिए, कलेक्शन ग्रुप comments के लिए, फ़ील्ड पाथ को * पर सेट करें, ताकि comments कलेक्शन ग्रुप के सभी फ़ील्ड मैच हो सकें. साथ ही, कलेक्शन ग्रुप के सभी फ़ील्ड की इंडेक्सिंग बंद करें. इसके बाद, छूट जोड़कर सिर्फ़ उन फ़ील्ड को इंडेक्स किया जा सकता है जो आपकी क्वेरी के लिए ज़रूरी हैं. इंडेक्स किए गए फ़ील्ड की संख्या कम करने से, स्टोरेज की लागत कम होती है. साथ ही, डेटा लिखने की परफ़ॉर्मेंस बेहतर हो सकती है.

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

अपने-आप इंडेक्स होने की सुविधा से छूट पाने के लिए, इंडेक्स मैनेज करें देखें.

मैन्युअल इंडेक्स

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

Cloud Firestore, मैन्युअल इंडेक्स का इस्तेमाल करके उन क्वेरी के जवाब देता है जिनके जवाब ऑटोमैटिक इंडेक्स से नहीं दिए जा सकते.

डिफ़ॉल्ट रूप से, Cloud Firestore किसी कलेक्शन में मौजूद हर फ़ील्ड के लिए, सिंगल-फ़ील्ड इंडेक्स अपने-आप बनाता है. Cloud Firestore, फ़ील्ड के कॉम्बिनेशन के लिए अपने-आप इंडेक्स नहीं बनाता. ऐसा इसलिए होता है, क्योंकि फ़ील्ड के कई कॉम्बिनेशन हो सकते हैं. इसके बजाय, Cloud Firestore ऐप्लिकेशन बनाते समय, ज़रूरी इंडेक्स की पहचान करने और उन्हें बनाने में आपकी मदद करता है.

जब भी ऐसी क्वेरी की जाती है जो मौजूदा इंडेक्स के साथ काम नहीं करती, तब Cloud Firestore गड़बड़ी का मैसेज दिखाता है. साथ ही, एक लिंक भी दिखाता है. इस लिंक पर जाकर, इंडेक्स बनाया जा सकता है.

कंसोल या Firebase CLI का इस्तेमाल करके, इंडेक्स को मैन्युअल तरीके से भी तय और मैनेज किया जा सकता है. मैन्युअल इंडेक्स बनाने और उन्हें मैनेज करने के बारे में ज़्यादा जानने के लिए, इंडेक्स मैनेज करना लेख पढ़ें.

इंडेक्स मोड और क्वेरी स्कोप

अपने-आप और मैन्युअल तरीके से बनने वाले इंडेक्स को अलग-अलग तरीके से कॉन्फ़िगर किया जाता है. हालांकि, दोनों के लिए आपको इंडेक्स मोड और क्वेरी के स्कोप को कॉन्फ़िगर करना होगा.

इंडेक्स मोड

इंडेक्स तय करते समय, इंडेक्स किए गए हर फ़ील्ड के लिए इंडेक्स मोड चुना जाता है. हर फ़ील्ड का इंडेक्स मोड, उस फ़ील्ड पर खास क्वेरी क्लॉज़ के साथ काम करता है. इनमें से कोई भी इंडेक्स मोड चुना जा सकता है:

क्वेरी के दायरे

हर इंडेक्स का दायरा, किसी कलेक्शन या कलेक्शन ग्रुप तक सीमित होता है. इसे इंडेक्स का क्वेरी स्कोप कहा जाता है:

कलेक्शन का दायरा

Cloud Firestore, डिफ़ॉल्ट रूप से कलेक्शन के स्कोप के साथ इंडेक्स बनाता है. ये इंडेक्स, ऐसी क्वेरी के लिए काम करते हैं जो किसी एक कलेक्शन से नतीजे दिखाती हैं.

कलेक्शन ग्रुप का स्कोप

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

डिफ़ॉल्ट क्रम और __name__ फ़ील्ड

हर फ़ील्ड के लिए तय किए गए इंडेक्स मोड (बढ़ते या घटते क्रम में) के हिसाब से दस्तावेज़ों को क्रम में लगाने के अलावा, इंडेक्स हर दस्तावेज़ के __name__ फ़ील्ड के हिसाब से आखिरी क्रम में लगाते हैं. __name__ फ़ील्ड की वैल्यू, पूरे दस्तावेज़ के पाथ पर सेट की गई है. इसका मतलब है कि नतीजे के सेट में मौजूद जिन दस्तावेज़ों के फ़ील्ड की वैल्यू एक जैसी होती है उन्हें दस्तावेज़ के पाथ के हिसाब से क्रम में लगाया जाता है.

डिफ़ॉल्ट रूप से, __name__ फ़ील्ड को इंडेक्स की डेफ़िनिशन में मौजूद, आखिरी बार क्रम से लगाए गए फ़ील्ड के क्रम में ही लगाया जाता है. उदाहरण के लिए:

नतीजों को डिफ़ॉल्ट के बजाय __name__ क्रम में लगाने के लिए, आपको वह इंडेक्स बनाना होगा.

इंडेक्स प्रॉपर्टी

क्वेरी को सबसे बेहतर तरीके से लागू करने की अनुमति देने वाले इंडेक्स को इन प्रॉपर्टी से तय किया जाता है:

• इक्वालिटी फ़िल्टर में इस्तेमाल किए गए फ़ील्ड
• क्रम से लगाने के लिए इस्तेमाल किए जाने वाले फ़ील्ड
• रेंज और इनइक्वालिटी फ़िल्टर में इस्तेमाल किए गए फ़ील्ड, जो क्रम से लगाने के लिए पहले से शामिल नहीं हैं
• एग्रीगेशन में इस्तेमाल किए गए फ़ील्ड (जो क्रम से लगाने के क्रम, रेंज, और असमानता वाले फ़िल्टर में पहले से शामिल नहीं हैं)

Cloud Firestore, क्वेरी के नतीजों का हिसाब इस तरह लगाता है:

1. इससे क्वेरी के कलेक्शन, फ़िल्टर प्रॉपर्टी, फ़िल्टर ऑपरेटर, और क्रम से लगाने के तरीकों से जुड़े इंडेक्स की पहचान की जाती है.
2. इससे उस इंडेक्स पोज़िशन की पहचान होती है जहां से स्कैनिंग शुरू होती है. शुरुआती पोज़िशन, क्वेरी के इक्वालिटी फ़िल्टर से शुरू होती है. साथ ही, पहले orderBy फ़ील्ड पर रेंज और इनइक्वालिटी फ़िल्टर के साथ खत्म होती है.
3. इंडेक्स को स्कैन करना शुरू करता है और हर उस दस्तावेज़ को दिखाता है जो सभी फ़िल्टर के मुताबिक है. स्कैन करने की प्रोसेस तब तक चलती है, जब तक इनमें से कोई एक काम नहीं हो जाता:
   • उसे कोई ऐसा दस्तावेज़ मिलता है जो फ़िल्टर करने की शर्तों को पूरा नहीं करता. साथ ही, यह पुष्टि करता है कि इसके बाद आने वाला कोई भी दस्तावेज़, फ़िल्टर करने की शर्तों को पूरी तरह से पूरा नहीं करेगा.
   • इंडेक्स के आखिर तक पहुंच जाता है.
   • क्वेरी के लिए अनुरोध किए गए ज़्यादा से ज़्यादा नतीजे इकट्ठा करता है.

इंडेक्स करने का उदाहरण

Cloud Firestore आपके लिए सिंगल-फ़ील्ड इंडेक्स अपने-आप बनाता है. इससे आपके ऐप्लिकेशन को डेटाबेस की सबसे बुनियादी क्वेरी के लिए तुरंत सहायता मिलती है. सिंगल-फ़ील्ड इंडेक्स की मदद से, फ़ील्ड वैल्यू और तुलना करने वाले ऑपरेटर <, <=, ==, >=, >, और in के आधार पर आसान क्वेरी की जा सकती हैं. अरे फ़ील्ड के लिए, इनकी मदद से array-contains और array-contains-any क्वेरी की जा सकती हैं.

इसे समझने के लिए, इंडेक्स बनाने के नज़रिए से यहां दिए गए उदाहरण देखें. यहां दिया गया स्निपेट, cities कलेक्शन में कुछ city दस्तावेज़ बनाता है. साथ ही, हर दस्तावेज़ के लिए name, state, country, capital, population, और regions फ़ील्ड सेट करता है:

var citiesRef = db.collection("cities");

citiesRef.doc("SF").set({
    name: "San Francisco", state: "CA", country: "USA",
    capital: false, population: 860000,
    regions: ["west_coast", "norcal"] });
citiesRef.doc("LA").set({
    name: "Los Angeles", state: "CA", country: "USA",
    capital: false, population: 3900000,
    regions: ["west_coast", "socal"] });
citiesRef.doc("DC").set({
    name: "Washington, D.C.", state: null, country: "USA",
    capital: true, population: 680000,
    regions: ["east_coast"] });
citiesRef.doc("TOK").set({
    name: "Tokyo", state: null, country: "Japan",
    capital: true, population: 9000000,
    regions: ["kanto", "honshu"] });
citiesRef.doc("BJ").set({
    name: "Beijing", state: null, country: "China",
    capital: true, population: 21500000,
    regions: ["jingjinji", "hebei"] });
test.firestore.js

ऑटोमैटिक इंडेक्सिंग की डिफ़ॉल्ट सेटिंग के हिसाब से, Cloud Firestore हर फ़ील्ड के लिए, बढ़ते क्रम में एक सिंगल-फ़ील्ड इंडेक्स, हर फ़ील्ड के लिए घटते क्रम में एक सिंगल-फ़ील्ड इंडेक्स, और ऐरे फ़ील्ड के लिए एक array-contains सिंगल-फ़ील्ड इंडेक्स को अपडेट करता है. नीचे दी गई टेबल की हर लाइन, सिंगल-फ़ील्ड इंडेक्स में मौजूद एक एंट्री को दिखाती है:

सिंगल-फ़ील्ड इंडेक्स के साथ काम करने वाली क्वेरी

अपने-आप बनने वाले इन सिंगल-फ़ील्ड इंडेक्स का इस्तेमाल करके, इस तरह की आसान क्वेरी चलाई जा सकती हैं:

const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");
test.firestore.js

इसके अलावा, in और कंपाउंड इक्वालिटी (==) क्वेरी भी बनाई जा सकती हैं:

citiesRef.where('country', 'in', ["USA", "Japan", "China"])

// Compound equality queries
citiesRef.where("state", "==", "CO").where("name", "==", "Denver")
citiesRef.where("country", "==", "USA")
         .where("capital", "==", false)
         .where("state", "==", "CA")
         .where("population", "==", 860000)

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

array-contains इंडेक्स की मदद से, regions कलेक्शन फ़ील्ड के लिए क्वेरी की जा सकती है:

citiesRef.where("regions", "array-contains", "west_coast")
// array-contains-any and array-contains use the same indexes
citiesRef.where("regions", "array-contains-any", ["west_coast", "east_coast"])

मैन्युअल इंडेक्स के साथ काम करने वाली क्वेरी

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

citiesRef.where("country", "==", "USA").orderBy("population", "asc")
citiesRef.where("country", "==", "USA").where("population", "<", 3800000)
citiesRef.where("country", "==", "USA").where("population", ">", 690000)
// in and == clauses use the same index
citiesRef.where("country", "in", ["USA", "Japan", "China"])
         .where("population", ">", 690000)

इन क्वेरी के लिए, यह इंडेक्स ज़रूरी है. क्वेरी में country फ़ील्ड के लिए, बराबर (== या in) का इस्तेमाल किया जाता है. इसलिए, इस फ़ील्ड के लिए असेंडिंग या डिसेंडिंग इंडेक्स मोड का इस्तेमाल किया जा सकता है. डिफ़ॉल्ट रूप से, असमानता वाले क्लॉज़, असमानता वाले क्लॉज़ में मौजूद फ़ील्ड के आधार पर, बढ़ते क्रम में लगाने का तरीका लागू करते हैं.

अगर आपको यही क्वेरी घटते क्रम में चलानी हैं, तो आपको population के लिए घटते क्रम में एक और इंडेक्स की ज़रूरत होगी:

citiesRef.where("country", "==", "USA").orderBy("population", "desc")

citiesRef.where("country", "==", "USA")
         .where("population", "<", 3800000)
         .orderBy("population", "desc")

citiesRef.where("country", "==", "USA")
         .where("population", ">", 690000)
         .orderBy("population", "desc")

citiesRef.where("country", "in", ["USA", "Japan", "China"])
         .where("population", ">", 690000)
         .orderBy("population", "desc")

इंडेक्स मर्ज करने की वजह से परफ़ॉर्मेंस में होने वाली कमी से बचने के लिए, हमारा सुझाव है कि आप अतिरिक्त क्लॉज़ के साथ array-contains या array-contains-any क्वेरी को जोड़ने के लिए एक इंडेक्स बनाएं:

citiesRef.where("regions", "array-contains", "east_coast")
         .where("capital", "==", true)

// array-contains-any and array-contains use the same index
citiesRef.where("regions", "array-contains-any", ["west_coast", "east_coast"])
         .where("capital", "==", true)

कलेक्शन ग्रुप इंडेक्स के साथ काम करने वाली क्वेरी

कलेक्शन ग्रुप के स्कोप वाले इंडेक्स को दिखाने के लिए, कुछ city दस्तावेज़ों में landmarks सब-कलेक्शन जोड़ें:

var citiesRef = db.collection("cities");

citiesRef.doc("SF").collection("landmarks").doc().set({
    name: "Golden Gate Bridge",
    category : "bridge" });
citiesRef.doc("SF").collection("landmarks").doc().set({
    name: "Golden Gate Park",
    category : "park" });

citiesRef.doc("DC").collection("landmarks").doc().set({
    name: "National Gallery of Art",
    category : "museum" });
citiesRef.doc("DC").collection("landmarks").doc().set({
    name: "National Mall",
    category : "park" });

कलेक्शन के स्कोप वाले इस सिंगल-फ़ील्ड इंडेक्स का इस्तेमाल करके, category फ़ील्ड के आधार पर किसी एक शहर के landmarks कलेक्शन के लिए क्वेरी की जा सकती है:

citiesRef.doc("SF").collection("landmarks").where("category", "==", "park")
citiesRef.doc("SF").collection("landmarks").where("category", "in", ["park", "museum"])

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

इस इंडेक्स को चालू करने पर, landmarks कलेक्शन ग्रुप के लिए क्वेरी की जा सकती है:

var landmarksGroupRef = db.collectionGroup("landmarks");

landmarksGroupRef.where("category", "==", "park")
landmarksGroupRef.where("category", "in", ["park", "museum"])

फ़िल्टर किए गए या क्रम से लगाए गए नतीजे दिखाने वाली कलेक्शन ग्रुप क्वेरी चलाने के लिए, आपको कलेक्शन ग्रुप के स्कोप के साथ उससे जुड़ा इंडेक्स चालू करना होगा. हालांकि, कलेक्शन ग्रुप की ऐसी क्वेरी जो नतीजों को फ़िल्टर या क्रम से नहीं लगाती हैं उनके लिए, इंडेक्स की किसी अन्य परिभाषा की ज़रूरत नहीं होती.

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

db.collectionGroup("landmarks").get()

इंडेक्स एंट्री

आपके प्रोजेक्ट के कॉन्फ़िगर किए गए इंडेक्स और दस्तावेज़ के स्ट्रक्चर से, किसी दस्तावेज़ के लिए इंडेक्स एंट्री की संख्या तय होती है. इंडेक्स एंट्री की संख्या, इंडेक्स एंट्री की संख्या की सीमा में शामिल होती है.

यहां दिए गए उदाहरण में, किसी दस्तावेज़ की इंडेक्स एंट्री दिखाई गई हैं.

दस्तावेज़

/cities/SF

city_name : "San Francisco"
temperatures : {summer: 67, winter: 55}
neighborhoods : ["Mission", "Downtown", "Marina"]

अपने-आप बनने वाले इंडेक्स

• city_name ASC
• city_name DESC
• आस-पास के इलाके बढ़ते क्रम में
• आस-पास के इलाके DESC
• तापमान के हिसाब से बढ़ते क्रम में
• तापमान DESC
• temperatures.summer ASC
• गर्मियों के मौसम में तापमान की जानकारी.सबसे ज़्यादा तापमान वाली जगहों के नाम पहले दिखाए गए हैं
• temperatures.winter ASC
• temperatures.winter DESC
• neighborhoods Array Contains

मैन्युअल इंडेक्स

• city_name ASC, neighborhoods ARRAY
• city_name DESC, neighborhoods ARRAY

इंडेक्स एंट्री

इस इंडेक्सिंग कॉन्फ़िगरेशन की वजह से, दस्तावेज़ के लिए ये इंडेक्स एंट्री बनती हैं:

इंडेक्स और कीमत

इंडेक्स, आपके ऐप्लिकेशन के स्टोरेज की लागत में योगदान देते हैं. इंडेक्स के लिए स्टोरेज के साइज़ का हिसाब लगाने के तरीके के बारे में ज़्यादा जानने के लिए, इंडेक्स एंट्री का साइज़ देखें.

इंडेक्स मर्ज करने की सुविधा का इस्तेमाल करना

हालांकि, Cloud Firestore हर क्वेरी के लिए इंडेक्स का इस्तेमाल करता है, लेकिन हर क्वेरी के लिए एक इंडेक्स की ज़रूरत नहीं होती. एक से ज़्यादा समानता (==) क्लॉज़ और वैकल्पिक तौर पर, orderBy क्लॉज़ वाली क्वेरी के लिए, Cloud Firestore मौजूदा इंडेक्स का फिर से इस्तेमाल कर सकता है. Cloud Firestore, समानता के लिए इस्तेमाल होने वाले सामान्य फ़िल्टर के इंडेक्स को मर्ज कर सकता है. इससे समानता के लिए इस्तेमाल होने वाली बड़ी क्वेरी के लिए ज़रूरी इंडेक्स बनाए जा सकते हैं.

इंडेक्स को मर्ज करने की सुविधा का इस्तेमाल करके, इंडेक्स करने की लागत को कम किया जा सकता है. उदाहरण के लिए, रेस्टोरेंट को रेटिंग देने वाले ऐप्लिकेशन के लिए, restaurants कलेक्शन में:

• collections_bookmark रेस्टोरेंट

  • class burgerthyme

    name : "Burger Thyme"
category : "burgers"
city : "San Francisco"
editors_pick : true
star_rating : 4
    

यह ऐप्लिकेशन, इस तरह की क्वेरी का इस्तेमाल करता है. ऐप्लिकेशन, category, city, और editors_pick के लिए इक्वालिटी क्लॉज़ के कॉम्बिनेशन का इस्तेमाल करता है. साथ ही, हमेशा बढ़ते क्रम में star_rating के हिसाब से क्रम में लगाता है:

db.collection("restaurants").where("category", "==", "burgers")
                            .orderBy("star_rating")

db.collection("restaurants").where("city", "==", "San Francisco")
                            .orderBy("star_rating")

db.collection("restaurants").where("category", "==", "burgers")
                            .where("city", "==", "San Francisco")
                            .orderBy("star_rating")

db.collection("restaurants").where("category", "==", "burgers")
                            .where("city", "==", "San Francisco")
                            .where("editors_pick", "==", true )
                            .orderBy("star_rating")

हर क्वेरी के लिए एक इंडेक्स बनाया जा सकता है:

इसके बजाय, इंडेक्स की संख्या को कम किया जा सकता है. इसके लिए, Cloud Firestore की उस सुविधा का इस्तेमाल करें जिससे इक्वालिटी क्लॉज़ के लिए इंडेक्स मर्ज किए जा सकते हैं:

इंडेक्स का यह सेट छोटा होने के साथ-साथ, एक और क्वेरी के साथ भी काम करता है:

db.collection("restaurants").where("editors_pick", "==", true)
                            .orderBy("star_rating")

इंडेक्स करने की सीमाएं

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

इंडेक्स करने के सबसे सही तरीके

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

अगर एक से ज़्यादा फ़ील्ड पर रेंज और इनइक्वालिटी ऑपरेटर वाली क्वेरी इस्तेमाल की जा रही हैं, तो इंडेक्सिंग से जुड़ी ज़रूरी बातें देखें. इनसे आपको Cloud Firestore क्वेरी की परफ़ॉर्मेंस और लागत को ऑप्टिमाइज़ करने में मदद मिलेगी.

इंडेक्स करने से जुड़ी समस्याओं (इंडेक्स फ़ैनआउट, INVALID_ARGUMENT गड़बड़ियां) को हल करने के बारे में ज़्यादा जानने के लिए, समस्या हल करने वाला पेज देखें.