Aggiornamento MongoDB()

In MongoDB il db.collection.update() il metodo modifica uno o più documenti esistenti in una raccolta.

Per impostazione predefinita, aggiorna solo un singolo documento. Ma se multi: true viene specificato, quindi aggiorna tutti i documenti che soddisfano i criteri di ricerca.

Aggiorna un singolo documento

Supponiamo di avere la collezione chiamata pets con i seguenti documenti:

{ "_id" : 1, "name" : "Wag", "type" : "Dog" }
{ "_id" : 2, "name" : "Bark", "type" : "Dog" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }

Possiamo aggiornare un singolo documento come questo:

db.pets.update( 
    { type: "Dog" },
    { $set: { type: "Cow" } }
    )

Risultato:

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

È stato aggiornato un solo documento. Ciò viene confermato quando interroghiamo la raccolta.

db.pets.find()

Risultato:

{ "_id" : 1, "name" : "Wag", "type" : "Cow" }
{ "_id" : 2, "name" : "Bark", "type" : "Dog" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }

Aggiorna più documenti

Usiamo ancora i documenti originali:

{ "_id" : 1, "name" : "Wag", "type" : "Dog" }
{ "_id" : 2, "name" : "Bark", "type" : "Dog" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }

Questa volta aggiungeremo multi: true alla nostra operazione di aggiornamento per aggiornare tutti i documenti che soddisfano i criteri di ricerca:

db.pets.update( 
    { type: "Dog" },
    { $set: { type: "Cow" } },
    { multi: true }
    )

Risultato:

WriteResult({ "nMatched" : 2, "nUpserted" : 0, "nModified" : 2 }) 

Quindi due documenti sono stati confrontati e aggiornati questa volta.

Diamo un'occhiata alla nostra collezione:

db.pets.find()

Risultato:

{ "_id" : 1, "name" : "Wag", "type" : "Cow" }
{ "_id" : 2, "name" : "Bark", "type" : "Cow" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }

Come previsto, entrambi i documenti ora hanno un type di Cow .

Ribaltamento

Il db.collection.update() il metodo accetta un upsert argomento che consente di eseguire un'operazione di inserimento.

Quando upsert: true , il documento viene aggiornato se c'è una corrispondenza con i criteri del filtro, ma se non c'è corrispondenza, viene inserito un nuovo documento.

Ricominciamo con i documenti originali:

{ "_id" : 1, "name" : "Wag", "type" : "Dog" }
{ "_id" : 2, "name" : "Bark", "type" : "Dog" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }

Esempio:

db.pets.update( 
    { name: "Bubbles" },
    { $set: { type: "Fish" } },
    { upsert: true }
    )

Risultato:

 WriteResult({
 "nMatched" : 0,
 "nUpserted" : 1,
 "nModified" : 0,
 "_id" : ObjectId("5fe2c925d9914101694102e1")
 }) 

In questo caso, non c'erano corrispondenze, quindi un documento è stato sostituito.

Controlliamo la collezione.

db.pets.find()

Risultato:

 { "_id" : 1, "name" : "Wag", "type" : "Dog" }
 { "_id" : 2, "name" : "Bark", "type" : "Dog" }
 { "_id" : 3, "name" : "Meow", "type" : "Cat" }
 { "_id" : ObjectId("5fe2c925d9914101694102e1"), "name" : "Bubbles", "type" : "Fish" } 

Documenti incorporati

Puoi anche usare db.collection.update() per aggiornare i documenti incorporati.

Supponiamo di avere il seguente documento:

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

Possiamo utilizzare il codice seguente per aggiornare il documento incorporato.

db.pets.update({ 
    _id: 1 
    }, { 
        $set: { 
            "specs.weight": 20, 
            "specs.color": "blue"
        } 
})

Risultato:

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 }) 

Quindi possiamo vedere che un documento è stato abbinato e modificato.

Controlliamo il documento.

db.pets.find({
    _id: 1
    }).pretty()

Risultato:

{
	"_id" : 1,
	"name" : "Wag",
	"type" : "Dog",
	"specs" : {
		"height" : 400,
		"weight" : 20,
		"color" : "blue"
	}
}

Possiamo vedere che il documento incorporato è stato aggiornato come specificato.

Array

Usiamo db.collection.update() per aggiornare un array.

Supponiamo di avere il seguente documento:

{
	"_id" : 1,
	"name" : "Wag",
	"type" : "Dog",
	"awards" : [
		"Top Dog",
		"Best Dog",
		"Biggest Dog"
	]
}

Aggiorniamo due degli elementi dell'array e il nome del cane.

db.pets.update({ 
    _id: 1 
    }, { 
        $set: { 
            "name": "Bark",
            "awards.0": "Bottom Dog", 
            "awards.1": "Worst Dog"
        } 
})

Risultato:

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 }) 

Possiamo vedere che un documento è stato abbinato e modificato.

E ora guarda il documento.

db.pets.find().pretty()

Risultato:

{
	"_id" : 1,
	"name" : "Bark",
	"type" : "Dog",
	"awards" : [
		"Bottom Dog",
		"Worst Dog",
		"Biggest Dog"
	]
}

Il parametro arrayFilters

Puoi anche usare gli arrayFilters parametro e il $ posizionale per determinare quali elementi dell'array aggiornare.

Ad esempio, supponiamo di avere una raccolta chiamata players con i seguenti documenti:

{ "_id" : 1, "scores" : [ 1, 5, 3 ] }
{ "_id" : 2, "scores" : [ 8, 17, 18 ] }
{ "_id" : 3, "scores" : [ 15, 11, 8 ] }

Potremmo eseguire la seguente query per aggiornare solo quegli elementi dell'array che hanno un valore superiore a un determinato importo (in questo caso 10).

db.players.update(
   { scores: { $gte: 10 } },
   { $set: { "scores.$[e]" : 10 } },
   { arrayFilters: [ { "e": { $gte: 10 } } ] }
)

Risultato:

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 }) 

Come previsto, questo aggiorna solo un documento, anche se due documenti corrispondono ai criteri (perché non abbiamo specificato multi: true ).

Ecco come sono ora i documenti.

db.players.find()

Risultato:

{ "_id" : 1, "scores" : [ 1, 5, 3 ] }
{ "_id" : 2, "scores" : [ 8, 10, 10 ] }
{ "_id" : 3, "scores" : [ 15, 11, 8 ] }

Nel documento 2 sono stati aggiornati due elementi dell'array, poiché tali elementi corrispondevano ai criteri.

Maggiori informazioni

Il db.collection.update() accetta anche altri parametri, come writeConcern , collation e hint .

Consulta la documentazione di MongoDB per db.collections.update() per ulteriori informazioni.