मोंगोडीबी फाइंडऑन ()

MongoDB में db.collection.findOne() विधि एक दस्तावेज़ देता है जो संग्रह या दृश्य पर निर्दिष्ट क्वेरी मानदंड को पूरा करता है।

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

findOne() find() . के समान है , सिवाय इसके कि findOne() केवल पहला दस्तावेज़ लौटाता है जो फ़िल्टर मानदंड से मेल खाता है, प्राकृतिक क्रम के अनुसार जो डिस्क पर दस्तावेज़ों के क्रम को दर्शाता है।

find() दूसरी ओर, विधि सभी मेल खाने वाले दस्तावेज़ लौटाती है।

साथ ही, findOne() वास्तविक दस्तावेज़ लौटाता है, जबकि find() प्रत्येक दस्तावेज़ में केवल एक कर्सर लौटाता है। इसलिए, आप findOne() . पर कर्सर विधियों को लागू नहीं कर सकते हैं जैसे आप find() . के साथ कर सकते हैं ।

उदाहरण

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

{ "_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 }

हम findOne() . का उपयोग कर सकते हैं एक दस्तावेज़ वापस करने के लिए।

db.pets.findOne()

परिणाम:

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

यहां, हमने pets . में सभी दस्तावेज़ों की खोज की संग्रह। हम जानते हैं कि इसने सभी दस्तावेज़ों की खोज की क्योंकि हमने कोई फ़िल्टरिंग मानदंड प्रदान नहीं किया था। हमने कोई तर्क भी नहीं दिया।

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

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

db.pets.findOne({})

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

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

एक प्रश्न प्रदान करें

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

db.collection.findOne(query, projection)

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

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

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

db.pets.findOne({"type":"Cat"})

परिणाम:

{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }

इसने खोज को केवल उन दस्तावेज़ों तक सीमित कर दिया जिनमें type . है Cat . के मान वाला फ़ील्ड , फिर findOne() उस परिणाम से पहला दस्तावेज़ लौटा दिया।

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

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

उदाहरण:

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

परिणाम:

{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }

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

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

• डॉट नोटेशन (उदा. 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.findOne({ "specs.height": 400 })

परिणाम:

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

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

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

परिणाम:

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

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

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

परिणाम:

null

सरणी

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

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

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

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

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

परिणाम:

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

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

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

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

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

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

अनुमान

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

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

db.collection.findOne(query, projection)

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

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

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

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

परिणाम:

{ "_id" : 1, "name" : "Wag", "type" : "Dog" }

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

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

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

परिणाम:

{ "name" : "Wag", "type" : "Dog" }

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

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

परिणाम:

{ "name" : "Wag", "type" : "Dog" }

और अनुमान

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

उदाहरण:

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

परिणाम:

{ "n" : "Wag", "t" : "Dog", "w" : 20 }

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

अधिक जानकारी

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