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

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

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

इस क्वेरी में, जनसंख्या और घनत्व के हिसाब से रेंज फ़िल्टर का इस्तेमाल किया गया है, ताकि सभी नतीजे दिखाए जा सकें ऐसे शहर जहां जनसंख्या 10,00,000 से ज़्यादा है और जनसंख्या घनत्व इलाके की हर इकाई में 10,000 से कम लोग हैं.

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

const q = query(
    collection(db, "cities"),
    where('population', '>', 1000000),
    where('density', '<', 10000),
  );

Swift

let query = db.collection("cities")
  .whereField("population", isGreaterThan: 1000000)
  .whereField("density", isLessThan: 10000)

Objective-C

FIRQuery *query =
 [[[[self.db collectionWithPath:@"cities"]
queryWhereField:@"population" isGreaterThan:@1000000]
   queryWhereField:@"density" isLessThan:@10000];

Java Android

Query query = db.collection("cities")
 .whereGreaterThan("population", 1000000)
 .whereLessThan("density", 10000);

Kotlin+KTX Android

val query = db.collection("cities")
 .whereGreaterThan("population", 1000000)
 .whereLessThan("density", 10000)

शुरू करें

   query := client.Collection("cities").
      Where("population", ">", 1000000).
      Where("density", "<", 10000)

Java

db.collection("cities")
  .whereGreaterThan("population", 1000000)
  .whereLessThan("density", 10000);

Node.js

db.collection("cities")
  .where('population', '>', 1000000),
  .where('density', '<', 10000)

Python

from google.cloud import firestore

db = firestore.Client()
query = db.collection("cities")
.where("population", ">", 1000000)
.where("density", "<", 10000)

PHP

$collection = $db->collection('samples/php/cities');
$chainedQuery = $collection
    ->where('population', '>', 1000000)
    ->where('density', '<', 10000);

query_filter_compound_multi_ineq.php

C#

CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef
    .WhereGreaterThan("Population", 1000000)
    .WhereLessThan("Density", 10000);
QuerySnapshot querySnapshot = await query.GetSnapshotAsync();
foreach (DocumentSnapshot documentSnapshot in querySnapshot)
{
    var name = documentSnapshot.GetValue<string>("Name");
    var population = documentSnapshot.GetValue<int>("Population");
    var density = documentSnapshot.GetValue<int>("Density");
    Console.WriteLine($"City '{name}' returned by query. Population={population}; Density={density}");
}
Program.cs

Ruby

query = cities_ref.where("population", ">", "1000000")
                  .where("density", "<", 10000)

C++

CollectionReference cities_ref = db->Collection("cities");
Query query = cities_ref.WhereGreaterThan("population", FieldValue::Integer(1000000))
                       .WhereLessThan("density", FieldValue::Integer(10000));

Unity

CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereGreaterThan("population", 1000000)
                      .WhereLessThan("density", 10000);

Dart

final citiesRef = FirebaseFirestore.instance.collection('cities')
final query = citiesRef.where("population", isGreaterThan: 1000000)
                  .where("density", isLessThan: 10000);

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

अपनी क्वेरी चलाने से पहले, पढ़ें क्वेरी और Cloud Firestore डेटा मॉडल के बारे में जानकारी.

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

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

मान लीजिए कि आपको कर्मचारियों के एक संग्रह के बारे में जानना है और पता लगाना है कि ऐसे कर्मचारी जिनका वेतन 1,00,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 से ज़्यादा है और वे कर्मचारी के अनुभव के बारे में बात करते हैं. अगर आपको लगता है कि सिर्फ़ कुछ ही कर्मचारियों को सैलरी मिलेगी 1,00,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 [...]) इंडेक्स को चुनेगा का इस्तेमाल किया जाता है. हालांकि, इस पर अन्य पाबंदियां लागू नहीं होती हैं experience, Cloud Firestore इसकी सभी इंडेक्स एंट्री पढ़ेगा salary फ़िल्टर लगाने से पहले, employees कलेक्शन देखें. इससे आखिरी नतीजे ढूंढने में मदद मिलेगी परिणाम सेट इसका मतलब है कि इंडेक्स की गई ऐसी एंट्री जो salary के मुताबिक नहीं हैं फ़िल्टर अब भी पढ़ा जाता है. इससे क्वेरी का इंतज़ार समय और लागत बढ़ जाती है.

कीमत

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

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

सीमाएं

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

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

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