Query Explain की मदद से, क्वेरी के एक्ज़ीक्यूशन का विश्लेषण करना

यह सिर्फ़ Cloud Firestore Enterprise वर्शन के लिए काम का है.

इस पेज पर, क्वेरी को लागू करते समय क्वेरी की परफ़ॉर्मेंस से जुड़ी जानकारी पाने का तरीका बताया गया है.

क्वेरी की व्याख्या करने वाली सुविधा का इस्तेमाल करना

क्वेरी एक्सप्लेन का इस्तेमाल करके, यह समझा जा सकता है कि आपकी क्वेरी कैसे एक्ज़ीक्यूट की जा रही हैं. इससे आपको ऐसी जानकारी मिलती है जिसका इस्तेमाल करके, अपनी क्वेरी को ऑप्टिमाइज़ किया जा सकता है.

Google Cloud Console या explain कमांड का इस्तेमाल करके, क्वेरी की व्याख्या की जा सकती है.

कंसोल

क्वेरी एडिटर में कोई क्वेरी चलाएं और एक्सप्लेनेशन टैब खोलें:

  1. Google Cloud Console में, डेटाबेस पेज पर जाएं.

    डेटाबेस पर जाएं

  2. डेटाबेस की सूची में से, MongoDB के साथ काम करने वाला Cloud Firestore डेटाबेस चुनें. Google Cloud Console, उस डेटाबेस के लिए Firestore Explorer खोलता है.
  3. क्वेरी एडिटर में कोई क्वेरी डालें और चलाएं पर क्लिक करें.

  4. क्वेरी के विश्लेषण का आउटपुट देखने के लिए, एक्सप्लेनेशन टैब पर क्लिक करें.

    कंसोल में क्वेरी की व्याख्या करने वाला टैब
MongoDB API

MongoDB API में Query Explain सुविधा, explain कमांड के ज़रिए काम करती है. इस कमांड का इस्तेमाल Mongo Shell और Compass जैसे टूल में किया जा सकता है.

explain कमांड को aggregate, find, distinct, और count कमांड के साथ इस्तेमाल किया जा सकता है. उदाहरण के लिए:

db.collection.explain.find(...)

explain() तरीके का भी इस्तेमाल किया जा सकता है. उदाहरण के लिए:

db.collection.find({QUERY}).explain()
सीमाएं
इन बातों का ध्यान रखें:

  • क्वेरी के बारे में जानकारी देने वाली सुविधा, कर्सर दिखाने वाले निर्देशों के साथ काम नहीं करती. उदाहरण के लिए, सीधे तौर पर यह कमांड कॉल करके, 'जवाब के बारे में जानकारी दो' सुविधा को चालू नहीं किया जा सकता:

    db.collection.aggregate(..., explain: true)

  • क्वेरी के बारे में जानकारी देने की सुविधा, सिर्फ़ find, aggregate, count, और distinct कमांड के साथ काम करती है.

  • MongoDB API के ज़रिए, क्वेरी की व्याख्या करने की सुविधा के Verbosity और Comment विकल्पों का इस्तेमाल नहीं किया जा सकता. यह व्यवहार, executionStats विकल्प से मेल खाता है. अगर allPlansExecution और queryPlanner विकल्प दिए जाते हैं, तो उन्हें अनदेखा कर दिया जाता है.

विश्लेषण

'क्वेरी की जानकारी दें' सुविधा के आउटपुट में दो मुख्य कॉम्पोनेंट होते हैं: खास जानकारी के आंकड़े और एक्ज़ीक्यूशन ट्री. उदाहरण के लिए, इस क्वेरी पर विचार करें:

db.order.aggregate(
 [
   { "$match": { "user_id": 1234 } },
   { "$sort": { "date_placed": 1 } }
 ]
)

आंकड़ों की खास जानकारी

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

Billing Metrics:
read units: 1

Execution Metrics:
request peak memory usage: 4.00 KiB (4,096 B)
results returned: 1

एक्ज़ीक्यूशन ट्री

एक्ज़ीक्यूशन ट्री, क्वेरी को नोड की सीरीज़ के तौर पर दिखाता है. सबसे नीचे मौजूद नोड (लीफ़ नोड), स्टोरेज लेयर से डेटा पाते हैं. यह डेटा, क्वेरी का जवाब जनरेट करने के लिए ट्री में ऊपर की ओर जाता है.

हर एक्ज़ीक्यूशन नोड के बारे में जानकारी के लिए, एक्ज़ीक्यूशन रेफ़रंस देखें.

क्वेरी को ऑप्टिमाइज़ करने के लिए इस जानकारी का इस्तेमाल करने के तरीके के बारे में जानने के लिए, क्वेरी को ऑप्टिमाइज़ करना लेख पढ़ें.

यहां एक्ज़ीक्यूशन ट्री का एक उदाहरण दिया गया है:

• Compute
|  $out_1: map_set($record_1, "__id__", $__id___1, "__key__", $__key___1, "__row_id__", $__row_id___1, "__$0__", $__$0___2)
|  is query result: true
|
|  Execution:
|   records returned: 1
|
└── • Compute
    |  $__$0___2: UNSET
    |
    |  Execution:
    |   records returned: 1
    |
    └── • Compute
        |  $__key___1: UNSET
        |  $__row_id___1: UNSET
        |
        |  Execution:
        |   records returned: 1
        |
        └── • Compute
            |  $__id___1: _id($record_1.__key__)
            |
            |  Execution:
            |   records returned: 1
            |
            └── • MajorSort
                |  fields: [$v_5 ASC]
                |  output: [$record_1]
                |
                |  Execution:
                |   records returned: 1
                |   peak memory usage: 4.00 KiB (4,096 B)
                |
                └── • Compute
                    |  $v_5: array_get($v_4, 0L)
                    |
                    |  Execution:
                    |   records returned: 1
                    |
                    └── • Compute
                        |  $v_4: sortPaths(array($record_1.date_placed), [date_placed ASC])
                        |
                        |  Execution:
                        |   records returned: 1
                        |
                        └── • Filter
                            |  expression: $eq($user_id_1, 1,234)
                            |
                            |  Execution:
                            |   records returned: 1
                            |
                            └── • TableScan
                                   source: **/my_collection
                                   order: STABLE
                                   properties: * - { __create_time__, __update_time__ }
                                   output record: $record_1
                                   output bindings: {$user_id_1=user_id}
                                   variables: [$record_1, $user_id_1]

                                   Execution:
                                    records returned: 1
                                    records scanned: 1

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