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 का इस्तेमाल करके, इंडेक्स को मैन्युअल तरीके से भी तय और मैनेज किया जा सकता है. मैन्युअल इंडेक्स बनाने और उन्हें मैनेज करने के बारे में ज़्यादा जानने के लिए, इंडेक्स मैनेज करना लेख पढ़ें.

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

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

इंडेक्स मोड

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

इंडेक्स मोड ब्यौरा
बढ़ते क्रम में यह फ़ील्ड, <, <=, ==, >=, >, !=, in, और not-in क्वेरी क्लॉज़ के साथ काम करता है. साथ ही, इस फ़ील्ड की वैल्यू के आधार पर, नतीजों को बढ़ते क्रम में लगाया जा सकता है.
घटते क्रम में यह फ़ील्ड, <, <=, ==, >=, >, !=, in, और not-in क्वेरी क्लॉज़ के साथ काम करता है. साथ ही, इस फ़ील्ड की वैल्यू के आधार पर, नतीजों को घटते क्रम में लगाया जा सकता है.
Array‑contains यह फ़ील्ड, array-contains और array-contains-any क्वेरी क्लॉज़ के साथ काम करता है.
वेक्टर इस फ़ील्ड में FindNearest क्वेरी क्लॉज़ इस्तेमाल किए जा सकते हैं.

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

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

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

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

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

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

डिफ़ॉल्ट रूप से, __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"] });

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

कलेक्शन फ़ील्ड इंडेक्स किया गया क्वेरी का दायरा
शहर नाम कलेक्शन
शहर राज्य कलेक्शन
शहर देश कलेक्शन
शहर कैपिटल कलेक्शन
शहर जनसंख्या कलेक्शन
शहर देश/इलाके कलेक्शन
शहर नाम कलेक्शन
शहर राज्य कलेक्शन
शहर देश कलेक्शन
शहर कैपिटल कलेक्शन
शहर जनसंख्या कलेक्शन
शहर देश/इलाके कलेक्शन
शहर array-contains देश/इलाके कलेक्शन

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

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

वेब
const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");

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")
कलेक्शन इंडेक्स किए गए फ़ील्ड क्वेरी का दायरा
शहर देश, जनसंख्या कलेक्शन
cities देश, जनसंख्या कलेक्शन

इंडेक्स मर्ज करने की वजह से परफ़ॉर्मेंस में होने वाली गिरावट से बचने के लिए, हमारा सुझाव है कि आप 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)
कलेक्शन इंडेक्स किए गए फ़ील्ड क्वेरी का दायरा
शहर array-contains tags, (या ) capital कलेक्शन

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

कलेक्शन ग्रुप के स्कोप वाले इंडेक्स को दिखाने के लिए, कुछ 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
  • neighborhoods ASC
  • आस-पास के इलाके DESC
  • तापमान के हिसाब से बढ़ते क्रम में
  • तापमान DESC
  • temperatures.summer ASC
  • temperatures.summer DESC
  • temperatures.winter ASC
  • temperatures.winter DESC
  • neighborhoods Array Contains

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

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

इंडेक्स के रिकॉर्ड

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

इंडेक्स इंडेक्स किया गया डेटा
इंडेक्स के रिकॉर्ड अपने-आप बनने की सुविधा
city_name ASC city_name: "San Francisco"
city_name DESC city_name: "San Francisco"
neighborhoods ASC neighborhoods: ["Mission", "Downtown", "Marina"]
आस-पास के इलाके DESC neighborhoods: ["Mission", "Downtown", "Marina"]
तापमान के हिसाब से बढ़ते क्रम में तापमान: {summer: 67, winter: 55}
तापमान DESC तापमान: {summer: 67, winter: 55}
temperatures.summer ASC temperatures.summer: 67
temperatures.summer DESC temperatures.summer: 67
temperatures.winter ASC temperatures.winter: 55
temperatures.winter DESC temperatures.winter: 55
neighborhoods Array Contains मोहल्ले: "मिशन"
neighborhoods Array Contains neighborhoods: "Downtown"
neighborhoods Array Contains neighborhoods: "Marina"
इंडेक्स में मैन्युअल तरीके से एंट्री करना
city_name ASC, neighborhoods ARRAY city_name: "San Francisco", neighborhoods: "Mission"
city_name ASC, neighborhoods ARRAY city_name: "San Francisco", neighborhoods: "Downtown"
city_name ASC, neighborhoods ARRAY city_name: "San Francisco", neighborhoods: "Marina"
city_name DESC, neighborhoods ARRAY city_name: "San Francisco", neighborhoods: "Mission"
city_name DESC, neighborhoods ARRAY city_name: "San Francisco", neighborhoods: "Downtown"
city_name DESC, neighborhoods ARRAY city_name: "San Francisco", neighborhoods: "Marina"

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

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

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

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

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

  • रेस्टोरेंट

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

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

कलेक्शन इंडेक्स किए गए फ़ील्ड क्वेरी का दायरा
रेस्टोरेंट कैटगरी, स्टार_रेटिंग कलेक्शन
रेस्टोरेंट शहर, star_rating कलेक्शन
रेस्टोरेंट category, city, star_rating कलेक्शन
रेस्टोरेंट category, city, editors_pick, star_rating कलेक्शन

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

कलेक्शन इंडेक्स किए गए फ़ील्ड क्वेरी का दायरा
रेस्टोरेंट कैटगरी, स्टार_रेटिंग कलेक्शन
रेस्टोरेंट शहर, star_rating कलेक्शन
रेस्टोरेंट editors_pick, star_rating कलेक्शन

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

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

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

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

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

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

हर दस्तावेज़ के लिए, इंडेक्स के रिकॉर्ड की ज़्यादा से ज़्यादा संख्या

40,000

इंडेक्स के रिकॉर्ड की संख्या, किसी दस्तावेज़ के लिए इन चीज़ों का कुल योग होती है:

  • सिंगल-फ़ील्ड इंडेक्स की एंट्री की संख्या
  • कंपोज़िट इंडेक्स की एंट्री की संख्या

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

कंपोज़िट इंडेक्स में फ़ील्ड की ज़्यादा से ज़्यादा संख्या 100
इंडेक्स के रिकॉर्ड का ज़्यादा से ज़्यादा साइज़

7.5 केआईबी

Cloud Firestore, इंडेक्स के रिकॉर्ड का साइज़ कैसे कैलकुलेट करता है, यह जानने के लिए इंडेक्स के रिकॉर्ड का साइज़ देखें.

किसी दस्तावेज़ के इंडेक्स के रिकॉर्ड के साइज़ का कुल योग

8 एमआईबी

कुल साइज़, किसी दस्तावेज़ के लिए इन चीज़ों का योग होता है:

  • किसी दस्तावेज़ के सिंगल-फ़ील्ड इंडेक्स की एंट्री के साइज़ का कुल योग
  • किसी दस्तावेज़ की कंपोज़िट इंडेक्स एंट्री के साइज़ का कुल योग
  • इंडेक्स किए गए फ़ील्ड की वैल्यू का ज़्यादा से ज़्यादा साइज़

    1,500 बाइट

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

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

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

    कारक ब्यौरा
    बड़े स्ट्रिंग फ़ील्ड

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

    क्रम में चलने वाली वैल्यू वाले दस्तावेज़ों के कलेक्शन में, डेटा लिखने की दर ज़्यादा होना

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

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

    टीटीएल फ़ील्ड

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

    बड़ी श्रेणी या मैप फ़ील्ड

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

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

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