एक से ज़्यादा फ़ील्ड पर, रेंज और इनक्वलिटी फ़िल्टर के साथ क्वेरी करने से जुड़ी खास जानकारी

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

एक से ज़्यादा फ़ील्ड पर रेंज और इनक्वलिटी फ़िल्टर

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

वेब वर्शन 9 मॉड्यूलर

  const q = query(
      collection(db, "users"),
      where('age', '>', 35),
      where('height', '>', 60),
      where('height', '<', 70)
    );

Swift

 let query = db.collection("users")
   .whereField("age", isGreaterThan: 35)
   .whereField("height", isGreaterThan: 60)
   .whereField("height", isLessThan: 70)

Objective-C

 FIRQuery *query = 
  [[[[self.db collectionWithPath:@"users"]
 queryWhereField:@"age" isGreaterThan:@35]
    queryWhereField:@"height" isGreaterThan:@60] 
        queryWhereField:@"height" isLessThan:@70];

Java Android

 Query query = db.collection("users")
  .whereGreaterThan("age", 35)
  .whereGreaterThan("height", 60)
  .whereLessThan("height", 70);

Kotlin+KTX Android

 val query = db.collection("users")
  .whereGreaterThan("age", 35)
  .whereGreaterThan("height", 60)
  .whereLessThan("height", 70)

Java

  db.collection("users")
    .whereGreaterThan("age", 35)
    .whereGreaterThan("height", 60)
    .whereLessThan("height", 70);

Node.js

db.collection("users")
  .where('age', '>', 35),
  .where('height', '>', 60),
  .where('height', '<', 70)

इंडेक्स करने से जुड़ी ज़रूरी बातें

अपनी क्वेरी चलाना शुरू करने से पहले, पक्का करें कि आपने क्वेरी और Cloud Firestore डेटा मॉडल के बारे में जानकारी.

Cloud Firestore में, क्वेरी के ORDER BY क्लॉज़ से तय होता है कि कौनसे इंडेक्स का इस्तेमाल क्वेरी चलाने के लिए किया जा सकता है. उदाहरण के लिए, ORDER BY a ASC, b ASC क्वेरी a ASC, b ASC फ़ील्ड पर एक कंपोज़िट इंडेक्स की ज़रूरत है.

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

मान लें कि आपको कर्मचारियों के एक संग्रह के बारे में जानना है और ऐसे कर्मचारी जिनका वेतन 10,000 से ज़्यादा है और जिनके इतने सालों का अनुभव है 0 से ज़्यादा होना चाहिए. डेटासेट के बारे में आपकी समझ के आधार पर, आपको पता है कि सैलरी की सीमा, अनुभव की सीमा से ज़्यादा चुनिंदा होती है. सबसे सही की वजह से इंडेक्स स्कैन की संख्या कम हो जाएगी (salary [...], experience [...]). इस तरह, वह क्वेरी जो तेज़ और किफ़ायती दर पर, salary को experience से पहले ऑर्डर करेगा और यह ऐसा दिखेगा:

Java

db.collection("employees")
  .whereGreaterThan("salary", 100000)
  .whereGreaterThan("experience", 0)
  .orderBy("salary")
  .orderBy("experience");

Node.js

db.collection("employees")
  .where("salary", ">", 100000)
  .where("experience", ">", 0)
  .orderBy("salary")
  .orderBy("experience");

Python

db.collection("employees")
  .where("salary", ">", 100000)
  .where("experience", ">", 0)
  .order_by("salary")
  .order_by("experience");

इंडेक्स ऑप्टिमाइज़ करने के सबसे सही तरीके

इंडेक्स को ऑप्टिमाइज़ करते समय, इन सबसे सही तरीकों पर ध्यान दें.

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

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

बेहतर इंडेक्स बनाने के बारे में ज़्यादा जानने के लिए, सबसे अच्छे इंडेक्स की परिभाषा देखें.

क्वेरी कंस्ट्रेंट सेलेक्टिविटी के घटते क्रम में ऑर्डर फ़ील्ड

यह पक्का करने के लिए कि Cloud Firestore आपकी क्वेरी के लिए सबसे सही इंडेक्स चुने, ऐसा orderBy() क्लॉज़ बताएं जिसमें फ़ील्ड, क्वेरी के घटते क्रम में हों कंस्ट्रेंट सेलेक्टिविटी. उच्च चयनात्मकता इसके छोटे उपसमुच्चय से मेल खाती है दस्तावेज़ों के एक बड़े सबसेट से, कम से कम चुनिंदा दस्तावेज़ मेल खाते हैं. पक्का करें कि इंडेक्स में, ज़्यादा वैल्यू वाली रेंज या इनक्वलिटी फ़ील्ड को चुना जाता है कम से कम चुनिंदा फ़ील्ड की तुलना में क्रम में लगाएं.

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

उदाहरण के लिए, मान लीजिए कि आप कर्मचारियों के एक समूह में जाकर खोज करना चाहते हैं वे कर्मचारी जिनका वेतन 100,000 से ज़्यादा है और नतीजों को कर्मचारी के अनुभव के बारे में बात करते हैं. अगर आपको लगता है कि सिर्फ़ कुछ ही कर्मचारियों को सैलरी मिलेगी से ज़्यादा है, तो क्वेरी लिखने का सबसे असरदार तरीका यह है:

Java

db.collection("employees")
  .whereGreaterThan("salary", 100000)
  .orderBy("salary")
  .get()
  .addOnSuccessListener(new OnSuccessListener<QuerySnapshot>() {
        @Override
        public void onSuccess(QuerySnapshot queryDocumentSnapshots) {
          // Order results by `experience`
        }
    });;

Node.js

const querySnapshot = await db.collection('employees')
                              .where("salary", ">", 100000)
                              .orderBy("salary")
                              .get();

// Order results by `experience`

Python

results = db.collection("employees")
            .where("salary", ">", 100000)
            .order_by("salary")
            .stream()

// Order results by `experience`

क्वेरी में experience पर ऑर्डर जोड़ने पर वही सेट मिलेगा और क्लाइंट पर परिणामों के क्रम को बदलने से रोकने के लिए, क्वेरी पिछली क्वेरी की तुलना में कहीं ज़्यादा बाहरी इंडेक्स एंट्री पढ़ें. ऐसा इसलिए है, क्योंकि Cloud Firestore हमेशा ऐसे इंडेक्स को प्राथमिकता देता है जिसके इंडेक्स फ़ील्ड प्रीफ़िक्स क्वेरी के क्लॉज़ के हिसाब से क्रम में लगाएं. अगर experience को क्लॉज़ के मुताबिक ऑर्डर में जोड़ा गया था, इसके बाद, Cloud Firestore, (experience [...], salary [...]) इंडेक्स चुनेगा का इस्तेमाल किया जाता है. इसलिए, क्योंकि Search Ads 360 के नए वर्शन पर experience, Cloud Firestore, यहां दी गई सभी इंडेक्स एंट्री पढ़ेगा फ़ाइनल नतीजे देखने के लिए, salary फ़िल्टर लागू करने से पहले employees कलेक्शन परिणाम सेट इसका मतलब है कि इंडेक्स की गई एंट्री जो salary के मुताबिक नहीं हैं फ़िल्टर अब भी पढ़ा जाता है. इससे क्वेरी का इंतज़ार समय और लागत बढ़ जाती है.

कीमत

कई फ़ील्ड पर, रेंज और इनक्वलिटी फ़िल्टर वाली क्वेरी का बिल इनके आधार पर भेजा जाता है दस्तावेज़ों को पढ़ा और इंडेक्स किया जाता है.

ज़्यादा जानकारी के लिए, कीमत पेज देखें.

सीमाएं

क्वेरी की सीमाओं के अलावा, इन सीमाओं का पहले ध्यान रखें एक से ज़्यादा फ़ील्ड पर रेंज और इनक्वलिटी फ़िल्टर वाली क्वेरी का इस्तेमाल करके:

  • दस्तावेज़ के फ़ील्ड और सिर्फ़ 'बराबर' पर रेंज या इनक्वलिटी फ़िल्टर वाली क्वेरी दस्तावेज़ कुंजी (__name__) पर प्रतिबंध समर्थित नहीं हैं.
  • Cloud Firestore, रेंज या इनक्वलिटी फ़ील्ड की संख्या को 10 तक सीमित करता है. ऐसा इसलिए किया जाता है, ताकि क्वेरी का खर्च बहुत ज़्यादा न हो चलाने के लिए.

आगे क्या करना है