Wie aktualisiere ich ein Objekt in MongoDB teilweise, damit das neue Objekt mit dem vorhandenen Objekt überlagert / zusammengeführt wird?

Angesichts dieses in MongoDB gespeicherten Dokuments

{
   _id : ...,
   some_key: { 
        param1 : "val1",
        param2 : "val2",
        param3 : "val3"
   }
}

Ein Objekt mit neuen Informationen zur param2und param3von der Außenwelt muss gespeichert werden

var new_info = {
    param2 : "val2_new",
    param3 : "val3_new"
};

Ich möchte die neuen Felder über den vorhandenen Status des Objekts zusammenführen / überlagern, damit param1 nicht entfernt wird

Dies tun

db.collection.update(  { _id:...} , { $set: { some_key : new_info  } } 

Wird dazu führen, dass MongoDB genau das tut, was es verlangt hat, und some_key auf diesen Wert setzt. Ersetzen des alten.

{
   _id : ...,
   some_key: { 
      param2 : "val2_new",
      param3 : "val3_new"
   }
}

Wie kann MongoDB nur neue Felder aktualisieren (ohne sie explizit einzeln anzugeben)? um dies zu bekommen:

{
   _id : ...,
   some_key: { 
        param1 : "val1",
        param2 : "val2_new",
        param3 : "val3_new"
   }
}

Ich verwende den Java-Client, aber jedes Beispiel wird geschätzt

Wenn ich die Frage richtig verstehe, möchten Sie ein Dokument mit dem Inhalt eines anderen Dokuments aktualisieren, jedoch nur mit den Feldern, die noch nicht vorhanden sind, und die bereits festgelegten Felder vollständig ignorieren (auch wenn sie einen anderen Wert haben).

Es gibt keine Möglichkeit, dies in einem einzigen Befehl zu tun.

Sie müssen das Dokument zuerst abfragen, herausfinden, was Sie möchten, $setund es dann aktualisieren (indem Sie die alten Werte als passenden Filter verwenden, um sicherzustellen, dass Sie nicht gleichzeitig Aktualisierungen erhalten).

Eine andere Lesart Ihrer Frage wäre, dass Sie zufrieden sind $set, aber nicht alle Felder explizit festlegen möchten. Wie würden Sie dann die Daten weitergeben?

Sie wissen, dass Sie Folgendes tun können:

db.collection.update(  { _id:...} , { $set: someObjectWithNewData } 

Ich habe es mit meiner eigenen Funktion gelöst. Wenn Sie das angegebene Feld im Dokument aktualisieren möchten, müssen Sie es klar ansprechen.

Beispiel:

{
    _id : ...,
    some_key: { 
        param1 : "val1",
        param2 : "val2",
        param3 : "val3"
    }
}

Wenn Sie nur param2 aktualisieren möchten, ist dies falsch:

db.collection.update(  { _id:...} , { $set: { some_key : new_info  } }  //WRONG

Sie müssen verwenden:

db.collection.update(  { _id:...} , { $set: { some_key.param2 : new_info  } } 

Also habe ich so eine Funktion geschrieben:

function _update($id, $data, $options=array()){

    $temp = array();
    foreach($data as $key => $value)
    {
        $temp["some_key.".$key] = $value;
    } 

    $collection->update(
        array('_id' => $id),
        array('$set' => $temp)
    );

}

_update('1', array('param2' => 'some data'));

Sie können die Punktnotation verwenden, um auf Felder tief in Objekten zuzugreifen und diese festzulegen, ohne die anderen Eigenschaften dieser Objekte zu beeinflussen.

Angesichts des oben angegebenen Objekts:

> db.test.insert({"id": "test_object", "some_key": {"param1": "val1", "param2": "val2", "param3": "val3"}})
WriteResult({ "nInserted" : 1 })

Wir können nur aktualisieren some_key.param2und some_key.param3:

> db.test.findAndModify({
... query: {"id": "test_object"},
... update: {"$set": {"some_key.param2": "val2_new", "some_key.param3": "val3_new"}},
... new: true
... })
{
    "_id" : ObjectId("56476e04e5f19d86ece5b81d"),
    "id" : "test_object",
    "some_key" : {
        "param1" : "val1",
        "param2" : "val2_new",
        "param3" : "val3_new"
    }
}

Sie können so tief eintauchen, wie Sie möchten. Dies ist auch nützlich, um einem Objekt neue Eigenschaften hinzuzufügen, ohne die vorhandenen zu beeinflussen.

Die beste Lösung besteht darin, Eigenschaften aus dem Objekt zu extrahieren und sie zu flachen Schlüssel-Wert-Paaren mit Punktnotation zu machen. Sie könnten zum Beispiel diese Bibliothek verwenden:

https://www.npmjs.com/package/mongo-dot-notation

Es hat .flatten Funktion, mit der Sie ein Objekt in einen flachen Satz von Eigenschaften ändern können, die dann dem Modifikator $ set zugewiesen werden können, ohne befürchten zu müssen, dass eine Eigenschaft Ihres vorhandenen DB-Objekts ohne Notwendigkeit gelöscht / überschrieben wird.

Entnommen aus mongo-dot-notationDokumenten:

var person = {
  firstName: 'John',
  lastName: 'Doe',
  address: {
    city: 'NY',
    street: 'Eighth Avenu',
    number: 123
  }
};



var instructions = dot.flatten(person)
console.log(instructions);
/* 
{
  $set: {
    'firstName': 'John',
    'lastName': 'Doe',
    'address.city': 'NY',
    'address.street': 'Eighth Avenu',
    'address.number': 123
  }
}
*/

Und dann bildet es den perfekten Selektor - es aktualisiert NUR die angegebenen Eigenschaften. EDIT: Ich bin manchmal gerne Archäologe;)

Mit Mongo können Sie verschachtelte Dokumente mithilfe einer .Konvention aktualisieren . Schauen Sie sich das an: Aktualisieren verschachtelter Dokumente in Mongodb . Hier ist eine weitere Frage aus der Vergangenheit zu einem Zusammenführungsupdate, wie Sie es meiner Meinung nach suchen: MongoDB-Atomupdate über das Zusammenführungsdokument

Ich hatte Erfolg damit:

db.collection.update(  { _id:...} , { $set: { 'key.another_key' : new_info  } } );

Ich habe eine Funktion , die meine Griffe Profil dynamisch Updates

function update(prop, newVal) {
  const str = `profile.${prop}`;
  db.collection.update( { _id:...}, { $set: { [str]: newVal } } );
}

Hinweis: 'Profil' ist spezifisch für meine Implementierung. Es ist nur die Zeichenfolge des Schlüssels, den Sie ändern möchten.

Es sieht so aus, als könnten Sie isPartialObject festlegen, um das zu erreichen, was Sie wollen.

    // where clause DBObject
    DBObject query = new BasicDBObject("_id", new ObjectId(id));

    // modifications to be applied
    DBObject update = new BasicDBObject();

    // set new values
    update.put("$set", new BasicDBObject("param2","value2"));

   // update the document
    collection.update(query, update, true, false); //3rd param->upsertFlag, 4th param->updateMultiFlag

Wenn Sie mehrere Felder aktualisieren möchten

        Document doc = new Document();
        doc.put("param2","value2");
        doc.put("param3","value3");
        update.put("$set", doc);

Starten Mongo 4.2, db.collection.update()kann eine Aggregation Pipeline akzeptieren, der Betreiber Aggregation ermöglicht wie $addFields, das gibt alle vorhandenen Felder aus den Eingangsdokumenten und neu hinzugefügte Feldern:

var new_info = { param2: "val2_new", param3: "val3_new" }

// { some_key: { param1: "val1", param2: "val2", param3: "val3" } }
// { some_key: { param1: "val1", param2: "val2"                 } }
db.collection.update({}, [{ $addFields: { some_key: new_info } }], { multi: true })
// { some_key: { param1: "val1", param2: "val2_new", param3: "val3_new" } }
// { some_key: { param1: "val1", param2: "val2_new", param3: "val3_new" } }

• Der erste Teil {}ist die Übereinstimmungsabfrage, bei der gefiltert wird, welche Dokumente aktualisiert werden sollen (in diesem Fall alle Dokumente).

• Der zweite Teil [{ $addFields: { some_key: new_info } }]ist die Update-Aggregations-Pipeline:

  • Beachten Sie die eckigen Klammern, die die Verwendung einer Aggregationspipeline angeben.
  • Da dies eine Aggregationspipeline ist, können wir verwenden $addFields.
  • $addFields führt genau das aus, was Sie benötigen: Aktualisieren des Objekts, sodass das neue Objekt mit dem vorhandenen Objekt überlagert / zusammengeführt wird:
  • In diesem Fall { param2: "val2_new", param3: "val3_new" }wird in das vorhandene zusammengeführt, some_keyindem Sie param1unberührt bleiben und entweder beide param2und entweder hinzufügen oder ersetzen param3.

• Vergessen Sie nicht { multi: true }, sonst wird nur das erste übereinstimmende Dokument aktualisiert.

db.collection.update(  { _id:...} , { $set: { some_key : new_info  } } 

zu

db.collection.update( { _id: ..} , { $set: { some_key: { param1: newValue} } } ); 

Ich hoffe das hilft!

Sie könnten lieber einen Upsert durchführen. Dieser Vorgang in MongoDB wird verwendet, um Dokumente in der Sammlung zu speichern. Wenn das Dokument den Abfragekriterien entspricht, wird ein Aktualisierungsvorgang ausgeführt, andernfalls wird ein neues Dokument in die Sammlung eingefügt.

etwas ähnliches wie unten

db.employees.update(
    {type:"FT"},
    {$set:{salary:200000}},
    {upsert : true}
 )

Verwenden Sie $ set, um diesen Vorgang auszuführen

.update({"_id": args.dashboardId, "viewData._id": widgetId}, {$set: {"viewData.$.widgetData": widgetDoc.widgetData}})
.exec()
.then(dashboardDoc => {
    return {
        result: dashboardDoc
    };
}); 

Erstellen Sie ein Aktualisierungsobjekt mit den Eigenschaftsnamen einschließlich des erforderlichen Punktpfads. ("somekey." + aus dem Beispiel von OP), und verwenden Sie dann das Update.

//the modification that's requested
updateReq = { 
   param2 : "val2_new",
   param3 : "val3_new"   
}

//build a renamed version of the update request
var update = {};
for(var field in updateReq){
    update["somekey."+field] = updateReq[field];
}

//apply the update without modifying fields not originally in the update
db.collection.update({._id:...},{$set:update},{upsert:true},function(err,result){...});

Ja, der beste Weg ist, die Objektnotation in eine flache Darstellung von Schlüsselwertzeichenfolgen zu konvertieren, wie in diesem Kommentar erwähnt: https://stackoverflow.com/a/39357531/2529199

Ich wollte eine alternative Methode mit dieser NPM-Bibliothek hervorheben: https://www.npmjs.com/package/dot-object, mit der Sie verschiedene Objekte mithilfe der Punktnotation bearbeiten können.

Ich habe dieses Muster verwendet, um programmgesteuert eine verschachtelte Objekteigenschaft zu erstellen, wenn der Schlüsselwert wie folgt als Funktionsvariable akzeptiert wurde:

const dot = require('dot-object');

function(docid, varname, varvalue){
  let doc = dot.dot({
      [varname]: varvalue 
  });

  Mongo.update({_id:docid},{$set:doc});
}

Mit diesem Muster kann ich verschachtelte und einstufige Eigenschaften austauschbar verwenden und sie sauber in Mongo einfügen.

Wenn Sie mit JS-Objekten außerhalb von Mongo herumspielen müssen, insbesondere auf der Clientseite, aber bei der Arbeit mit Mongo konsistent sind, bietet Ihnen diese Bibliothek mehr Optionen als das zuvor erwähnte mongo-dot-notationNPM-Modul.

PS Ich wollte dies ursprünglich nur als Kommentar erwähnen, aber anscheinend ist mein S / O-Mitarbeiter nicht hoch genug, um einen Kommentar zu schreiben. Um nicht auf SzybkiSaszas Kommentar einzugehen, wollte ich nur die Bereitstellung eines alternativen Moduls hervorheben.

Ich habe versucht findAndModify(), ein bestimmtes Feld in einem bereits vorhandenen Objekt zu aktualisieren.

https://docs.mongodb.com/manual/reference/method/db.collection.findAndModify/

Sie sollten darüber nachdenken, das Objekt austauschbar zu aktualisieren, und dann einfach das Objekt mit den aktualisierten Feldern speichern. So etwas wie unten gemacht

function update(_id) {
    return new Promise((resolve, reject) => {

        ObjModel.findOne({_id}).exec((err, obj) => {

            if(err) return reject(err)

            obj = updateObject(obj, { 
                some_key: {
                    param2 : "val2_new",
                    param3 : "val3_new"
                }
            })

            obj.save((err, obj) => {
                if(err) return reject(err)
                resolve(obj)
            })
        })
    })
}


function updateObject(obj, data) {

    let keys = Object.keys(data)

    keys.forEach(key => {

        if(!obj[key]) obj[key] = data[key]

        if(typeof data[key] == 'object') 
            obj[key] = updateObject(obj[key], data[key])
        else
            obj[key] = data[key]
    })

    return obj
}

Sie müssen eingebettete Dokumente verwenden (Zeichenfolge für das Pfadobjekt).

let update = {}
Object.getOwnPropertyNames(new_info).forEach(param => {
   update['some_key.' + param] = new_info[param]
})

In JavaScript können Sie den Spread Operator (...) zum Aktualisieren verwenden

db.collection.update(  { _id:...} , { $set: { ...update  } }