MongoDB में db.collection.findOneAndReplace() विधि निर्दिष्ट फ़िल्टर के आधार पर एकल दस्तावेज़ को प्रतिस्थापित करती है।
collection भाग उस संग्रह का नाम है जिसके साथ ऑपरेशन करना है।
उदाहरण
मान लीजिए हमारे पास pets . नामक संग्रह है जिसमें निम्नलिखित दस्तावेज शामिल हैं:
{ "_id" : 1, "name" : "Wag", "type" : "Dog" }
{ "_id" : 2, "name" : "Bark", "type" : "Dog" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }
हम db.collection.findOneAndReplace() . का उपयोग कर सकते हैं उन दस्तावेज़ों में से किसी एक को बदलने की विधि।
db.pets.findOneAndReplace(
{ "type": "Dog" },
{ "name": "Bruno", "type" : "Horse" }
)परिणाम:
{ "_id" : 1, "name" : "Wag", "type" : "Dog" } डिफ़ॉल्ट रूप से, यह मूल दस्तावेज़ लौटाता है (संशोधित संस्करण नहीं)।
ध्यान दें कि संग्रह में दो कुत्ते होने के बावजूद केवल एक कुत्ते को अपडेट किया गया था।
आइए संग्रह की जाँच करें।
db.pets.find()परिणाम:
{ "_id" : 1, "name" : "Bruno", "type" : "Horse" }
{ "_id" : 2, "name" : "Bark", "type" : "Dog" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" } हम देख सकते हैं कि पहले दस्तावेज़ को नए दस्तावेज़ से बदल दिया गया है।
ध्यान दें कि प्रतिस्थापन दस्तावेज़ _id . निर्दिष्ट नहीं कर सकता है मान जो _id . से भिन्न हो बदले गए दस्तावेज़ में मूल्य।
संशोधित दस्तावेज़ लौटाएं
डिफ़ॉल्ट रूप से, जब आप db.collection.findOneAndReplace() का उपयोग करते हैं, तो मूल दस्तावेज़ वापस कर दिया जाता है .
यदि आप इसके बजाय संशोधित दस्तावेज़ वापस करना चाहते हैं, तो returnNewDocument . का उपयोग करें पैरामीटर।
आइए एक और संशोधन करें, लेकिन इस बार हम returnNewDocument: true use का उपयोग करेंगे ।
db.pets.findOneAndReplace(
{ "type": "Dog" },
{ "handle": "Harry", "DOB" : "2020-05-12", "points": 10 },
{ returnNewDocument: true }
)परिणाम:
{ "_id" : 2, "handle" : "Harry", "DOB" : "2020-05-12", "points" : 10 } इस बार दूसरे कुत्ते को अपडेट किया गया। इस मामले में, हमने एक और महत्वपूर्ण बदलाव किया है, और हम देख सकते हैं कि रिटर्न दस्तावेज़ इसे दर्शाता है।
बदले गए दस्तावेज़ को देखने के लिए हम संग्रह को फिर से देख सकते हैं।
db.pets.find()परिणाम:
{ "_id" : 1, "name" : "Bruno", "type" : "Horse" }
{ "_id" : 2, "handle" : "Harry", "DOB" : "2020-05-12", "points" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" } अप्सर्ट
एक अप्सर्ट एक विकल्प है जिसका उपयोग आप अपडेट ऑपरेशंस पर कर सकते हैं। यदि निर्दिष्ट दस्तावेज़ मौजूद नहीं है, तो एक नया डाला जाता है। अगर यह करता है मौजूद है, तब मूल दस्तावेज़ अपडेट किया जाता है (और कोई दस्तावेज़ सम्मिलित नहीं किया जाता है)।
आप upsert: true . निर्दिष्ट करके अप्सर्ट प्रदर्शन कर सकते हैं ।
upsert: false का उपयोग करने का उदाहरण
सबसे पहले, यहां एक गैर-मौजूद दस्तावेज़ को अपडेट करने का प्रयास करने का एक उदाहरण दिया गया है जब upsert: false ।
db.pets.findOneAndReplace(
{ "_id": 4 },
{ "name": "Fluffy", "type": "Pooch", "DOB" : "2019-12-03", "points": 20 },
{
returnNewDocument: true
}
)परिणाम:
null
दस्तावेज़ संग्रह में मौजूद नहीं था और इसलिए findOneAndReplace() लौटा null . भले ही हमने स्पष्ट रूप से upsert: false . निर्दिष्ट नहीं किया हो , हम जानते हैं कि यह गलत था क्योंकि यह डिफ़ॉल्ट मान है (अर्थात यह वह मान है जिसका उपयोग तब किया जाता है जब आप अप्सर्ट विकल्प निर्दिष्ट नहीं करते हैं)।
यदि हम संग्रह में एक और नज़र डालें, तो हम देख सकते हैं कि दस्तावेज़ को ऊपर नहीं रखा गया था।
db.pets.find()परिणाम:
{ "_id" : 1, "name" : "Bruno", "type" : "Horse" }
{ "_id" : 2, "handle" : "Harry", "DOB" : "2020-05-12", "points" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" } upsert: true
अब यह फिर से है, लेकिन इस बार हम निर्दिष्ट करते हैं upsert: true ।
db.pets.findOneAndReplace(
{ "_id": 4 },
{ "name": "Fluffy", "type": "Pooch", "DOB" : "2019-12-03", "points": 20 },
{
upsert: true,
returnNewDocument: true
}
)परिणाम:
{
"_id" : 4,
"name" : "Fluffy",
"type" : "Pooch",
"DOB" : "2019-12-03",
"points" : 20
}
इस बार एक नया दस्तावेज़ जोड़ा गया है और हम ऊपर वाले दस्तावेज़ को आउटपुट के रूप में देखते हैं (क्योंकि हमने returnNewDocument: true निर्दिष्ट किया है। )।
आइए फिर से संग्रह की जाँच करें।
db.pets.find()परिणाम:
{ "_id" : 1, "name" : "Bruno", "type" : "Horse" }
{ "_id" : 2, "handle" : "Harry", "DOB" : "2020-05-12", "points" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }
{ "_id" : 4, "name" : "Fluffy", "type" : "Pooch", "DOB" : "2019-12-03", "points" : 20 } तो हम देख सकते हैं कि नया दस्तावेज़ वास्तव में ऊपर रखा गया था।
sort पैरामीटर
आप sort . का उपयोग कर सकते हैं filter . द्वारा मिलान किए गए दस्तावेज़ों के लिए सॉर्टिंग क्रम निर्दिष्ट करने के लिए पैरामीटर ।
sort का उपयोग करते समय पैरामीटर, 1 . का मान दस्तावेज़ों को आरोही क्रम में क्रमबद्ध करता है, और -1 . का मान होता है उन्हें अवरोही क्रम में क्रमबद्ध करता है।
तर्क को एक दस्तावेज़ के रूप में प्रदान करने की आवश्यकता है। उदाहरण के लिए, { sort: { "salary": 1 } } salary . के आधार पर छाँटें फ़ील्ड आरोही क्रम में।
उदाहरण के लिए, मान लें कि हम employees . नामक एक संग्रह बनाते हैं निम्नलिखित दस्तावेजों के साथ:
db.employees.insertMany([
{ _id: 1, name: "Sandy", salary: 55000 },
{ _id: 2, name: "Sarah", salary: 128000 },
{ _id: 3, name: "Fritz", salary: 25000 },
{ _id: 4, name: "Chris", salary: 45000 },
{ _id: 5, name: "Beck", salary: 82000 }
])हम 60000 से कम वेतन वाले दस्तावेज़ों को खोजने के लिए निम्नलिखित कोड चला सकते हैं, फिर उनमें से सबसे कम वेतन वाले दस्तावेज़ को बदल सकते हैं।
db.employees.findOneAndReplace(
{ "salary": { $lt: 60000 } },
{ "name": "Fluffy", "salary": 250000 },
{
sort: { "salary": 1 }
}
)परिणाम:
{ "_id" : 3, "name" : "Fritz", "salary" : 25000 } यह अद्यतन किए जाने से पहले दस्तावेज़ को दिखाता है। जैसा कि अपेक्षित था, सबसे कम वेतन वाले कर्मचारी को एक नए वेतन (और एक नया नाम) के साथ बदल दिया गया था।
दस्तावेज़ अब इस तरह दिखते हैं।
db.employees.find()परिणाम:
{ "_id" : 1, "name" : "Sandy", "salary" : 55000 }
{ "_id" : 2, "name" : "Sarah", "salary" : 128000 }
{ "_id" : 3, "name" : "Fluffy", "salary" : 250000 }
{ "_id" : 4, "name" : "Chris", "salary" : 45000 }
{ "_id" : 5, "name" : "Beck", "salary" : 82000 } तो हम देख सकते हैं कि फ़्रिट्ज़ की जगह फ़्लफ़ी ने ले ली है, जिनके पास बेहतर वेतन है।
आइए इसे वापस मूल दस्तावेज़ पर वापस लाते हैं।
db.employees.remove({})
db.employees.insertMany([
{ _id: 1, name: "Sandy", salary: 55000 },
{ _id: 2, name: "Sarah", salary: 128000 },
{ _id: 3, name: "Fritz", salary: 25000 },
{ _id: 4, name: "Chris", salary: 45000 },
{ _id: 5, name: "Beck", salary: 82000 }
])
अब वही findOneAndReplace() चलाते हैं कोड फिर से, लेकिन इस बार हम इसे अवरोही क्रम में क्रमबद्ध करेंगे।
db.employees.findOneAndReplace(
{ "salary": { $lt: 60000 } },
{ "name": "Fluffy", "salary": 250000 },
{
sort: { "salary": -1 }
}
)परिणाम:
{ "_id" : 1, "name" : "Sandy", "salary" : 55000 } इस बार सैंडी को बदल दिया गया।
आइए फिर से संग्रह की जाँच करें।
db.employees.find()परिणाम:
{ "_id" : 1, "name" : "Fluffy", "salary" : 250000 }
{ "_id" : 2, "name" : "Sarah", "salary" : 128000 }
{ "_id" : 3, "name" : "Fritz", "salary" : 25000 }
{ "_id" : 4, "name" : "Chris", "salary" : 45000 }
{ "_id" : 5, "name" : "Beck", "salary" : 82000 } जैसी उम्मीद थी।
अधिक जानकारी
db.collection.findOneAndReplace() विधि अन्य मापदंडों को भी स्वीकार करती है, जैसे कि projection (वापस जाने के लिए फ़ील्ड का एक सबसेट निर्दिष्ट करने के लिए), maxTimeMS , और collation ।
db.collections.findOneAndReplace() . के लिए MongoDB दस्तावेज़ देखें अधिक जानकारी के लिए।
