#mongo update

[nofatclips]

MongoDB Updates and Performances

Each document in a collection has allocated record space which includes the document and a small amount of padding, which makes it possible for update operations to increase the size of a document slightly without outgrowing its slot.

When an update makes the document bigger than its allocated size, it cannot possibly happen in place: MongoDB will recreate the document in a new location, where more space can be reserved in order to store it, and delete the old version.

From the user point of view, this move is transparent: the document is still there, in the same collection, only its physical location changed. But it impacts on performances.

First, and most obvious, the single update is slown down by the creation of the new copy of the document. Second, the collection will lose contiguity and get fragmented over different portions (extents) of the data files, slowing down subsequent search operations.

[nofatclips]

Updating all documents in a collection in MongoDB

In order to update all documents in a collection, say for adding a new field to all of them, we set the first argument to update to something that always matches, that is the empty object. But it's not enough! This:

db.myStuff.update({}, {$set: {newFad: "default"}})

(note the use of $set to avoid wholesale update), will just update the first document found in the collection. To update all of them, use the multi flag in the third argument to update:

db.myStuff.update({}, {$set: {newFad: "default"}}, {multi: true})

Since mongo has no transactions, the updates will be executed as a sequence of single update operations, eventually intermingled with other operations, even on the same data.

[nofatclips]

Adding data to MongoDB

Before updating a collection, one obviously needs to insert data in it. The insert() method will create a new record:

db.products.insert( { item: "card", qty: 15 } )

An _id (primary key) value will be added automatically if not specified. If the primary key is specified but a document with that value already exist, you'll get an error:

> var card = db.products.findOne({"item": "card"}) > db.products.insert(card) E11000 duplicate key error index:     dek.products.$_id_  dup key:         { : ObjectId('5194973a65642aa95f1eb40f') }

If you want to insert a document (if new) or update an existing one, Mongo provides a useful wrapper around insert() and update(), the save() method:

> card.qty-=1 14 > db.products.save(card) > db.products.findOne() {         "_id" : ObjectId("5194973a65642aa95f1eb40f"),         "item" : "card",         "qty" : 14 }

[nofatclips]

Updating an array in a MongoDB document

Using the $set operator on an array value will replicate the "wholesale" issue on a smaller scale:

db.people.update({name: "Smith"}, {$set: {"friends": "Girl"}})

the whole array is replaced by the new value. If we want to add a value, the $push operator will do:

db.people.update({name: "Smith"}, {$push: {"friends": "Girl"}})

To avoid duplication, the $addToSet will consider the array as a set and return it untouched if the value is already present:

db.people.update({name: "Smith"}, {$addToSet: {"friends": "Girl"}})

[nofatclips]

Updating a document in MongoDB

The update() method gets two arguments, a query analogous to the find() query and a new object that will replace that matched by the query, except for the primary key:

db.people.update({name: "Smith", salary: 1000}, {"salary": 1200})

This wholesale update will remove the name field, as well as any other field except salary and _id, from the "Smith" document which is probably not what was intented.

To set a particular field (or set of fields) while leaving the others untouched, Mongo provides the $set operator:

db.people.update({name: "Smith", salary: 1000}, {$set: {"salary": 1200}})

But to update an array, even $set won't do.

[mongoblog]

Updating one element in an array

Mongo updates are usually easy and pretty clear (if you are familiar with JSON format), but it has its own limitations, especially when it comes to updating fields within an array.

Let's assume we have a collection 'foo' like so:

> db.foo.find().pretty()

{

"_id" : ObjectId("4f9808648859c65d"),

"array" : [

{"text" : "foo", "value" : 11},

{"text" : "foo", "value" : 22},

{"text" : "foobar", "value" : 33}

]

}

And now we would like to update the text of the element in the array 'array' to "blah" where the value is 22:

> db.foo.update({"array.value" : 22}, {"$set" : {"array.$.text" : "blah"}})

> db.foo.find().pretty()

{

"_id" : ObjectId("4f9808648859c65d"),

"array" : [

{"text" : "foo", "value" : 11},

{"text" : "foobar", "value" : 33},

{"text" : "blah", "value" : 22}

]

}

So, as you just saw, the trick is the dollar sign '$' (called the $ positional operator) which saves the index (1 in our case) of the element from the array that matched the query. This means that if we knew the position of the element (which is nearly impossible in a real life case), we will just change the update statement to : {"$set" : {"array.1.text" : "blah"}}.

Please note that the $ positional operator (for now) updates the first relevant document ONLY. This means if the query was to update all elements where the value is greater than 10, it will just update the element where value is 10, and skip the other two (10gen are still working on this, and here's the ticket for it).

But you can always work around this, and the laziest way is to read the entire document, update it manually, and then save it back. You must be careful with this process since it isn't the safest: the same object might be subject to other updates while you're manually updating the array. To avoid that, the simplest way is to use the 'update if current' (will be the topic of the next post).