😃 👨🏽‍🏭 🙃 MongoDB: $ या VS $ - किस तेजी से काम करता है? 👨🏻‍🎤 😗 🧒🏿

प्रश्नों में तार्किक कार्यों में $ या $ का उपयोग करने के मामलों में MongoDB प्रदर्शन की तुलना बहुत कम होगी। मुझे उम्मीद है कि यह लेख किसी के काम करने के समय को बचाता है।

टेस्ट MongoDB 2.4.9 पर चलते हैं

मान लीजिए कि MongoDB में दस्तावेजों का एक संग्रह है। सार की समझ को सरल बनाने के लिए - इसे केवल दो क्षेत्रों के साथ दस्तावेज़ होने दें।

$m = new MongoClient('mongodb://mongodb01,mongodb02,mongodba/?replicaSet=pkrs'); $mdb = $m->selectDB('test'); $collection = $mdb->selectCollection('test'); $collection->drop(); $collection->ensureIndex(array('i' => 1, 'j' => 1)); for ($i = 0; $i < 100; ++$i) { for ($j = 0; $j < 100; ++$j) { $collection->insert(array('i' => $i, 'j' => $j)); } }

संग्रह में केवल 10K दस्तावेज होंगे। हां, यहां बैचइनर का उपयोग करना संभव था, लेकिन मैं नोट के मुख्य सार की समझ को जटिल नहीं करना चाहता।

आपको नियमित रूप से (प्रति सेकंड कई बार) 1000 दस्तावेजों का चयन करने की आवश्यकता है। नमूने की स्थिति अनबाउंड जोड़े i और j का एक सेट है।

क्योंकि चूँकि मैंने एक महीने से भी कम समय पहले MongoDB के साथ काम करना शुरू किया था, पहली बात जो मन में आई वह इस तरह का अनुरोध था:

 $orArray = array(); for ($i = 0; $i < 10; ++$i) { for ($j = 0; $j < 100; ++$j) { $orArray[] = array('i' => $i, 'j' => $j); } } $query = array('$or' => $orArray);

तथ्य यह है कि यहां डेटा क्रम में जाता है, केवल एक उदाहरण है, ताकि व्यवसाय तर्क के साथ सिर को टकराना न हो। वास्तव में, जैसा कि मैंने ऊपर उल्लेख किया है, जोड़े i और j एक दूसरे से जुड़े नहीं हैं और अव्यवस्थित तरीके से चलते हैं।

इस अनुरोध को पूरा करने की कोशिश करने के बाद, मेरी आँखें अप्रिय आश्चर्य से चौड़ी हो गईं - यह अनुरोध 2 सेकंड से अधिक समय के लिए पूरा हो गया! कोड में ऊपर आप देख सकते हैं कि इंडेक्स बनाया गया है।

यह आम तौर पर अस्वीकार्य था।

मैंने यह सुनिश्चित करने का निर्णय लिया कि यह ऐसा नेटवर्क नहीं है जो धीमा हो, लेकिन मामला अनुरोध में है।

परीक्षण के लिए, वह यह अनुरोध करेगा:

 $query = array('i' => array('$lt' => 10), 'j' => array('$lt' => 100));

डेटा की मात्रा में परिणाम समान है, लेकिन क्वेरी पहले ही 0.01 सेकंड में चलना शुरू कर रही है।

यह स्पष्ट हो गया कि आपको वर्कअराउंड देखने की आवश्यकता है। और वह मिल गया था। अनुरोध के तर्क से, $ के बजाय $ का उपयोग या सुझाव दिया गया था। लेकिन मुझे यह नहीं मिला कि मूल्यों के जोड़े पर तुरंत $ का उपयोग कैसे करें। अगर ऐसा कोई रास्ता है, तो मैं संकेत के लिए बहुत आभारी रहूंगा।

चूंकि मुझे नहीं पता है कि दो क्षेत्रों में $ कैसे बनाया जाए, हम निम्नानुसार एक कृत्रिम क्षेत्र का परिचय देंगे (अंडरस्कोर '_' के माध्यम से i और j के मूल्यों को अंधा करते हैं):

 $collection->ensureIndex(array('ij' => 1)); for ($i = 0; $i < 100; ++$i) { for ($j = 0; $j < 100; ++$j) { $collection->insert(array('i' => $i, 'j' => $j, 'ij' => $i.'_'.$j)); } }

और फिर हमारा अनुरोध निम्नलिखित है:

 $inArray = array(); for ($i = 0; $i < 10; ++$i) { for ($j = 0; $j < 100; ++$j) { $inArray[] = $i.'_'.$j; } } $query = array('ij' => array('$in' => $inArray));

और "ओह चमत्कार!" हम अपना डेटा केवल 0.01 सेकंड में प्राप्त करते हैं (लेकिन यह सब "2 सेकंड से अधिक" के साथ शुरू हुआ)।

थोड़ी सी गुगली करते हुए, मुझे इस घटना का निम्नलिखित स्पष्टीकरण मिला: जब $ या MongoDB निर्माण के साथ क्वेरी की जाती है, तो यह कथित तौर पर कई प्रश्न बनाता है और फिर परिणामों को "जमा देता है"। मुझे यकीन नहीं है कि यह कथन सही है, लेकिन मुझे अभी तक दूसरा नहीं मिला है।

PS निष्कर्ष: $ का दुरुपयोग न करें या

PPS नीचे दिए गए कोड में आप देख सकते हैं कि मैंने समय कैसे मापा। यदि कोई व्यक्ति जानकारी में नहीं है, तो मैं स्पष्ट करूंगा कि कॉल को निष्पादित नहीं किया जाता है, जब खोज () कहा जाता है केवल MongoCursor ऑब्जेक्ट बनाया गया है। और केवल पहले दस्तावेज़ का अनुरोध करने पर ही अनुरोध किया जाता है। इसलिए, दस्तावेज़ प्राप्त करने के चक्र के पहले पुनरावृत्ति में समय कटऑफ लिया जाता है।

PPPS अगर किसी को घर पर ड्राइविंग टेस्ट में दिलचस्पी होगी, तो यहां जानिए पूरा स्रोत:

 <?php $m = new MongoClient('mongodb://mongodb01,mongodb02,mongodba/?replicaSet=pkrs'); $mdb = $m->selectDB('test'); $collection = $mdb->selectCollection('test'); $collection->drop(); $collection->ensureIndex(array('i' => 1, 'j' => 1)); for ($i = 0; $i < 100; ++$i) { for ($j = 0; $j < 100; ++$j) { $collection->insert(array('i' => $i, 'j' => $j)); } } $orArray = array(); for ($i = 0; $i < 10; ++$i) { for ($j = 0; $j < 100; ++$j) { $orArray[] = array('i' => $i, 'j' => $j); } } $query = array('$or' => $orArray); testQuery('OR Query', $collection, $query); $query = array('i' => array('$lt' => 10), 'j' => array('$lt' => 100)); testQuery('Range Query', $collection, $query); $collection->drop(); $collection->ensureIndex(array('ij' => 1)); for ($i = 0; $i < 100; ++$i) { for ($j = 0; $j < 100; ++$j) { $collection->insert(array('i' => $i, 'j' => $j, 'ij' => $i.'_'.$j)); } } $inArray = array(); for ($i = 0; $i < 10; ++$i) { for ($j = 0; $j < 100; ++$j) { $inArray[] = $i.'_'.$j; } } $query = array('ij' => array('$in' => $inArray)); testQuery('IN Query', $collection, $query); function testQuery ($testName, $collection, $query) { $cursor = $collection->find($query); $cursor->batchSize(1000); $start = microtime(true); $first = true; foreach ($cursor as $doc) { if ($first) { $time1 = microtime(true); $first = false; } } $time2 = microtime(true); $resultFirst = $time1 - $start; $resultOther = $time2 - $time1; echo "{$testName} - First: {$resultFirst} Other: {$resultOther}<br />\n"; }

यूपीडी 1 डिम_एस को मिश्रित के बजाय सलाह दी गई (और ऊपर दिए गए परीक्षण से यह स्पष्ट है कि इसे दो अलग बनाने के लिए समग्र) सूचकांक का उपयोग किया गया था। ऐसा करने के बाद, क्वेरी प्रसंस्करण की गति लगभग 10 गुना (0.2 सेकंड तक) तेज हो गई, लेकिन फिर भी $ में विकल्प के साथ हार जाता है

फैलाओ जो समझाता है:

समझाओ ($ या समग्र सूचकांक पर)

 /* 0 */ { "clauses" : [ { "cursor" : "BtreeCursor i_1_j_1", "isMultiKey" : false, "n" : 1, "nscannedObjects" : 1, "nscanned" : 1, "nscannedObjectsAllPlans" : 1, "nscannedAllPlans" : 1, "scanAndOrder" : false, "indexOnly" : false, "nYields" : 0, "nChunkSkips" : 0, "millis" : 0, "indexBounds" : { "i" : [ [ 1, 1 ] ], "j" : [ [ 1, 1 ] ] } }, { "cursor" : "BtreeCursor i_1_j_1", "isMultiKey" : false, "n" : 1, "nscannedObjects" : 1, "nscanned" : 1, "nscannedObjectsAllPlans" : 1, "nscannedAllPlans" : 1, "scanAndOrder" : false, "indexOnly" : false, "nYields" : 0, "nChunkSkips" : 0, "millis" : 0, "indexBounds" : { "i" : [ [ 2, 2 ] ], "j" : [ [ 2, 2 ] ] } } ], "n" : 2, "nscannedObjects" : 2, "nscanned" : 2, "nscannedObjectsAllPlans" : 2, "nscannedAllPlans" : 2, "millis" : 0, "server" : "mongodb01:27017" }

स्पष्ट करें ($ और i और j के लिए दो अलग-अलग सूचकांकों के साथ)

 /* 0 */ { "clauses" : [ { "cursor" : "BtreeCursor i_1", "isMultiKey" : false, "n" : 1, "nscannedObjects" : 100, "nscanned" : 100, "nscannedObjectsAllPlans" : 300, "nscannedAllPlans" : 300, "scanAndOrder" : false, "indexOnly" : false, "nYields" : 0, "nChunkSkips" : 0, "millis" : 1, "indexBounds" : { "i" : [ [ 1, 1 ] ] } }, { "cursor" : "BtreeCursor i_1", "isMultiKey" : false, "n" : 1, "nscannedObjects" : 100, "nscanned" : 100, "nscannedObjectsAllPlans" : 300, "nscannedAllPlans" : 300, "scanAndOrder" : false, "indexOnly" : false, "nYields" : 0, "nChunkSkips" : 0, "millis" : 1, "indexBounds" : { "i" : [ [ 2, 2 ] ] } } ], "n" : 2, "nscannedObjects" : 200, "nscanned" : 200, "nscannedObjectsAllPlans" : 600, "nscannedAllPlans" : 600, "millis" : 2, "server" : "mongodb01:27017" }

समझाओ (कृत्रिम रूप से दर्ज किए गए सूचकांक के साथ $)

 /* 0 */ { "cursor" : "BtreeCursor ij_1 multi", "isMultiKey" : false, "n" : 2, "nscannedObjects" : 2, "nscanned" : 3, "nscannedObjectsAllPlans" : 2, "nscannedAllPlans" : 3, "scanAndOrder" : false, "indexOnly" : false, "nYields" : 0, "nChunkSkips" : 0, "millis" : 0, "indexBounds" : { "ij" : [ [ "1_1", "1_1" ], [ "2_2", "2_2" ] ] }, "server" : "mongodb01:27017" }

UPD 2 मैंने MongoDB 2.6 के नवीनतम संस्करण पर एक परीक्षण चलाया

दरअसल, मूल संस्करण (दो क्षेत्रों के लिए समग्र सूचकांक) वहाँ बहुत तेजी से काम करता है! अर्थात्, 0.07 सेकंड में। लेकिन एक ही समय में, i_j फॉर्म के एक सूचकांक के साथ विकल्प अभी भी 0.006 - 0.01 सेकंड (यानी, लगभग 10 गुना तेज) में है।

MongoDB: $ या VS $ - किस तेजी से काम करता है?

More articles: