मोंगोडब पर डुप्लिकेट निकालें

यदि आप अन्य सभी डुप्लीकेट को आसानी से त्यागने के लिए तैयार हैं तो आप मूल रूप से .एग्रीगेट () उसी RegisterNumber . के साथ दस्तावेज़ एकत्र करने के लिए पहले मैच के अलावा अन्य सभी दस्तावेजों को महत्व दें और हटा दें।

MongoDB 3.0.x में कुछ आधुनिक सहायकों का अभाव है लेकिन मूल बातें .एग्रीगेट () प्रक्रिया के बड़े परिणाम सेट और "बल्क ऑपरेशंस" की उपस्थिति के लिए एक कर्सर लौटाता है लेखन प्रदर्शन के लिए अभी भी मौजूद है:

var bulk = db.collection.initializeOrderedBulkOp();
var count = 0;

db.collection.aggregate([
  // Group on unique value storing _id values to array and count 
  { "$group": {
    "_id": "$RegisterNumber",
    "ids": { "$push": "$_id" },
    "count": { "$sum": 1 }      
  }},
  // Only return things that matched more than once. i.e a duplicate
  { "$match": { "count": { "$gt": 1 } } }
]).forEach(function(doc) {
  var keep = doc.ids.shift();     // takes the first _id from the array

  bulk.find({ "_id": { "$in": doc.ids }}).remove(); // remove all remaining _id matches
  count++;

  if ( count % 500 == 0 ) {  // only actually write per 500 operations
      bulk.execute();
      bulk = db.collection.initializeOrderedBulkOp();  // re-init after execute
  }
});

// Clear any queued operations
if ( count % 500 != 0 )
    bulk.execute();

अधिक आधुनिक रिलीज़ (3.2 और ऊपर) में का उपयोग करना पसंद किया जाता है। बल्कराइट () बजाय। ध्यान दें कि यह एक 'क्लाइंट लाइब्रेरी' चीज़ है, क्योंकि ऊपर दिखाए गए समान "थोक" तरीकों को वास्तव में "अंडर द हुड" कहा जाता है:

var ops = [];

db.collection.aggregate([
  { "$group": {
    "_id": "$RegisterNumber",
    "ids": { "$push": "$id" },
    "count": { "$sum": 1 }      
  }},
  { "$match": { "count": { "$gt": 1 } } }
]).forEach( doc => {

  var keep = doc.ids.shift();

  ops = [
    ...ops,
    {
      "deleteMany": { "filter": { "_id": { "$in": doc.ids } } }
    }
  ];

  if (ops.length >= 500) {
    db.collection.bulkWrite(ops);
    ops = [];
  }
});

if (ops.length > 0)
  db.collection.bulkWrite(ops);

तो $group $RegisterNumber . के माध्यम से सब कुछ एक साथ खींचता है मिलान करने वाले दस्तावेज़ को महत्व देता है और एकत्र करता है _id एक सरणी के लिए मान। $sum का उपयोग करके आप गिनती रखते हैं कि ऐसा कितनी बार होता है ।

फिर ऐसे किसी भी दस्तावेज़ को फ़िल्टर करें जिसमें केवल 1 . की गिनती हो चूंकि वे स्पष्ट रूप से डुप्लीकेट नहीं हैं।

लूप में जाने से आप _id . की पहली घटना को हटा देते हैं .shift() . के साथ कुंजी के लिए एकत्रित सूची में , सरणी में केवल अन्य "डुप्लिकेट" छोड़कर।

इन्हें $in<के साथ "निकालें" ऑपरेशन में पास किया जाता है। /कोड> मिलान करने और निकालने के लिए दस्तावेज़ों की "सूची" के रूप में।