Change streams on collections in MongoDB - Step-by-Step Execution

Concept Flow - Change streams on collections

Start watching collection

↓

Wait for change event

↓

Change occurs in collection

↓

Change event captured

↓

Process event data

↓

Continue listening or stop

This flow shows how MongoDB listens for changes on a collection and processes each change event as it happens.

Execution Sample

MongoDB

const changeStream = db.collection('orders').watch();
changeStream.on('change', (change) => {
  console.log(change);
});

This code opens a change stream on the 'orders' collection and logs each change event as it occurs.

Execution Table

Step	Action	Change Detected	Event Data	Output
1	Open change stream on 'orders'	No	N/A	Listening for changes
2	Insert new order document	Yes	{"operationType":"insert","fullDocument":{"_id":1,"item":"book"}}	Logs insert event
3	Update order document _id=1	Yes	{"operationType":"update","documentKey":{"_id":1},"updateDescription":{"updatedFields":{"status":"shipped"}}}	Logs update event
4	Delete order document _id=1	Yes	{"operationType":"delete","documentKey":{"_id":1}}	Logs delete event
5	No further changes	No	N/A	Waits for next change or stops

💡 Stops listening when change stream is closed or application ends

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
changeStream	Not opened	Opened and listening	Listening	Listening	Closed or still listening
change	None	Insert event object	Update event object	Delete event object	None or last event

Key Moments - 3 Insights

Why does the change stream keep listening even after one change event?

Because change streams are designed to continuously watch for changes until explicitly closed, as shown in execution_table rows 2-5.

What kind of events can the change stream detect?

It detects insert, update, delete, and other operations on the collection, as seen in the 'Change Detected' and 'Event Data' columns in the execution_table.

What happens if no changes occur after opening the change stream?

The stream waits and does not produce output until a change happens, shown in step 1 and step 5 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the 'change' variable value after step 3?

A Update event object

B Insert event object

C Delete event object

D None

💡 Hint

Check the 'change' row in variable_tracker after Step 3

At which step does the change stream detect a delete operation?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Change Detected' column in execution_table for 'delete'

If no changes occur, what does the change stream do according to the execution_table?

A Closes automatically

B Logs an error

C Waits for next change

D Returns empty data

💡 Hint

See Step 1 and Step 5 in execution_table where no changes are detected

Concept Snapshot

Change streams let you watch real-time changes on a MongoDB collection.
Use collection.watch() to open a stream.
Listen for 'change' events to get insert, update, delete info.
The stream stays open until closed.
Useful for reactive apps and syncing data.

Full Transcript

Change streams in MongoDB allow applications to listen for real-time changes on a collection. When you open a change stream using the watch() method on a collection, MongoDB waits for any changes like inserts, updates, or deletes. Each time a change happens, an event is sent to your application with details about the operation. The stream keeps listening until you close it or the application ends. This lets you react immediately to data changes without polling the database.

Practice

1. What is the main purpose of using change streams on a MongoDB collection?

easy

A. To create indexes on the collection

B. To backup the collection data automatically

C. To watch for real-time changes happening in the collection

D. To delete documents based on a condition

Solution

1. Step 1: Understand what change streams do

   Change streams allow applications to listen for real-time changes like inserts, updates, or deletes in a collection.

2. Step 2: Compare options with this purpose

   Only To watch for real-time changes happening in the collection describes watching for real-time changes, which matches the purpose of change streams.

3. Final Answer:

   To watch for real-time changes happening in the collection -> Option C

4. Quick Check:

   Change streams = watch real-time changes [OK]

Hint: Change streams = real-time watch on collection changes [OK]

Common Mistakes:

• Thinking change streams backup data
• Confusing change streams with indexing
• Assuming change streams delete documents

2. Which of the following is the correct way to start a change stream on a collection named orders in MongoDB?

easy

A. db.orders.changeStream()

B. db.orders.watch()

C. db.orders.listen()

D. db.orders.observe()

Solution

1. Step 1: Recall the MongoDB method for change streams

   The correct method to open a change stream on a collection is watch().

2. Step 2: Match the method with the collection name

   Using db.orders.watch() correctly starts the change stream on the orders collection.

3. Final Answer:

   db.orders.watch() -> Option B

4. Quick Check:

   Change stream method = watch() [OK]

Hint: Use .watch() to start change streams on collections [OK]

Common Mistakes:

• Using non-existent methods like changeStream()
• Confusing with listen() or observe() which don't exist
• Misspelling the method name

3. Given the following code snippet, what will be the output when a new document is inserted into the products collection?

const changeStream = db.products.watch();
changeStream.on('change', (change) => {
  console.log(change.operationType);
});

medium

A. 'insert'

B. 'update'

C. 'delete'

D. 'replace'

Solution

1. Step 1: Understand the event listener on change stream

   The code listens for any change and logs the operationType of that change.

2. Step 2: Identify the operation type for inserting a document

   When a new document is inserted, the operationType is insert.

3. Final Answer:

   'insert' -> Option A

4. Quick Check:

   Insert operation logs 'insert' [OK]

Hint: Insert triggers operationType 'insert' in change stream [OK]

Common Mistakes:

• Confusing insert with update or delete
• Expecting full document instead of operationType
• Misreading event listener output

4. You wrote this code to watch changes on the users collection but it throws an error:

const changeStream = db.users.watch({ operationType: 'insert' });

What is the mistake?

medium

A. The operationType should be capitalized as 'Insert'

B. The collection name should be user not users

C. You must call start() after watch()

D. The watch method does not accept a filter object directly

Solution

1. Step 1: Check the argument to watch()

   The watch() method expects an array pipeline for filtering, not a direct object.

2. Step 2: Understand correct filtering syntax

   To filter by operationType, you must pass a pipeline like [{ $match: { operationType: 'insert' } }].

3. Final Answer:

   The watch method does not accept a filter object directly -> Option D

4. Quick Check:

   Filter must be pipeline array, not object [OK]

Hint: Use pipeline array for filters in watch() [OK]

Common Mistakes:

• Passing filter as object instead of pipeline array
• Wrong collection name assumption
• Expecting a start() method
• Capitalizing operationType values incorrectly

5. You want to build a live notification system that only alerts when a document in the tasks collection is updated and the status field changes to 'completed'. Which change stream pipeline correctly filters these changes?

hard

A. [{ $match: { operationType: 'update', 'updateDescription.updatedFields.status': 'completed' } }]

B. [{ $match: { operationType: 'insert', 'fullDocument.status': 'completed' } }]

C. [{ $match: { 'updateDescription.updatedFields.status': 'completed' } }]

D. [{ $match: { operationType: 'delete', 'updateDescription.updatedFields.status': 'completed' } }]

Solution

1. Step 1: Identify the operation type needed

   We want to watch only updates, so operationType must be 'update'.

2. Step 2: Filter for status field changed to 'completed'

   The updateDescription.updatedFields.status contains changed fields; we check if it equals 'completed'.

3. Step 3: Combine filters in a pipeline

   The correct pipeline is [{ $match: { operationType: 'update', 'updateDescription.updatedFields.status': 'completed' } }].

4. Final Answer:

   [{ $match: { operationType: 'update', 'updateDescription.updatedFields.status': 'completed' } }] -> Option A

5. Quick Check:

   Filter updates with status='completed' = [{ $match: { operationType: 'update', 'updateDescription.updatedFields.status': 'completed' } }] [OK]

Hint: Filter update and updatedFields.status in $match pipeline [OK]

Common Mistakes:

• Filtering inserts or deletes instead of updates
• Checking fullDocument instead of updateDescription
• Missing operationType filter
• Using wrong field path in filter