क्वेरी एक्ज़ीक्यूट करने का रेफ़रंस

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

सामान्य कॉन्सेप्ट

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

लाइनें और रिकॉर्ड

लाइन और रिकॉर्ड शब्दों का इस्तेमाल, आम तौर पर किसी दस्तावेज़ या इंडेक्स एंट्री के लिए किया जाता है.

वैरिएबल

$ एक वैरिएबल को दिखाता है, जिसे एक्ज़ीक्यूशन ट्री में बनाया गया है या रेफ़रंस के तौर पर इस्तेमाल किया गया है. उदाहरण के लिए: $foo_1. आम तौर पर, इन वैरिएबल का इस्तेमाल किसी दस्तावेज़ के कॉन्टेंट या किसी क्वेरी को लागू करने के दौरान, आकलन किए गए एक्सप्रेशन की वैल्यू को रेफ़र करने के लिए किया जाता है.

एग्ज़िक्यूशन नोड में ये इंटरनल वैरिएबल दिख सकते हैं:

• $__key__ - कुंजी, किसी दस्तावेज़ का इंटरनल आइडेंटिफ़ायर होती है. यह एक यूनीक आइडेंटिफ़ायर है. इसमें प्रोजेक्ट, डेटाबेस, और दस्तावेज़ का पूरा पाथ शामिल होता है.
• $__id__ - आईडी, किसी कलेक्शन में मौजूद दस्तावेज़ का यूनीक आइडेंटिफ़ायर होता है. यह किसी एक कलेक्शन में यूनीक होता है.
• $rid - लाइन आईडी, स्टोरेज में मौजूद किसी दस्तावेज़ का इंटरनल आइडेंटिफ़ायर होता है. यह किसी एक कलेक्शन में यूनीक होता है.

उदाहरण के लिए, मान लें कि दस्तावेज़ __key__ से __id__ का हिसाब लगाने के लिए, Compute नोड का इस्तेमाल किया जाता है:

Compute
    |  $__id__1: _id($__key__)
    |  records returned: 1

पाबंदियां और रेंज

कुछ स्कैन नोड, स्कैन की गई वैल्यू की रेंज के बारे में बताने के लिए, constraints और ranges एट्रिब्यूट का इस्तेमाल करते हैं. इन एट्रिब्यूट में रेंज ट्री फ़ॉर्मैट का इस्तेमाल किया जाता है. इसमें वैल्यू की एक सूची होती है. ये वैल्यू, इंडेक्स की परिभाषा में दिखने वाली कुंजियों की क्रम वाली सूची से जुड़ी होती हैं. उदाहरण के लिए, ट्री में दिखने वाली पहली रेंज, यहां (1..5], कुंजियों की क्रम वाली सूची में पहली कुंजी, यहां a, की सीमाओं से मेल खाती है:

| index: type=CollectionGroupIndex, id=CICAgOjXh#EK, keys=[a ASC, b ASC, __key__ ASC]
| constraints: /
               |----(1..5]
                    |----[1L]

इंडेंटेशन का हर लेवल, सूची में अगली कुंजी पर लागू होने वाली पाबंदी को दिखाता है. स्क्वेयर ब्रैकेट, इन्क्लूसिव रेंज को दिखाते हैं. वहीं, राउंड ब्रैकेट, एक्सक्लूसिव रेंज को दिखाते हैं. इस मामले में, शर्त का मतलब 1 < "a" <= 5 और "b" = 1 है.

a के लिए कई ब्रांच वाले इस उदाहरण में, शर्त 1 < a <= 5 OR a = 10 से मेल खाती है:

| constraints: /
               |----(1L, 5L]
               |----[10L]

मुख्य वैरिएबल

कुछ स्कैन नोड (जैसे कि SequentialScan) में, index एट्रिब्यूट के हिस्से के तौर पर कुंजियों की सूची और Scan नोड में एक अलग keys एट्रिब्यूट होता है. Scan नोड में मौजूद keys एट्रिब्यूट, इंडेक्स की परिभाषा में मौजूद हर कुंजी के वैरिएबल नाम को क्रम से दिखाता है. एग्ज़ीक्यूशन ट्री में स्कैन किए गए फ़ील्ड की रनटाइम वैल्यू को रेफ़रंस देने के लिए, वैरिएबल का इस्तेमाल किया जा सकता है.

इस उदाहरण में, मौजूदा दस्तावेज़ के लिए user फ़ील्ड की वैल्यू, वैरिएबल $user_1 और date_placed की वैल्यू, $date_placed_1 पर मैप होती है.

index: type=CollectionGroupIndex, id=CICAgOjXh4EK, keys=[user ASC, date_placed ASC, __key__ ASC]
keys: [user ASC, date_placed ASC, __key__ ASC]

एक्ज़ीक्यूशन नोड

क्वेरी एक्ज़ीक्यूशन ट्री में ये नोड हो सकते हैं.

SeekingScan

यह डाइनैमिक स्कैन को दिखाता है. इसमें, नतीजे के तौर पर मिली लाइनें, इंडेक्स की एक ही क्रम वाली रेंज में नहीं हो सकती हैं. साथ ही, क्वेरी को पूरा करने के लिए, कई अलग-अलग स्कैन करने होंगे.

उदाहरण के लिए, ऐसी क्वेरी जिसमें a मौजूद है और b की वैल्यू 1 है, ["a" ASC, "b" ASC] के इंडेक्स पर काम करती है. इसके लिए, a की हर अलग वैल्यू के लिए, एक अलग और संभावित रूप से क्रम में न होने वाली रेंज को स्कैन करना और उसे दिखाना होगा. यह पूरी तरह से TableScan करने से ज़्यादा असरदार है. हालांकि, ["b" ASC, "a" ASC] के कंपोज़िट इंडेक्स पर एक SequentialScan करने से कम असरदार है.

• SeekingScan
| constraints: /
               |----(-∞..+∞)
                    |----[1L]
| index: type=CollectionGroupIndex, id=CAE, keys=[user ASC, quantity ASC, __key__ ASC]
| keys: [user ASC, quantity ASC, __key__ ASC]
| properties: Selection { user }
| records returned: 1
| records scanned: 1

SequentialScan

यह स्टोरेज में मौजूद पंक्तियों की स्टैटिक और क्रम से चलने वाली रेंज के स्कैन को दिखाता है. इसे एक ही बार में स्कैन किया जा सकता है.

key ordering length से उन कुंजियों की संख्या का पता चलता है जिन्हें सुरक्षित रखना ज़रूरी है. साथ ही, इन्हें कुंजियों के ओरिजनल क्रम में दिखाना ज़रूरी है. [k1, k2, k3] के स्कीमा के लिए, कुंजी के क्रम की लंबाई 0 होने का मतलब है कि स्कैन किसी भी क्रम में नतीजे दिखा सकता है. 1 का मतलब है कि k1 के हिसाब से क्रम में लगाया गया है, लेकिन एक जैसी k1 वैल्यू वाली लाइनें किसी भी क्रम में आ सकती हैं. 3 का मतलब है कि दस्तावेज़ों को क्रम से लगाया गया है.

• SequentialScan
| index: type=CollectionGroupIndex, id=CAE, keys=[user ASC, date_placed ASC, __key__ ASC]
| key ordering length: 3
| keys: [user ASC, date_placed ASC, __key__ ASC]
| limit: 10
| properties: Selection { a }
| ranges: /
| records returned: 1
| records scanned: 1

UniqueScan

यह स्टोरेज में मौजूद पंक्तियों की स्टैटिक और क्रम से चलने वाली रेंज को स्कैन करता है. साथ ही, इन-मेमोरी डुप्लीकेट कॉपी हटाने की तकनीक का इस्तेमाल करके, डुप्लीकेट पंक्तियों को हटाता है.

• UniqueScan
| index: type=CollectionGroupIndex, id=CAE, keys=[user ASC, date_placed ASC, __key__ ASC]
| keys: [user ASC, date_placed ASC, __key__ ASC]
| properties: Selection { a }
| ranges: /
          |----(-∞..+∞)
| records returned: 1
| records scanned: 1

IndexSeek

यह एक डाइनैमिक स्कैन को दिखाता है. इसमें, रनटाइम डेटा के हिसाब से पंक्तियों को पैरामीटर के तौर पर सेट किया जा सकता है. साथ ही, हो सकता है कि ये पंक्तियां इंडेक्स की एक ही क्रम वाली रेंज में न हों. इसके अलावा, क्वेरी के हिसाब से नतीजे दिखाने के लिए, कई अलग-अलग स्कैन किए जा सकते हैं.

उदाहरण के लिए, ["user" ASC, "date_placed" ASC] के इंडेक्स पर चल रही ऐसी क्वेरी जिसमें user, $user_id के बराबर है और date_placed, "2025-08-10" के बराबर है, वह रनटाइम के दौरान $user_id वैरिएबल की वैल्यू का इस्तेमाल करेगी. साथ ही, स्कैन की रेंज को सीमित करने के लिए, date_placed पर "2025-08-10" की पाबंदी का इस्तेमाल करेगी.

• IndexSeek
| index: type=CollectionGroupIndex, id=CAE, keys=[user ASC, date_placed ASC, __key__ ASC]
| fields: [$user_1 ASC, $date_placed_1 ASC, $rid ASC]
| key: $key_1
| filter: $eq($user_1, $user_id) AND $eq($date_placed_1, "2025-08-10")
| records returned: 1
| records scanned: 1

लाएं

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

• Fetch
|  order: PRESERVE_INPUT_ORDER
|  peak memory usage: 4.00 KiB (4,096 B)
|  properties: *
|  records returned: 1

TableScan

किसी कलेक्शन का पूरा और बिना क्रम वाला स्कैन. इसका इस्तेमाल तब किया जाता है, जब किसी क्वेरी को उससे जुड़े इंडेक्स के बिना चलाया जाता है.

क्रम STABLE या UNDEFINED हो सकता है. इसमें STABLE, डिटरमिनिस्टिक ऑर्डर को दिखाता है.

• TableScan
|  order: STABLE
|  properties: *
|  records returned: 1
|  records scanned: 1
|  source: (default)#/**/collection

लागू करें

यह डेटा के दो सेट (input और map) को आपस में जोड़ता है. इसके लिए, यह input की हर लाइन को स्कैन करता है और हर लाइन के लिए, map साइड से नतीजे स्कैन करके दिखाता है.

join_type से पता चलता है कि किस तरह का जॉइन इस्तेमाल किया गया है. उदाहरण के लिए, LEFT_OUTER का मतलब है कि input की सभी लाइनें, आउटपुट में कम से कम एक बार शामिल की गई हैं. अगर input टेबल की किसी पंक्ति को map टेबल में कोई मैच नहीं मिलता है, तो भी उसे शामिल किया जाएगा. हालांकि, map टेबल के कॉलम के लिए null वैल्यू का इस्तेमाल किया जाएगा.

• Apply
|  join_type: LEFT_OUTER
|
└── • input tree
|     ...
└── • map tree
      ...

HashAggregate

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

• HashAggregate
|  aggregations: [sum($b_1) AS total]
|  groups: [$a_1]
|  peak memory usage: 4.00 KiB (4,096 B)
|  records returned: 0

StreamAggregate

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

• StreamAggregate
|  keys: [foo ASC, bar ASC]
|  properties: Selection { baz }
|  aggregations: [$sum($foo_1) AS baz]

MajorSort

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

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

• MajorSort
|  fields: [a ASC, b DESC]
|  limit: 10
|  peak memory usage: 4.00 KiB (4,096 B)
|  records returned: 1

Concat

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

• Concat
├── • Fetch
...
├── • Fetch

कंप्यूट

यह एक्सप्रेशन के सेट का आकलन करता है और नतीजों को वैरिएबल के सेट को असाइन करता है.

• Compute
|  $user_1: user
|  $full_name_1: str_concat($first_name_1, " ", $last_name_1)
|  $address_1: UNSET
|  records returned: 1

फ़िल्टर

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

• Filter
|  expression: $eq(foo, "bar")
|  records returned: 1

RecordCount

यह चाइल्ड नोड से जनरेट हुई लाइनों की संख्या की गिनती करता है. साथ ही, मौजूदा संख्या को count एट्रिब्यूट में बताए गए वैरिएबल में दिखाता है.

• RecordCount
|  count: $row_number_1
|  records returned: 1

वैल्यू

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

• Values
| expression: [{__key__=/col/1}, {__key__=/col/2}]

अननेस्ट

चाइल्ड नोड से जनरेट की गई वैल्यू को अननेस्ट करता है.

• Unnest
|  expression: foo AS unnested_foo

सीमा

यह पैरंट नोड को दिखाई जाने वाली पंक्तियों की संख्या को सीमित करता है.

• Limit
|  limit: 10
|  records returned: 1

ऑफ़सेट

चाइल्ड नोड से जनरेट की गई लाइनों की तय संख्या को स्किप करता है.

• Offset
|  offset: 10
|  records returned: 1