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

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

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

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

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

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

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

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

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

इंडेक्स को मैनेज करने में कम समय लगता है और ऐप्लिकेशन को डेवलप करने में ज़्यादा समय मिलता है

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

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

Cloud Firestore दो तरह के इंडेक्स का इस्तेमाल करता है: सिंगल-फ़ील्ड और कंपोज़िट. इंडेक्स किए गए फ़ील्ड की संख्या के अलावा, सिंगल-फ़ील्ड और कंपोज़िट इंडेक्स को मैनेज करने के तरीके में भी अंतर होता है.

सिंगल-फ़ील्ड इंडेक्स

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

अपने-आप इंडेक्स होने की सुविधा

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

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

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

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

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

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

सिंगल-फ़ील्ड इंडेक्स से जुड़ी छूट

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

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

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

सिंगल-फ़ील्ड इंडेक्स के लिए छूट बनाने और उन्हें मैनेज करने के लिए, इंडेक्स मैनेज करना लेख पढ़ें.

कंपोज़िट इंडेक्स

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

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, और tags फ़ील्ड सेट किए गए हैं:

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"])

कंपोज़िट इंडेक्स के साथ काम करने वाली क्वेरी

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

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" });

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

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
• temperatures.summer ASC
• temperatures.summer DESC
• temperatures.winter ASC
• temperatures.winter DESC
• पड़ोस की जानकारी देने वाला कलेक्शन, इसमें ये शामिल हैं (ASC और DESC)

कंपोज़िट इंडेक्स

• 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 गड़बड़ियां) को हल करने के बारे में ज़्यादा जानकारी के लिए, समस्या हल करने वाला पेज देखें.