MongoDB: प्रश्न

हालाँकि कुछ ने मेरे पिछले विषय के बारे में लिखा था, MongoDB: दस्तावेज़ बनाना, अपडेट करना और हटाना , यह ऑफ़सेट की एक रीटेलिंग है। प्रलेखन, मैं इससे पूरी तरह सहमत नहीं हूं। मुझे यह प्रतीत हुआ कि इसमें दी गई जानकारी किसी के लिए उपयोगी थी, इसलिए मैं निरंतरता को पोस्ट करता हूं।

खोजें MySQL में SELECT का एक एनालॉग है। MongoDB से दस्तावेज़ लाने के लिए उपयोग किया जाता है। एक संग्रह के रूप में दस्तावेजों की एक सरणी लौटाता है, अगर कोई दस्तावेज़ नहीं हैं, तो एक खाली संग्रह। एक उदाहरण:

> db.users.find();

संग्रह से सभी उपयोगकर्ताओं को वापस कर देगा।

> db.users.find( { age: 27 } );

उन सभी उपयोगकर्ताओं को लौटाएगा जिनकी उम्र 27 है।

उदाहरण के लिए, आप कई पैरामीटर निर्दिष्ट कर सकते हैं:

> db.users.find( { username: “joe”, age: 27 } );

कभी-कभी दस्तावेजों से कुछ विशिष्ट फ़ील्ड प्राप्त करना आवश्यक होता है। इस मामले में, अनुरोध इस तरह दिखता है:

> db.users.find( { }, { username: 1, email: 1 } );

नतीजतन, हम सभी उपयोगकर्ताओं को केवल "उपयोगकर्ता नाम" और "ईमेल" फ़ील्ड + "_id" फ़ील्ड के साथ प्राप्त करेंगे, जो हमेशा डिफ़ॉल्ट रूप से वापस आ जाता है। यदि "_id" फ़ील्ड या किसी अन्य फ़ील्ड की आवश्यकता नहीं है, तो हम इसे इस तरह निर्दिष्ट कर सकते हैं:

> db.users.find( { }, { username: 1, email: 1, _id: 0 } );

एक शर्त के साथ अनुरोध

ऑपरेटर: $ lt - कम, $ lte - इससे कम या बराबर, $ gt - अधिक, $ gte - अधिक या बराबर, $ ne - नहीं के बराबर।
उपयोग के उदाहरण:
हमें सभी उपयोगकर्ता मिलते हैं जिनकी आयु 18 से अधिक और 30 से कम है

> db.users.find( { age: { $gte: 18, $lte: 30 } } );

हमें सभी उपयोगकर्ता मिलते हैं जिनका "उपयोगकर्ता नाम" "joe" के बराबर नहीं है

> db.users.find( { username: { $ne: “joe” } } );

मान लीजिए कि हमारे संग्रह संख्याओं के साथ लॉटरी टिकटों को संग्रहीत करते हैं और हमें केवल उन लोगों को खोजने की आवश्यकता है जिनके पास जीतने वाले नंबर 390, 754, 454 हैं। इस मामले में, हम ऑपरेटर में $ का उपयोग करते हैं:

> db.users.find( { numbers: { $in: [ 390, 754, 454 ] } } );

यानी टिकट में इनमें से एक नंबर होना चाहिए।
ऑपरेटर में $ के विपरीत $ नौ है। सादृश्य से, वह केवल उन टिकटों को प्राप्त करता है जहां ऊपर बताए गए नंबर नहीं हैं।
$ या ऑपरेटर का उपयोग प्रश्नों के लिए किया जाता है जब आपको उन दस्तावेज़ों का चयन करने की आवश्यकता होती है जो मूल्यों में से एक से मेल खाते हैं। उदाहरण के लिए, हमें 547 नंबर या जहां "विजेता" क्षेत्र सत्य है, के साथ सभी टिकटों का चयन करने की आवश्यकता है:

> db.users.find( { $or: [ { tickect_number: 547 }, { winner: true } ] } );

$ Mod ऑपरेटर का उपयोग उन कुंजियों को चुनने के लिए किया जाता है जिनके मान पहले तर्क से विभाजित होते हैं और शेष भाग दूसरे तर्क के बराबर होता है। यह समझ से बाहर है, लेकिन अधिक स्पष्ट रूप से:

> db.users.find( { user_id: { $mod: [ 5, 1 ] } } );

ऐसी क्वेरी उन सभी उपयोगकर्ताओं को लौटाएगी जिनके उपयोगकर्ता_ 1, 6, 11, 16 और इसी तरह के हैं।
उपरोक्त को छोड़कर सभी उपयोगकर्ताओं को प्राप्त करने के लिए, आप $ नहीं ऑपरेटर का उपयोग कर सकते हैं:

> db.users.find( { user_id: { $not: { $mod: [ 5, 1 ] } } } );

हमें "user_id" 2, 3, 4, 5, 7, 8, 9, 10, 12 और इसी तरह के उपयोगकर्ता मिलेंगे।
एक कुंजी मौजूद है या नहीं - इसकी जाँच के लिए एक ऑपरेटर भी है - $ मौजूद है

> db.c.find({"z" : {"$in" : [null], "$exists" : true}});

तो आप संग्रह में सभी दस्तावेजों का चयन कर सकते हैं जहां कुंजी "z" मौजूद है और यह शून्य है।

नियमित अभिव्यक्ति

हम सभी जानते हैं कि नियमित अभिव्यक्ति एक बहुत शक्तिशाली चीज है। MongoDB पर्ल-संगत नियमित अभिव्यक्ति का उपयोग करता है।
इस तरह से आप सभी उपयोगकर्ताओं को नाम या जो के साथ पा सकते हैं:

> db.users.find( { "name" : /^joe$/i } );

सामान्य तौर पर, जहां घूमना है। उसी जावास्क्रिप्ट के लिए सेवाओं का एक समूह है, जहां आप अपने नियमित रूप से लिख सकते हैं और जांच सकते हैं।

ऐरे में प्रश्न

मान लें कि हमारे पास एक खाद्य संग्रह है और हम वहां फल की एक सरणी के साथ एक दस्तावेज़ डालते हैं

> db.food.insert( { "fruit" : [ "apple", "banana", "peach" ] } );

ऐसा निवेदन है

> db.food.find({"fruit" : "banana"});

उसे सफलतापूर्वक पा लेंगे।
यदि आपको सरणी के एक से अधिक तत्वों के लिए दस्तावेजों का चयन करने की आवश्यकता है, तो हम ऑपरेटर को $ का उपयोग कर सकते हैं

> db.food.find( { fruits: { $all : [ "apple", "banana" ] } } );

ऐसी क्वेरी फल दस्तावेज में सभी दस्तावेज वापस कर देगी जिसमें सेब और केले हैं।
हम एरे में तत्वों के पूर्ण संयोग से दस्तावेज प्राप्त कर सकते हैं:

> db.food.find( { fruits: [ "apple", "banana", "peach" ] } );

हमारे पास एक ब्लॉग है, इसमें टिप्पणियां हैं। हम पहले 10 टिप्पणियाँ प्राप्त करना चाहते हैं। $ टुकड़ा ऑपरेटर बचाव के लिए आता है:

> db.blog.posts.findOne( { }, { "comments" : { "$slice" : 10 } } );

findOne - खोजने के लिए समान काम करता है, लेकिन पहला मिलान दस्तावेज़ लौटाता है।

यदि आपको अंतिम 10 टिप्पणियाँ प्राप्त करने की आवश्यकता है, तो इस तरह लिखें:

> db.blog.posts.findOne( { }, { "comments" : { "$slice" : -10 } } );

इसके अलावा $ टुकड़ा बीच से दस्तावेज़ प्राप्त कर सकते हैं:

> db.blog.posts.findOne( { }, { comments : { "$slice" : [ 23, 10 ] } });

इस स्थिति में, 23 प्रारंभिक तत्व छोड़ दिए जाएंगे और यदि संभव हो तो 34 के माध्यम से 24 को वापस कर दिया जाएगा

सीमाएं, छोड़ें, और क्रमबद्ध करें

अनुरोध पर सीमित संख्या में दस्तावेज प्राप्त करने के लिए, सीमा कमांड का उपयोग किया जाता है:

> db.users.find().limit(3);

पहले 3 उपयोगकर्ताओं को वापस करेगा।
कई दस्तावेज़ों को छोड़ कर बाकी सभी प्राप्त करने के लिए, स्किप कमांड का उपयोग करें:

> db.users.find().skip(3);

हमें पहले तीन को छोड़कर सभी उपयोगकर्ता मिलते हैं।
सॉर्ट करने के लिए, सॉर्ट कमांड का उपयोग करें। छंटनी आरोही (1) और अवरोही (- 1) हो सकती है। प्राथमिकता के क्रम में कई कुंजी द्वारा छंटनी की जा सकती है:

> db.users.find().sort( { username : 1, age : -1 } );

इन तीनों आदेशों का उपयोग एक साथ किया जा सकता है:

> db.stock.find( { "desc" : "mp3" } ).limit(50).skip(50).sort( { "price" : -1 } );

बड़े मान के साथ स्किप कमांड का उपयोग करना बहुत तेजी से काम नहीं करता है। उदाहरण के रूप में पृष्ठांकन का उपयोग करने पर विचार करें:

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

> var page1 = db.foo.find(criteria).limit(100)
> var page2 = db.foo.find(criteria).skip(100).limit(100)
> var page3 = db.foo.find(criteria).skip(200).limit(100)

लेकिन यह धीरे-धीरे काम करेगा। मान लीजिए कि हम उस तारीख के बारे में एक चयन करेंगे, जिस दिन दस्तावेज़ बनाया गया था:

> var page1 = db.foo.find().sort( {"date" : -1} ).limit(100);

अवरोही क्रम में क्रमबद्ध करें और पहले 100 लें। क्रम न छोड़ने के लिए, हम अंतिम दस्तावेज़ की तारीख प्राप्त कर सकते हैं और इस तिथि के लिए पहले ही अनुरोध कर सकते हैं:

var page2 = db.foo.find( { "date" : { "$gt" : latest.date } } );

इस तरह आप बड़े मानों के लिए स्किप कमांड का उपयोग करने से बच सकते हैं।

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