Aggiornamento MongoDBMolti()

In MongoDB il db.collection.updateMany() il metodo aggiorna tutti i documenti che corrispondono al filtro specificato per una raccolta.

Esempio

Supponiamo di avere una collezione chiamata pets che contiene i seguenti documenti:

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

Possiamo vedere che due documenti hanno Dog come loro type .

Possiamo aggiornare entrambi i documenti contemporaneamente in questo modo:

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

Risultato:

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

Questo ci mostra che due documenti corrispondono e due sono stati aggiornati.

Possiamo controllare la collezione:

db.pets.find()

Risultato:

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

Ribaltamento

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

Quando upsert: true , tutti i documenti che soddisfano i criteri di filtro vengono aggiornati, ma se non ci sono corrispondenze, 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.updateMany( 
    { name: "Bubbles" },
    { $set: { type: "Fish" } },
    { upsert: true }
    )

Risultato:

 {
 "acknowledged" : true,
 "matchedCount" : 0,
 "modifiedCount" : 0,
 "upsertedId" : ObjectId("5fe27e1dd991410169410244")
 } 

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("5fe27e1dd991410169410244"), "name" : "Bubbles", "type" : "Fish" } 

Documenti incorporati

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

Supponiamo di inserire i seguenti documenti:

db.pets.insertMany([
    {
        "_id" : 1,
        "name" : "Wag",
        "type" : "Dog",
        "specs" : {
            "height" : 400,
            "weight" : 15,
            "color" : "white"
        }
    },  
    {
        "_id" : 2,
        "name" : "Bark",
        "type" : "Dog",
        "specs" : {
            "height" : 200,
            "weight" : 12,
            "color" : "white"
        }
    }
])

Possiamo utilizzare il codice seguente per aggiornare il documento incorporato.

db.pets.updateMany({ 
    type: "Dog" 
    }, { 
        $set: { 
            "specs.color": "brown",
            "specs.gooddog": false
        } 
})

Risultato:

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

Quindi possiamo vedere che entrambi i documenti sono stati aggiornati.

Controlliamo il documento.

db.pets.find({
    type: "Dog"
    }).pretty()

Risultato:

{
	"_id" : 1,
	"name" : "Wag",
	"type" : "Dog",
	"specs" : {
		"height" : 400,
		"weight" : 15,
		"color" : "brown",
		"gooddog" : false
	}
}
{
	"_id" : 2,
	"name" : "Bark",
	"type" : "Dog",
	"specs" : {
		"height" : 200,
		"weight" : 12,
		"color" : "brown",
		"gooddog" : false
	}
}

Possiamo vedere che i documenti incorporati sono stati aggiornati come specificato.

Array

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

Supponiamo di avere una collezione chiamata players con i seguenti documenti:

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

Aggiorniamo due elementi dell'array in tutti i documenti.

db.players.updateMany({}, 
{ 
        $set: {
            "scores.0": 20, 
            "scores.1": 26
        } 
})

Risultato:

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

Possiamo vedere che tutti e tre i documenti sono stati aggiornati. Questo perché ho lasciato vuoti i criteri del filtro (ho usato {} per i criteri di filtro).

E diamo un'occhiata al documento.

db.players.find()

Risultato:

 { "_id" : 1, "scores" : [ 20, 26, 3 ] }
 { "_id" : 2, "scores" : [ 20, 26, 18 ] }
 { "_id" : 3, "scores" : [ 20, 26, 8 ] } 

Il parametro arrayFilters

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

Ad esempio, guardando il nostro documento precedente:

 { "_id" : 1, "scores" : [ 20, 26, 3 ] }
 { "_id" : 2, "scores" : [ 20, 26, 18 ] }
 { "_id" : 3, "scores" : [ 20, 26, 8 ] } 

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

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

Risultato:

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

Come previsto, tutti i documenti soddisfano i criteri e sono quindi aggiornati. Tuttavia, non tutti gli elementi dell'array sono stati aggiornati.

Ecco come sono ora i documenti.

db.players.find()

Risultato:

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

Gli unici elementi dell'array che sono stati aggiornati sono quelli con un valore superiore a 15.

Maggiori informazioni

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

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