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

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

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

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

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

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

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

हर क्वेरी के लिए इंडेक्स

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

इंडेक्स मैनेजमेंट की कम ज़रूरत, ऐप्लिकेशन डेवलपमेंट पर ज़्यादा सुविधाएं

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

इंडेक्स टाइप

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

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

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

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

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

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

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

  • बिना कलेक्शन वाले, बिना मैप वाले हर सबफ़ील्ड के लिए, कलेक्शन के स्कोप वाला आरोही इंडेक्स.
  • बिना कलेक्शन वाले, बिना मैप वाले हर सबफ़ील्ड के लिए, कलेक्शन-स्कोप का एक घटते क्रम वाला इंडेक्स.
  • कलेक्शन के स्कोप वाले अरे में हर अरे सबफ़ील्ड के लिए इंडेक्स शामिल होता है.
  • Cloud Firestore, मैप के हर सबफ़ील्ड को बार-बार इंडेक्स करता है.

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

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

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

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

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

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

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

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

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

Cloud Firestore, एक साथ कई इंडेक्स का इस्तेमाल करता है क्वेरी जो पहले से सिंगल-फ़ील्ड इंडेक्स के साथ काम नहीं करतीं.

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

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

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

इंडेक्स मोड और क्वेरी के दायरे

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

इंडेक्स मोड

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

क्वेरी के स्कोप

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

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

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

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

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

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

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

डिफ़ॉल्ट रूप से, __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 अपडेट हो जाता है हर नॉन-अरे फ़ील्ड में एक बढ़ते क्रम वाला सिंगल-फ़ील्ड इंडेक्स, एक घटते क्रम वाला सिंगल- हर गैर-अरे फ़ील्ड की फ़ील्ड इंडेक्स और एक अरे में अरे फ़ील्ड का इस्तेमाल करें. नीचे दी गई टेबल की हर पंक्ति में सिंगल-फ़ील्ड इंडेक्स:

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

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

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

कलेक्शन के स्कोप के साथ यहां दिए गए सिंगल-फ़ील्ड इंडेक्स का इस्तेमाल करके क्वेरी की जा सकती है 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 एएससी
• शहर का नाम DESC
• तापमान.गर्मी एएससी
• तापमान.गर्मी का DESC
• तापमान.सर्दियों में एएससी
• तापमान.सर्दियों के बारे में जानकारी
• आस-पड़ोस में मौजूद अरे में शामिल है (ASC और DESC)

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

• City_name ASC, आस-पड़ोस के ARRAY
• City_name DESC, आस-पड़ोस के ARRAY

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

इंडेक्स करने से जुड़े इस कॉन्फ़िगरेशन के नतीजे के तौर पर, नीचे दी गई इंडेक्स एंट्री दस्तावेज़:

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

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

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

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

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

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

  • class बर्गर

    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 की मर्ज करने की सुविधा का फ़ायदा उठाकर इंडेक्स किए गए लोगों की संख्या eक्वालिटी क्लॉज़ के लिए इंडेक्स:

इस इंडेक्स का यह सेट न सिर्फ़ छोटा है, बल्कि दूसरी क्वेरी के साथ भी काम करता है:

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

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

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

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

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

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

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