मोंगोडीबी $indexOfArray

MongoDB में, $indexOfArray एकत्रीकरण पाइपलाइन ऑपरेटर एक निर्दिष्ट मान की घटना के लिए एक सरणी खोजता है और पहली घटना की सरणी अनुक्रमणिका देता है।

सिंटैक्स

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

{ $indexOfArray: [ <array expression>, <search expression>, <start>, <end> ] }

कहां:

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

MongoDB में, सरणियाँ शून्य-आधारित होती हैं, इसलिए सूचकांक की गिनती शून्य से शुरू होती है (0 )।

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

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

उदाहरण

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

{ "_id" : 1, "prod" : "Bat", "sizes" : [ "XS", "M", "L" ] }
{ "_id" : 2, "prod" : "Hat", "sizes" : [ "XS", "S", "L", "XL" ] }
{ "_id" : 3, "prod" : "Cap", "sizes" : [ "XXS", "XS", "M", "XL" ] }
{ "_id" : 4, "prod" : "Zap", "sizes" : [ 10, 12, 15 ] }
{ "_id" : 5, "prod" : "Tap", "sizes" : [ 15, 16, 20 ] }

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

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS" ] }
          }
     }
   ]
)

परिणाम:

{ "sizes" : [ "XS", "M", "L" ], "result" : 0 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : 0 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : 1 }
{ "sizes" : [ 10, 12, 15 ], "result" : -1 }
{ "sizes" : [ 15, 16, 20 ], "result" : -1 }

पहले दो दस्तावेज़ों में, खोज मान स्थिति 0 . पर पाया गया था (सरणी शून्य-आधारित हैं)।

तीसरे दस्तावेज़ में, यह स्थिति 1 . पर पाया गया था . ध्यान दें कि खोज एक सटीक मिलान के लिए थी। इसने स्थिति नहीं लौटाई 0 , भले ही स्थिति पर मान 0 इसमें खोज मान होता है (अर्थात XXS इसमें XS शामिल है )।

पिछले दो दस्तावेज़ों में खोज मान नहीं मिला, और इसलिए -1 लौटा दिया गया।

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

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", 15 ] }
          }
     }
   ]
)

परिणाम:

{ "sizes" : [ "XS", "M", "L" ], "result" : -1 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : -1 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : -1 }
{ "sizes" : [ 10, 12, 15 ], "result" : 2 }
{ "sizes" : [ 15, 16, 20 ], "result" : 0 }

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

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

उदाहरण:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", 15, 1 ] }
          }
     }
   ]
)

परिणाम:

{ "sizes" : [ 10, 12, 15 ], "result" : 2 }
{ "sizes" : [ 15, 16, 20 ], "result" : -1 }

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

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

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

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

उदाहरण:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS", 0, 1 ] }
          }
     }
   ]
)

परिणाम:

{ "sizes" : [ "XS", "M", "L" ], "result" : 0 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : 0 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : -1 }

तीसरा दस्तावेज़ लौटा -1 जिसका अर्थ है कि खोज अभिव्यक्ति नहीं मिली।

अगर हम अंतिम इंडेक्स की स्थिति को 1 से बढ़ाते हैं तो यहां क्या होता है:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS", 0, 2 ] }
          }
     }
   ]
)

परिणाम:

{ "sizes" : [ "XS", "M", "L" ], "result" : 0 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : 0 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : 1 }

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

खाली सरणी

एक खाली सरणी खोजना -1 returns देता है ।

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 6 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS" ] }
          }
     }
   ]
)

परिणाम:

{ "sizes" : [ ], "result" : -1 }

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

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

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

{ "_id" : 8, "prod" : "Map" }

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

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 8 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS" ] }
          }
     }
   ]
)

परिणाम:

{ "result" : null }

शून्य मान

अगर ऐरे एक्सप्रेशन null है (एक सरणी के बजाय), $indexOfArray रिटर्न null ।

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

{ "_id" : 7, "prod" : "Lap", "sizes" : null }

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

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 7 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XS" ] }
          }
     }
   ]
)

परिणाम:

{ "sizes" : null, "result" : null }

हालांकि, जब सर्च एक्सप्रेशन null हो , परिणाम -1 . है , जब तक कि ऐरे एक्सप्रेशन भी null न हो या इसकी फ़ील्ड अनुपलब्ध है:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5, 6, 7, 8 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", null ] }
          }
     }
   ]
)

परिणाम:

{ "sizes" : [ "XS", "M", "L" ], "result" : -1 }
{ "sizes" : [ "XS", "S", "L", "XL" ], "result" : -1 }
{ "sizes" : [ "XXS", "XS", "M", "XL" ], "result" : -1 }
{ "sizes" : [ 10, 12, 15 ], "result" : -1 }
{ "sizes" : [ 15, 16, 20 ], "result" : -1 }
{ "sizes" : [ ], "result" : -1 }
{ "sizes" : null, "result" : null }
{ "result" : null }

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

यदि सरणी अभिव्यक्ति गलत डेटा प्रकार है, $indexOfArray एक त्रुटि देता है।

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

{ "_id" : 9, "prod" : "Box", "sizes" : "XXL" }

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

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 9 ] } } },
     {
       $project:
          {
            _id: 0,
            sizes: 1,
            result: { $indexOfArray: [ "$sizes", "XXL" ] }
          }
     }
   ]
)

परिणाम:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$indexOfArray requires an array as a first argument, found: string",
	"code" : 40090,
	"codeName" : "Location40090"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1

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