Causal consistency concept in MongoDB - Step-by-Step Execution

Concept Flow - Causal consistency concept

Client A writes data X

↓

Client B reads data X

↓

Client B writes data Y based on X

↓

Client A reads data Y

↓

Causal order preserved

↓

No conflicting views

Causal consistency ensures that if one operation influences another, all clients see these operations in the same order.

Execution Sample

MongoDB

session = client.start_session(causal_consistency=True)
with session.start_transaction():
    collection.insert_one({'_id': 1, 'value': 'X'}, session=session)
    doc = collection.find_one({'_id': 1}, session=session)
    collection.insert_one({'_id': 2, 'value': 'Y', 'based_on': doc['_id']}, session=session)

This code shows a client writing data X, reading it, then writing data Y based on X within a causally consistent session.

Execution Table

Step	Action	Operation	Data State	Causal Order Maintained
1	Start session with causal consistency	Session started	No data	Yes
2	Insert document X	Write {'_id':1, 'value':'X'}	Data: X inserted	Yes
3	Read document X	Read {'_id':1}	Data: X read	Yes
4	Insert document Y based on X	Write {'_id':2, 'value':'Y', 'based_on':1}	Data: X and Y inserted	Yes
5	End transaction	Commit	Data committed	Yes
6	Another client reads Y	Read {'_id':2}	Sees Y and X	Yes
7	Another client reads X	Read {'_id':1}	Sees X	Yes
8	Exit	No more operations	Final data state consistent	Yes

💡 All operations respect causal order, so clients see related writes in correct sequence.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
session	null	active	active	active	ended
data X	none	inserted	read	inserted	persisted
data Y	none	none	none	inserted	persisted

Key Moments - 2 Insights

Why does client B see data X before writing data Y?

Because causal consistency ensures client B reads the write of data X before writing data Y that depends on it, as shown in execution_table step 3 and 4.

Can client A see data Y before data X?

No, client A cannot see data Y before data X because causal consistency preserves the order of dependent writes, as shown in execution_table steps 2, 4, and 6.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is data Y inserted?

A Step 3

B Step 2

C Step 4

D Step 6

💡 Hint

Check the 'Operation' column for the write of document Y.

According to variable_tracker, what is the state of 'session' after Step 4?

A active

B null

C ended

D committed

💡 Hint

Look at the 'session' row and the column 'After Step 4'.

If causal consistency was not enabled, what might happen when another client reads data?

A Client B cannot write data Y

B Another client might see data Y before data X

C Client B would always see data X first

D Client B session would end early

💡 Hint

Causal consistency ensures order; without it, order can be broken as shown in the concept description.

Concept Snapshot

Causal consistency ensures operations that depend on each other are seen in order.
Clients see writes that influence their reads before their own writes.
Use sessions with causal_consistency=True in MongoDB.
This avoids conflicting or out-of-order views.
Ideal for collaborative or dependent data updates.

Full Transcript

Causal consistency in MongoDB means that if one client writes data and another client reads it and then writes related data, all clients will see these operations in the same order. This prevents confusion from seeing updates out of order. The example code shows a session with causal consistency enabled where data X is written, read, and then data Y is written based on X. The execution table traces each step, showing data states and confirming causal order is maintained. Variable tracking shows session and data states changing step by step. Key moments clarify why clients see data in order and cannot see dependent data before its base. The quiz tests understanding of when data is written, session states, and what happens without causal consistency. The snapshot summarizes the concept simply for quick recall.