mongodb: should i always use the 'safe' option on updates

Question

when dealing with mongodb, when should i use the {safe: true} on queries?

Right now I use the \'safe\' option just to check if my queries were inserted or updated succes

Answer 1

Assuming when you say queries you actually mean writes/inserts (the wording of your question makes me think this) then the Write Concern (safe, none, fsync, etc) can be used to get more speed and less safety when that is acceptable, and less speed and more safety when that is necessary.

As an example, a hypothetical Facebook-style application could use an unsafe write for "Likes" while it would use a very safe write for password changes. The logic behind this is that there will be many thousand "Like"-style updates happening a second, and it doesn't matter if one is lost, whereas password updates happen less regularly but it is essential that they succeed.

Therefore, try to tailor your Write Concern choice to the kind of update you are doing, based upon your speed and data integrity requirements.

Answer 2

Here is another use case where unsafe writes are an appropriate choice: You are making a large number of writes in very short order. In this case you might perform a number of writes, and then call get last error to see if any of them failed.

collection.setWriteConcern(WriteConcern.NORMAL)
collection.getDB().resetError()
List<
for (Something data : importData) {
    collection.insert(makeDBObject(data))
}
collection.getDB().getLastError(WriteConcern.REPLICAS_SAFE).throwOnError()

If this block succeeds without an exception, then all of the data was inserted successfully. If there was an exception, then one or more of the write operations failed, and you will need to retry them (or check for a unique index violation, etc). In real life, you might call getLastError every 10 writes or so, to avoid having to resubmit lots of requests.

This pattern is very nice for performance when performing bulk inserts of large amounts of data.

Answer 3

Safe is only necessary on writes, not reads. Queries are only reads.