मोंगोडीबी ढूंढें ()

MongoDB में db.collection.find() विधि संग्रह या दृश्य में दस्तावेज़ों का चयन करती है और चयनित दस्तावेज़ों पर एक कर्सर लौटाती है..

collection भाग संग्रह या देखने के लिए खोज का नाम है।

आप इसका उपयोग सभी दस्तावेज़ों, केवल कुछ, या केवल एक दस्तावेज़ को वापस करने के लिए कर सकते हैं। आप यह भी निर्दिष्ट कर सकते हैं कि किन क्षेत्रों को वापस किया जाना चाहिए।

यह ध्यान रखना महत्वपूर्ण है कि यह वास्तव में दस्तावेजों को वापस नहीं करता है। यह केवल एक कर्सर देता है दस्तावेजों को। ऐसा कहने के बाद, यह कहना आसान है कि यह "दस्तावेज़ लौटाता है", और इसे आम तौर पर इस तरह से संदर्भित किया जाता है - इस लेख में शामिल है 🙂

सभी दस्तावेज़ लौटाएं

प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है।

db.pets.find()

परिणाम:

{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 }

यहां, हम find() . का उपयोग करते हैं pets . से सभी दस्तावेज़ वापस करने की विधि संग्रह। हम जानते हैं कि यह सभी दस्तावेज़ लौटाता है क्योंकि हमने कोई फ़िल्टरिंग मानदंड प्रदान नहीं किया है। वास्तव में, हमने कोई तर्क नहीं दिया।

जब बिना किसी तर्क के कॉल किया जाता है, find() संग्रह से सभी दस्तावेज़ लौटाता है और दस्तावेज़ों के लिए सभी फ़ील्ड लौटाता है।

उपरोक्त करने का दूसरा तरीका इस प्रकार है:

db.pets.find({})

इस मामले में हम एक खाली दस्तावेज़ पास करते हैं।

इस खाली दस्तावेज़ में जोड़कर, हम परिणामों को फ़िल्टर करना शुरू कर सकते हैं।

परिणाम फ़िल्टर करें

find() . का वास्तविक सिंटैक्स इस तरह जाता है:

db.collection.find(query, projection)

इसका मतलब है कि आप एक क्वेरी को पहले तर्क के रूप में और एक प्रक्षेपण को दूसरे के रूप में पास कर सकते हैं।

यदि आप कोई क्वेरी पास करते हैं, तो इसका उपयोग परिणामों को फ़िल्टर करने के लिए किया जाता है। एक क्वेरी एक दस्तावेज़ है जिसमें क्वेरी ऑपरेटर होते हैं। जैसा कि हमने पिछले उदाहरण में देखा, एक खाली दस्तावेज़ सभी दस्तावेज़ लौटाता है।

आइए परिणामों को संग्रह में दस्तावेज़ों के सबसेट तक सीमित करें।

db.pets.find({"type":"Dog"})

परिणाम:

{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }

इसने परिणामों को केवल उन दस्तावेज़ों तक सीमित कर दिया जिनका type . है Dog . के मान वाला फ़ील्ड ।

इस मामले में, हमने केवल एक दस्तावेज़ को फ़िल्टरिंग मानदंड के रूप में पारित किया है।

आप क्वेरी ऑपरेटरों का भी उपयोग कर सकते हैं। ये आपको अपनी क्वेरी में अधिक विशिष्ट मानदंड लागू करने की अनुमति देते हैं।

उदाहरण:

db.pets.find({"weight": { $lt: 10 }})

परिणाम:

{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 }

एम्बेडेड दस्तावेज़

यदि आपके पास ऐसे दस्तावेज़ हैं जिनमें एम्बेडेड दस्तावेज़ हैं, तो आप एम्बेडेड दस्तावेज़ों में डेटा क्वेरी करने के लिए निम्न विधियों का उपयोग कर सकते हैं।

• डॉट नोटेशन (उदा. field.nestedfield: <value> )
• नेस्टेड फ़ॉर्म (उदा. { field: { nestedfield: <value> } } ) ध्यान दें कि यह विकल्प केवल MongoDB 4.4 से उपलब्ध है।

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

db.pets.insertOne({
    "_id" : 6,
    "name" : "Fetch",
    "type" : "Dog",
    "specs" : {
        "height" : 400,
        "weight" : 15,
        "color" : "brown"
    }
})

हम एम्बेडेड दस्तावेज़ में क्वेरी करने के लिए डॉट नोटेशन का उपयोग कर सकते हैं।

db.pets.find({ "specs.height": 400 })

परिणाम:

{ "_id" : 6, "name" : "Fetch", "type" : "Dog", "specs" : { "height" : 400, "weight" : 15, "color" : "brown" } }

निम्न क्वेरी वही दस्तावेज़ लौटाती है, इस समय को छोड़कर हम नेस्टेड प्रपत्र का उपयोग करके एम्बेडेड दस्तावेज़ का संदर्भ देते हैं।

db.pets.find({ 
    "specs" : {
		"height" : 400,
		"weight" : 15,
		"color" : "brown"
	}
 })

परिणाम:

{ "_id" : 6, "name" : "Fetch", "type" : "Dog", "specs" : { "height" : 400, "weight" : 15, "color" : "brown" } }

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

db.pets.find({ 
    "specs" : {
		"height" : 400
	}
 })

परिणाम प्रारूपित करें

पिछले उदाहरण का परिणाम एक पंक्ति में लौटाया गया था। आप cursor.pretty() . का उपयोग कर सकते हैं परिणामों को अधिक पठनीय प्रारूप में प्रदर्शित करने के लिए कर्सर को कॉन्फ़िगर करने की विधि।

pretty() का उपयोग करने के लिए विधि, इसे find() . में जोड़ें विधि।

उदाहरण:

db.pets.find({ "_id": 6 }).pretty()

परिणाम:

{
	"_id" : 6,
	"name" : "Fetch",
	"type" : "Dog",
	"specs" : {
		"height" : 400,
		"weight" : 15,
		"color" : "brown"
	}
}

सरणी

आप सरणी तत्व को उसके सूचकांक या उसके मान द्वारा संदर्भित करके सरणियों में डेटा का संदर्भ दे सकते हैं।

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

db.pets.insertOne({
    "_id" : 7,
    "name" : "Jake",
    "type" : "Dog",
    "awards" : [
        "Top Dog",
        "Best Dog",
        "Biggest Dog"
    ]
})

अगर हम सभी कुत्तों को शीर्ष कुत्ते पुरस्कार के साथ ढूंढना चाहते हैं, तो हम निम्नलिखित प्रश्न लिख सकते हैं (जो उपरोक्त कुत्ते को वापस कर देगा)।

db.pets.find({ 
    "awards": "Top Dog"
}).pretty()

परिणाम:

{
	"_id" : 7,
	"name" : "Jake",
	"type" : "Dog",
	"awards" : [
		"Top Dog",
		"Best Dog",
		"Biggest Dog"
	]
}

आप एलिमेंट इंडेक्स को इस तरह भी निर्दिष्ट कर सकते हैं:

db.pets.find({ 
    "awards.0": "Top Dog"
}).pretty()

ऐसा करने के लिए आवश्यक है कि निर्दिष्ट मान निर्दिष्ट अनुक्रमणिका पर हो। इसलिए, निम्न क्वेरी उसी कुत्ते को वापस नहीं करती है।

db.pets.find({ 
    "awards.1": "Top Dog"
}).pretty()

ध्यान दें कि सरणियाँ शून्य-आधारित हैं, इसलिए 0 का सूचकांक पहले तत्व को निर्दिष्ट करता है, 1 दूसरे तत्व को निर्दिष्ट करता है, और इसी तरह।

अनुमान

डिफ़ॉल्ट रूप से, जब आप find() . का उपयोग करते हैं, तो सभी दस्तावेज़ फ़ील्ड वापस आ जाते हैं . लेकिन यदि आवश्यक हो तो लौटाए गए फ़ील्ड की संख्या को कम करने के लिए आप अनुमानों का उपयोग कर सकते हैं।

आपको याद होगा कि find() . के लिए सिंटैक्स इस तरह जाता है:

db.collection.find(query, projection)

जहां query फ़िल्टरिंग मानदंड प्रदान करता है (जो हमने उपरोक्त उदाहरणों में किया है), और projection एक वैकल्पिक प्रक्षेपण है जो निर्दिष्ट करता है कि किस फ़ील्ड को किसी भी मिलान दस्तावेज़ से वापस करना है। इसलिए, यदि हम प्रक्षेपण का उपयोग करना चाहते हैं, तो हम इसे केवल क्वेरी के बाद रखते हैं।

जब आप प्रक्षेपण का उपयोग करते हैं, तो आप शामिल . के लिए फ़ील्ड निर्दिष्ट कर सकते हैं , फ़ील्ड को बहिष्कृत करना , अथवा दोनों। ऐसा करने के लिए, फ़ील्ड का नाम और या तो 1 . सूचीबद्ध करें (इसे शामिल करने के लिए) या 0 (इसे बाहर करने के लिए)।

अब तक, हमारे संग्रह में निम्नलिखित दस्तावेज़ शामिल हैं:

{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 }
{ "_id" : 6, "name" : "Fetch", "type" : "Dog", "specs" : { "height" : 400, "weight" : 15, "color" : "brown" } }
{ "_id" : 7, "name" : "Jake", "type" : "Dog", "awards" : [ "Top Dog", "Best Dog", "Biggest Dog" ] }

शामिल करने के लिए फ़ील्ड निर्दिष्ट करने के लिए प्रक्षेपण का उपयोग करने का एक उदाहरण यहां दिया गया है:

db.pets.find({}, { name: 1, type: 1 })

परिणाम:

{ "_id" : 1, "name" : "Wag", "type" : "Dog" }
{ "_id" : 2, "name" : "Bark", "type" : "Dog" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat" }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat" }
{ "_id" : 6, "name" : "Fetch", "type" : "Dog" }
{ "_id" : 7, "name" : "Jake", "type" : "Dog" }

ध्यान दें कि _id भले ही हमने इसे अपने प्रोजेक्शन में शामिल नहीं किया हो, फिर भी फ़ील्ड लौटा दी जाती है। यह फ़ील्ड एक अपवाद है, और डिफ़ॉल्ट रूप से शामिल है।

अगर आप _id नहीं चाहते हैं फ़ील्ड लौटाने के लिए, आपको उसे स्पष्ट रूप से बाहर करना होगा।

db.pets.find({}, { _id: 0, name: 1, type: 1 })

परिणाम:

{ "name" : "Wag", "type" : "Dog" }
{ "name" : "Bark", "type" : "Dog" }
{ "name" : "Meow", "type" : "Cat" }
{ "name" : "Scratch", "type" : "Cat" }
{ "name" : "Bruce", "type" : "Bat" }
{ "name" : "Fetch", "type" : "Dog" }
{ "name" : "Jake", "type" : "Dog" }

यहां एक और उदाहरण दिया गया है, इस बार हम केवल निर्दिष्ट करते हैं कि किन क्षेत्रों को बाहर करना है।

db.pets.find({}, { _id: 0, weight: 0, specs: 0, awards: 0 })

परिणाम:

{ "name" : "Wag", "type" : "Dog" }
{ "name" : "Bark", "type" : "Dog" }
{ "name" : "Meow", "type" : "Cat" }
{ "name" : "Scratch", "type" : "Cat" }
{ "name" : "Bruce", "type" : "Bat" }
{ "name" : "Fetch", "type" : "Dog" }
{ "name" : "Jake", "type" : "Dog" }

और अनुमान

कई अन्य चीजें हैं जो आप अनुमानों के साथ कर सकते हैं। उदाहरण के लिए, मोंगडीबी 4.4 से शुरू करके आप अनुमानित फ़ील्ड के मान को निर्दिष्ट करने के लिए समग्र अभिव्यक्तियों का उपयोग कर सकते हैं।

उदाहरण:

db.pets.find({}, { 
    "_id": 0,
    "n": "$name", 
    "t": "$type", 
    "w": "$weight" 
    })

परिणाम:

{ "n" : "Wag", "t" : "Dog", "w" : 20 }
{ "n" : "Bark", "t" : "Dog", "w" : 10 }
{ "n" : "Meow", "t" : "Cat", "w" : 7 }
{ "n" : "Scratch", "t" : "Cat", "w" : 8 }
{ "n" : "Bruce", "t" : "Bat", "w" : 3 }
{ "n" : "Fetch", "t" : "Dog" }
{ "n" : "Jake", "t" : "Dog" }

यहां, हमने फ़ील्ड नामों का नाम बदल दिया। हमने $fieldName का उपयोग करते हुए स्ट्रिंग अक्षर के रूप में प्रत्येक फ़ील्ड के लिए एक नया नाम निर्दिष्ट करके ऐसा किया है। उस फ़ील्ड मान को आउटपुट करने के लिए सिंटैक्स। परिणाम कुछ ऐसा है जैसे SQL में उपनाम का उपयोग करना।

अधिक जानकारी

अधिक जानकारी के लिए MongoDB दस्तावेज़ देखें।