मोंगोडीबी $indexOfBytes

MongoDB में, $indexOfBytes एकत्रीकरण पाइपलाइन ऑपरेटर एक सबस्ट्रिंग की घटना के लिए एक स्ट्रिंग की खोज करता है और पहली घटना के यूटीएफ -8 बाइट इंडेक्स देता है।

UTF बाइट इंडेक्स शून्य-आधारित है (अर्थात यह 0 . से शुरू होता है) )।

सिंटैक्स

वाक्य रचना इस प्रकार है:

{ $indexOfBytes: [ <string expression>, <substring expression>, <start>, <end> ] }

कहां:

• <string expression> खोजने के लिए स्ट्रिंग है।
• <substring expression> वह सबस्ट्रिंग है जिसे आप स्ट्रिंग में खोजना चाहते हैं।
• <start> एक वैकल्पिक तर्क है जो खोज के लिए प्रारंभिक अनुक्रमणिका स्थिति निर्दिष्ट करता है। कोई भी मान्य व्यंजक हो सकता है जो एक गैर-ऋणात्मक पूर्णांक संख्या का समाधान करता हो।
• <end> एक वैकल्पिक तर्क है जो खोज के लिए अंतिम अनुक्रमणिका स्थिति निर्दिष्ट करता है। कोई भी मान्य व्यंजक हो सकता है जो एक गैर-ऋणात्मक पूर्णांक संख्या का समाधान करता हो।

यदि निर्दिष्ट मान नहीं मिलता है, तो $indexOfBytes रिटर्न -1 ।

यदि निर्दिष्ट मान के कई उदाहरण हैं, तो केवल पहला लौटाया जाता है।

उदाहरण

मान लीजिए हमारे पास test . नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:

{ "_id" : 1, "data" : "c 2021" }
{ "_id" : 2, "data" : "© 2021" }
{ "_id" : 3, "data" : "ไม้เมือง" }

यहां $indexOfBytes applying लागू करने का एक उदाहरण दिया गया है उन दस्तावेज़ों के लिए:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "2021" ] }
          }
     }
   ]
)

परिणाम:

{ "data" : "c 2021", "result" : 2 }
{ "data" : "© 2021", "result" : 3 }
{ "data" : "ไม้เมือง", "result" : -1 }

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

इसका कारण यह है कि कॉपीराइट प्रतीक (© .) ) दूसरे दस्तावेज़ में 2 बाइट्स लगते हैं। c चरित्र (पहले दस्तावेज़ में) केवल 1 बाइट का उपयोग करता है। स्पेस कैरेक्टर भी 1 बाइट का उपयोग करता है।

$indexOfBytes . का परिणाम शून्य-आधारित है (सूचकांक 0 से शुरू होता है ), और इसलिए हम 2 . के परिणाम के साथ समाप्त होते हैं और 3 क्रमशः।

तीसरे दस्तावेज़ के संबंध में, सबस्ट्रिंग बिल्कुल नहीं मिली, और इसलिए परिणाम -1 . है ।

यहां एक और उदाहरण दिया गया है, इस समय को छोड़कर हम थाई वर्ण की खोज करते हैं:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "เ" ] }
          }
     }
   ]
)

परिणाम:

{ "data" : "c 2021", "result" : -1 }
{ "data" : "© 2021", "result" : -1 }
{ "data" : "ไม้เมือง", "result" : 9 }

इस मामले में, हमने एक ऐसे चरित्र की खोज की जो तीसरे दस्तावेज़ में तीसरे स्थान पर दिखाई देता है, और इसका UTF-8 बाइट इंडेक्स 9 के रूप में वापस आता है। .

ऐसा इसलिए है क्योंकि इस मामले में, प्रत्येक वर्ण 3 बाइट्स का उपयोग करता है। लेकिन दूसरे कैरेक्टर में एक डाइक्रिटिक मार्क होता है, जो कि 3 बाइट्स का भी होता है। इसलिए, पहले दो अक्षर (विशेषक सहित) 9 बाइट्स का उपयोग करते हैं। शून्य-आधारित अनुक्रमण को देखते हुए, उनकी UTF-8 बाइट अनुक्रमणिका 0 . से होती है करने के लिए 8 . इसका मतलब है कि तीसरा वर्ण 9 position से शुरू होता है ।

MongoDB देखें $strLenBytes एक उदाहरण के लिए जो इस विशेष स्ट्रिंग में प्रत्येक वर्ण के लिए बाइट्स की संख्या देता है।

प्रारंभिक स्थिति निर्दिष्ट करें

आप खोज के लिए प्रारंभिक अनुक्रमणिका स्थिति निर्दिष्ट करने के लिए तीसरा तर्क प्रदान कर सकते हैं।

मान लीजिए हमारे पास निम्नलिखित दस्तावेज़ हैं:

{ "_id" : 4, "data" : "ABC XYZ ABC" }

यहां $indexOfBytes applying लागू करने का एक उदाहरण दिया गया है प्रारंभिक स्थिति के साथ:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "ABC", 1 ] }
          }
     }
   ]
)

परिणाम:

{ "data" : "ABC XYZ ABC", "result" : 8 }

इस मामले में, सबस्ट्रिंग का दूसरा उदाहरण वापस कर दिया गया था। ऐसा इसलिए है क्योंकि हमने 1 . स्थिति पर खोज शुरू की है , और सबस्ट्रिंग का पहला उदाहरण स्थिति 0 . से शुरू होता है (खोज के लिए प्रारंभिक स्थिति से पहले)।

यदि प्रारंभ स्थिति स्ट्रिंग की बाइट लंबाई से अधिक या अंतिम स्थिति से अधिक है, तो $indexOfBytes रिटर्न -1 ।

यदि यह एक ऋणात्मक संख्या है, तो $indexOfBytes एक त्रुटि देता है।

एक समाप्ति स्थिति निर्दिष्ट करें

आप खोज के लिए अंतिम अनुक्रमणिका स्थिति निर्दिष्ट करने के लिए चौथा तर्क भी प्रदान कर सकते हैं।

यदि आप यह तर्क प्रदान करते हैं, तो आपको एक प्रारंभिक स्थिति भी प्रदान करनी होगी। ऐसा करने में विफल होने पर इस तर्क को शुरुआती बिंदु के रूप में व्याख्यायित किया जाएगा।

उदाहरण:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ", 0, 5 ] }
          }
     }
   ]
)

परिणाम:

{ "data" : "ABC XYZ ABC", "result" : -1 }

परिणाम -1 . है जिसका अर्थ है कि सबस्ट्रिंग नहीं मिला। ऐसा इसलिए है क्योंकि हमने 0 . स्थान पर अपनी खोज शुरू की है और इसे 5 . स्थिति पर समाप्त किया , इसलिए सबस्ट्रिंग को कैप्चर नहीं कर रहा है।

यदि हम अंतिम अनुक्रमणिका स्थिति में वृद्धि करते हैं तो यहां क्या होता है:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ", 0, 7 ] }
          }
     }
   ]
)

परिणाम:

{ "data" : "ABC XYZ ABC", "result" : 4 }

इस बार मान शामिल किया गया और इसकी अनुक्रमणिका स्थिति वापस आ गई।

यदि अंतिम स्थिति प्रारंभिक स्थिति से एक संख्या कम है, $indexOfBytes रिटर्न -1 ।

यदि यह एक ऋणात्मक संख्या है, तो $indexOfBytes एक त्रुटि देता है।

अनुपलब्ध फ़ील्ड

यदि फ़ील्ड दस्तावेज़ में नहीं है, $indexOfBytes रिटर्न null ।

मान लीजिए हमारे पास निम्नलिखित दस्तावेज़ हैं:

{ "_id" : 5 }

यहां बताया गया है कि जब हम $indexOfBytes . लागू करते हैं तो क्या होता है :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 5 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ" ] }
          }
     }
   ]
)

परिणाम:

{ "result" : null }

शून्य मान

यदि पहला तर्क null है , $indexOfBytes रिटर्न null ।

मान लीजिए हमारे पास निम्नलिखित दस्तावेज़ हैं:

{ "_id" : 6, "data" : null }

यहां बताया गया है कि जब हम $indexOfBytes . लागू करते हैं तो क्या होता है :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 6 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ" ] }
          }
     }
   ]
)

परिणाम:

{ "data" : null, "result" : null }

हालांकि, जब दूसरा तर्क (यानी सबस्ट्रिंग) null . है , एक त्रुटि वापस आ जाती है:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", null ] }
          }
     }
   ]
)

परिणाम:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$indexOfBytes requires a string as the second argument, found: null",
	"code" : 40092,
	"codeName" : "Location40092"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1

गलत डेटा प्रकार

यदि पहला तर्क गलत डेटा प्रकार है (यानी यह एक स्ट्रिंग को हल नहीं करता है), $indexOfBytes एक त्रुटि देता है।

मान लीजिए हमारे पास निम्नलिखित दस्तावेज़ हैं:

{ "_id" : 7, "data" : 123 }

यहां बताया गया है कि जब हम $indexOfBytes . लागू करते हैं तो क्या होता है उस दस्तावेज़ के लिए:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 7 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ" ] }
          }
     }
   ]
)

परिणाम:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$indexOfBytes requires a string as the first argument, found: double",
	"code" : 40091,
	"codeName" : "Location40091"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1

जैसा कि त्रुटि संदेश बताता है, $indexOfBytes requires a string as the first argument ।