Read concern levels (local, majority, snapshot) in MongoDB

Introduction

Read concern levels tell MongoDB how fresh or safe the data you read should be. They help you decide if you want the newest data or data confirmed by many servers.

When you want to read the most recent data even if it is not confirmed by other servers.

When you want to read data that is confirmed by most servers to avoid reading uncommitted changes.

When you want to read a consistent snapshot of data at a specific point in time during a transaction.

When you want to avoid reading data that might be rolled back in case of failures.

When you want to balance between speed and data accuracy depending on your application needs.

Syntax

MongoDB

db.collection.find().readConcern('level')

// where 'level' can be 'local', 'majority', or 'snapshot'

local returns the most recent data on the node, even if not confirmed by others.

majority returns data confirmed by most nodes, ensuring durability.

snapshot provides a consistent view of data during a transaction.

Examples

Reads the most recent data from the node, fast but might not be confirmed by others.

MongoDB

db.orders.find().readConcern('local')

Reads data confirmed by most nodes, safer but might be slightly older.

MongoDB

db.orders.find().readConcern('majority')

Reads a consistent snapshot of data inside a transaction.

MongoDB

session = db.getMongo().startSession({readConcern: {level: 'snapshot'}})
session.startTransaction()
session.getDatabase('shop').orders.find().toArray()
session.commitTransaction()
session.endSession()

Sample Program

This example inserts two orders and reads them twice: once with 'local' and once with 'majority' read concern.

MongoDB

use shop

// Insert sample data
db.orders.insertMany([
  {item: 'apple', qty: 5},
  {item: 'banana', qty: 10}
])

// Read with local read concern
print('Local read concern:')
var localData = db.orders.find().readConcern('local').toArray()
printjson(localData)

// Read with majority read concern
print('Majority read concern:')
var majorityData = db.orders.find().readConcern('majority').toArray()
printjson(majorityData)

Important Notes

Use local for fastest reads when you don't mind reading unconfirmed data.

majority is safer for critical data because it reads data confirmed by most servers.

snapshot is only available inside transactions and gives a consistent view of data.

Summary

Read concern controls how fresh and safe your read data is.

local is fastest but less safe, majority is safer but might be slower.

snapshot is for consistent reads inside transactions.

Practice

1. Which MongoDB read concern level provides the fastest read but may return data that is not yet acknowledged by majority of nodes?

easy

A. local

B. majority

C. snapshot

D. linearizable

Solution

1. Step 1: Understand read concern levels

   local returns the most recent data on the node but does not wait for replication.

2. Step 2: Compare with other levels

   majority waits for data to be acknowledged by majority nodes, snapshot is for transactions, and linearizable is stricter and slower.

3. Final Answer:

   local -> Option A

4. Quick Check:

   Fastest read = local [OK]

Hint: Fastest read is always local [OK]

Common Mistakes:

• Confusing local with majority
• Thinking snapshot is fastest
• Assuming linearizable is default

2. Which of the following is the correct syntax to set read concern to majority in a MongoDB query?

easy

A. db.collection.find.readConcern('majority')

B. db.collection.find().readConcern = 'majority'

C. db.collection.find().readConcern('majority')

D. db.collection.find().withReadConcern('majority')

Solution

1. Step 1: Recall MongoDB read concern syntax

   The correct method to set read concern on a query is readConcern('level').

2. Step 2: Check options for syntax correctness

   Some options look similar, but one omits parentheses after find. The correct chaining is db.collection.find().readConcern('majority').

3. Final Answer:

   db.collection.find().readConcern('majority') -> Option C

4. Quick Check:

   Correct method call = db.collection.find().readConcern('majority') [OK]

Hint: Use .readConcern('level') after find() [OK]

Common Mistakes:

• Using assignment instead of method call
• Using non-existent method names
• Placing parentheses incorrectly

3. Given a MongoDB transaction using snapshot read concern, what will be the behavior if a document is updated after the transaction starts but before it reads the document?

medium

A. The transaction reads the updated document reflecting the change.

B. The transaction reads the document state as it was at the start of the transaction.

C. The transaction throws an error due to data inconsistency.

D. The transaction reads the document from the primary node only.

Solution

1. Step 1: Understand snapshot read concern in transactions

   snapshot ensures a consistent view of data as of the start of the transaction.

2. Step 2: Analyze document update timing

   Since the document was updated after the transaction started, the transaction will not see this change.

3. Final Answer:

   The transaction reads the document state as it was at the start of the transaction. -> Option B

4. Quick Check:

   snapshot = consistent start view [OK]

Hint: Snapshot reads see data as of transaction start [OK]

Common Mistakes:

• Assuming transaction sees latest updates
• Thinking snapshot causes errors on updates
• Confusing snapshot with majority read concern

4. You wrote this code snippet to set read concern to majority but it throws an error:

db.collection.find().readConcern = 'majority'

What is the error and how to fix it?

medium

A. No error, code is correct.

B. Error: readConcern must be set on the client, not query.

C. Error: 'majority' is not a valid read concern level.

D. Error: readConcern is a method, use readConcern('majority') instead.

Solution

1. Step 1: Identify the error cause

   Assigning a string to readConcern property is invalid because it is a method, not a property.

2. Step 2: Correct the syntax

   Use method call syntax: readConcern('majority') to set the read concern level.

3. Final Answer:

   Error: readConcern is a method, use readConcern('majority') instead. -> Option D

4. Quick Check:

   Use method call, not assignment [OK]

Hint: Use parentheses for readConcern, not assignment [OK]

Common Mistakes:

• Assigning string instead of calling method
• Setting read concern on wrong object
• Using invalid read concern levels

5. You want to ensure your MongoDB transaction reads a consistent snapshot of data and also that your reads outside transactions see only data confirmed by majority of nodes. Which read concern levels should you use respectively?

hard

A. snapshot for transactions, majority for outside reads

B. local for transactions, snapshot for outside reads

C. majority for transactions, local for outside reads

D. snapshot for transactions, local for outside reads

Solution

1. Step 1: Identify read concern for transactions

   snapshot read concern ensures consistent view inside transactions.

2. Step 2: Identify read concern for outside transactions

   majority ensures reads see data confirmed by majority of nodes, providing safety.

3. Final Answer:

   snapshot for transactions, majority for outside reads -> Option A

4. Quick Check:

   Transaction = snapshot, Outside = majority [OK]

Hint: Use snapshot in transactions, majority outside [OK]

Common Mistakes:

• Using local inside transactions
• Confusing majority with snapshot
• Using local for safe reads