MongoDB में दस्तावेज़ अपडेट करें

1. अवलोकन

MongoDB एक क्रॉस-प्लेटफ़ॉर्म, दस्तावेज़-उन्मुख, ओपन-सोर्स NoSQL डेटाबेस है, जिसे C++ में लिखा गया है। इसके अतिरिक्त, MongoDB उच्च प्रदर्शन, उच्च उपलब्धता और स्वचालित स्केलिंग प्रदान करता है।

MongoDB में दस्तावेज़ों को अपडेट करने के लिए, हम विभिन्न तरीकों का उपयोग कर सकते हैं जैसे updateOne , findOneAndUpdate, आदि। इसके अलावा, MongoDB अद्यतन विधियों के लिए विभिन्न ऑपरेटरों को प्रदान करता है।

इस ट्यूटोरियल में, हम MongoDB में अपडेट ऑपरेशन करने के लिए विभिन्न तरीकों पर चर्चा करेंगे। प्रत्येक दृष्टिकोण के लिए, हम पहले मोंगो शेल क्वेरी और फिर जावा में इसके कार्यान्वयन पर चर्चा करेंगे।

2. डेटाबेस सेटअप

इससे पहले कि हम अद्यतन प्रश्नों पर आगे बढ़ें, आइए पहले एक डेटाबेस बनाएं, baeldung , और एक नमूना संग्रह, विद्यार्थी:

use baeldung;
db.createCollection(student);

उदाहरण के तौर पर, आइए संग्रह में कुछ दस्तावेज़ जोड़ें विद्यार्थी insertMany . का उपयोग करके क्वेरी:

db.student.insertMany([
    {
        "student_id": 8764,
        "student_name": "Paul Starc",
        "address": "Hostel 1",
        "age": 16,
        "roll_no":199406
    },
    {
        "student_id": 8765,
        "student_name": "Andrew Boult",
        "address": "Hostel 2",
        "age": 18,
        "roll_no":199408
    }
]);

सफल इंसर्शन पर, हमें स्वीकृत:सत्य . के साथ एक JSON प्राप्त होगा :

{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("621b078485e943405d04b557"),
	ObjectId("621b078485e943405d04b558")
    ]
}

आइए अब MongoDB में दस्तावेज़ों को अपडेट करने के विभिन्न तरीकों के बारे में गहराई से जानें।

3. updateOne . का उपयोग करना विधि

MongoDB में एक अपडेट ऑपरेशन एक नया फ़ील्ड जोड़कर, एक फ़ील्ड को हटाकर या किसी मौजूदा फ़ील्ड को अपडेट करके किया जा सकता है। अपडेटवन  विधि लागू क्वेरी फ़िल्टर के आधार पर संग्रह में एकल दस्तावेज़ को अद्यतन करती है। यह पहले उस दस्तावेज़ को ढूंढता है जो फ़िल्टर से मेल खाता है और फिर निर्दिष्ट फ़ील्ड को अपडेट करता है।

इसके अतिरिक्त, हम विभिन्न ऑपरेटरों का उपयोग कर सकते हैं जैसे कि $set , $अनसेट , $inc , आदि, अद्यतन विधि के साथ।

प्रदर्शित करने के लिए, आइए संग्रह के एकल दस्तावेज़ को अद्यतन करने के लिए क्वेरी पर गौर करें:

db.student.updateOne(
    { 
        "student_name" : "Paul Starc"
    },
    { 
        $set: {
            "address" : "Hostel 2"
        }
    }
 );

हमें नीचे दिखाए गए जैसा आउटपुट मिलेगा:

{
    "acknowledged":true,
    "matchedCount":1,
    "modifiedCount":1
}

आइए अब ऊपर के जावा ड्राइवर कोड को देखें updateOne क्वेरी:

UpdateResult updateResult = collection.updateOne(Filters.eq("student_name", "Paul Starc"),
Updates.set("address", "Hostel 2"));

यहां, सबसे पहले हमने student_name . का उपयोग किया है दस्तावेज़ों को फ़िल्टर करने के लिए फ़ील्ड। फिर हम दस्तावेज़ के पते को student_name . के साथ अपडेट करते हैं "पॉल स्टार्क"।

4. updateMany . का उपयोग करना विधि

अद्यतनकई विधि दिए गए फ़िल्टर से मेल खाने वाले MongoDB संग्रह के सभी दस्तावेज़ों को अपडेट करती है। updateMany . का उपयोग करने के लाभों में से एक यह है कि हम पुराने दस्तावेज़ों के क्षेत्रों को खोए बिना कई दस्तावेज़ों को अपडेट कर सकते हैं।

आइए updateMany . का उपयोग करके MongoDB शेल क्वेरी देखें विधि:

db.student.updateMany(
    { 
        age: { 
            $lt: 20
         } 
    },
    { 
        $set:{ 
            "Review" : true 
        }
    }
);

उपरोक्त आदेश निम्न आउटपुट लौटाएगा:

{
    "acknowledged":true,
    "matchedCount":2,
    "modifiedCount":2
}

यहां, मिलान की गई गणना मेल खाने वाले दस्तावेज़ों की संख्या होती है, जबकि modifiedCount संशोधित दस्तावेज़ संख्या शामिल है।

आइए अब updateMany . का उपयोग करके Java ड्राइवर कोड देखें विधि:

UpdateResult updateResult = collection.updateMany(Filters.lt("age", 20), Updates.set("Review", true));

यहां, उम्र . वाले सभी दस्तावेज़ 20 से कम फ़िल्टर किए जाएंगे, और समीक्षा फ़ील्ड को सत्य . पर सेट कर दिया जाएगा ।

5. प्रतिस्थापित करें . का उपयोग करना विधि

प्रतिस्थापित करें MongoDB की विधि पूरे दस्तावेज़ को बदल देती है। replaceOne . की कमियों में से एक यह है कि सभी पुराने क्षेत्रों को नए क्षेत्रों से बदल दिया जाएगा, और पुराने क्षेत्रों को भी खो दिया जाएगा:

db.student.replaceOne(
    { 
        "student_id": 8764
    },
    {
        "student_id": 8764,
        "student_name": "Paul Starc",
        "address": "Hostel 2",
        "age": 18,
        "roll_no":199406
    }
);

इस मामले में, हमें निम्न आउटपुट मिलेगा:

{
    "acknowledged":true,
    "matchedCount":1,
    "modifiedCount":1
}

यदि कोई मिलान नहीं मिलता है, तो ऑपरेशन मिलान गणना लौटाता है 0 के रूप में:

{
    "acknowledged":true,
    "matchedCount":0,
    "modifiedCount":0
}

आइए replaceOne . का उपयोग करके संबंधित जावा ड्राइवर कोड लिखें विधि:

Document replaceDocument = new Document();
replaceDocument
  .append("student_id", 8764)
  .append("student_name", "Paul Starc")
  .append("address", "Hostel 2")
  .append("age",18)
  .append("roll_no", 199406);
UpdateResult updateResult = collection.replaceOne(Filters.eq("student_id", 8764), replaceDocument);

उपरोक्त कोड में, हमने एक दस्तावेज़ बनाया है जिसके द्वारा पुराने दस्तावेज़ को बदल दिया जाएगा। student_id . वाला दस्तावेज़ 8764 को नए बनाए गए दस्तावेज़ से बदल दिया जाएगा।

6. findOneAndReplace . का उपयोग करना विधि

findOneAndReplace विधि MongoDB द्वारा प्रदान की गई उन्नत अद्यतन विधियों में से एक है, और यह दिए गए चयन मानदंड के आधार पर पहले मिलान किए गए दस्तावेज़ को प्रतिस्थापित करती है। डिफ़ॉल्ट रूप से, यह विधि मूल दस्तावेज़ लौटाती है। हम findOneAndReplace . के विभिन्न विकल्पों का उपयोग कर सकते हैं यदि आवश्यक हो तो दस्तावेज़ों को सॉर्ट और प्रोजेक्ट करने के लिए।

संक्षेप में, findOneAndReplace लागू फ़िल्टर के आधार पर संग्रह के पहले मिलान दस्तावेज़ को प्रतिस्थापित करता है:

db.student.findOneAndReplace(
    { 
        "student_id" : { 
            $eq : 8764 
        }
    },
    { 
        "student_id" : 8764,
        "student_name" : "Paul Starc",
        "address": "Hostel 2",
        "age": 18,
        "roll_no":199406 
    },
    {
        returnNewDocument: false
    }
);

यह क्वेरी निम्नलिखित दस्तावेज़ लौटाएगी:

{
    "student_id":8764,
    "student_name":"Paul Starc",
    "address":"Hostel 1",
    "age":16,
    "roll_no":199406
}

अगर हम returnNewDocument . सेट करते हैं से सच , इसके बाद ऑपरेशन बदले हुए दस्तावेज़ को वापस कर देगा:

{
    "student_id":8764,
    "student_name":"Paul Starc",
    "address":"Hostel 2",
    "age":18,
    "roll_no":199406
}

आइए अब findOneAndReplace . का उपयोग करें student_id . को प्रोजेक्ट करने की विधि और उम्र लौटाए गए दस्तावेज़ में फ़ील्ड:

db.student.findOneAndReplace(
    { 
        "student_id" : {
        $eq : 8764 
        } 
    },
    { 
        "student_id" : 8764, 
        "student_name" : "Paul Starc",
        "address": "Hostel 2",
        "age": 18,
        "roll_no":199406 
    },
    { 
        projection: { 
            "_id" : 0,
            "student_id":1,
            "age" : 1 
        } 
    }
);

उपरोक्त क्वेरी के आउटपुट में केवल अनुमानित फ़ील्ड होंगे:

{
    "student_id":"8764",
    "age":16
}

उपरोक्त क्वेरी का जावा ड्राइवर कोड findOneAndReplace: . के विभिन्न विकल्पों के साथ

Document replaceDocument = new Document();
replaceDocument
  .append("student_id", 8764)
  .append("student_name", "Paul Starc")
  .append("address", "Hostel 2")
  .append("age", 18)
  .append("roll_no", 199406);
Document sort = new Document("roll_no", 1);
Document projection = new Document("_id", 0).append("student_id", 1).append("address", 1);
Document resultDocument = collection.findOneAndReplace(
  Filters.eq("student_id", 8764), 
  replaceDocument,
  new FindOneAndReplaceOptions().upsert(true).sort(sort).projection(projection).returnDocument(ReturnDocument.AFTER));

उपरोक्त क्वेरी में, findOneAndReplace विधि पहले दस्तावेज़ों को roll_no, . के आधार पर आरोही क्रम में क्रमबद्ध करेगी और नया बनाया गया दस्तावेज़ दस्तावेज़ को student_id . से बदल देता है "8764"।

7. findOneAndUpdate . का उपयोग करना विधि

findOneAndUpdate विधि संग्रह में पहले मिलान किए गए दस्तावेज़ को अपडेट करती है। यदि एक से अधिक दस्तावेज़ चयन मानदंड से मेल खाते हैं, तो यह केवल पहले मिलान किए गए दस्तावेज़ को अपडेट करता है। जब हम दस्तावेज़ को अपडेट करते हैं, तो _id . का मान फ़ील्ड अपरिवर्तित रहता है:

db.student.findOneAndUpdate(
    { 
        "student_id" : 8764
    },
    { 
        $inc : { 
            "roll_no" : 5
        } 
    },
    { 
        sort: { 
            "roll_no" : 1 
        }, 
        projection: { 
            "_id" : 0,
            "student_id":1,
            "address" : 1
        }
    }
);

क्वेरी के आउटपुट में केवल studentId . होगा और पता पुराने दस्तावेज़ का:

{
    "student_id":8764,
    "address":"Hostel 1"
}

उपरोक्त क्वेरी का जावा ड्राइवर कोड, findOneAndUpdate . के विभिन्न विकल्पों का उपयोग करते हुए इस प्रकार है:

Document sort = new Document("roll_no", 1);
Document projection = new Document("_id", 0).append("student_id", 1).append("address", 1);
Document resultDocument = collection.findOneAndUpdate(
  Filters.eq("student_id", 8764),
  Updates.inc("roll_no", 5), 
  new FindOneAndUpdateOptions().sort(sort).projection(projection).returnDocument(ReturnDocument.BEFORE));

इस मामले में, findOneAndUpdate विधि पहले दस्तावेज़ को roll_no . के आधार पर आरोही क्रम में क्रमबद्ध करेगी . उपरोक्त क्वेरी roll_no  . को बढ़ा देती है 5 तक और फिर student_id . लौटाता है और पता फ़ील्ड।