Change stream events (insert, update, delete) in MongoDB - Step-by-Step Execution

Concept Flow - Change stream events (insert, update, delete)

Start watching collection

↓

Wait for event

↓

Event occurs?

No→Keep waiting

Yes↓

Identify event type

↓

Process

↓

Insert

↓

Continue watching

The system watches a collection and waits for changes. When an insert, update, or delete happens, it processes that event and keeps watching.

Execution Sample

MongoDB

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

This code listens for any change events on a MongoDB collection and prints the type of operation (insert, update, delete) when it happens.

Execution Table

Step	Event Occurs	operationType	Action Taken	Output
1	Insert document	insert	Log 'insert'	insert
2	Update document	update	Log 'update'	update
3	Delete document	delete	Log 'delete'	delete
4	No event	N/A	Wait for event	No output

💡 Watching continues indefinitely until stopped manually.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
event.operationType	undefined	insert	update	delete	undefined

Key Moments - 3 Insights

Why does the listener keep running even when no events happen?

Because the change stream waits for events asynchronously and does not stop unless explicitly closed, as shown in execution_table row 4.

What does 'operationType' represent in the event?

'operationType' tells what kind of change happened (insert, update, delete), as seen in execution_table rows 1-3.

Can multiple event types be handled in the same listener?

Yes, the listener checks the 'operationType' for each event and processes accordingly, demonstrated by the branching in concept_flow.

Visual Quiz - 3 Questions

Look at the execution_table, what is the 'operationType' at Step 2?

A insert

B update

C delete

D N/A

💡 Hint

Check the 'operationType' column in execution_table row 2.

At which step does the system wait without output?

A Step 4

B Step 2

C Step 1

D Step 3

💡 Hint

Look for 'No event' and 'No output' in execution_table.

If a new 'replace' event type is added, how would the execution_table change?

A No change needed

B Replace 'delete' row with 'replace'

C Add a new row with operationType 'replace' and action to log 'replace'

D Remove 'insert' row

💡 Hint

Refer to how insert, update, and delete events are handled in execution_table rows 1-3.

Concept Snapshot

MongoDB change streams watch collections for changes.
Events include insert, update, and delete.
Each event has an 'operationType' field.
Listeners react to events asynchronously.
Change streams run until closed.

Full Transcript

This visual execution shows how MongoDB change streams work by watching a collection for changes. The flow starts by opening a watch on the collection, then waiting for events. When an event occurs, the system checks the type: insert, update, or delete. It processes the event accordingly, for example by logging the operation type. The listener keeps running and waiting for new events until it is stopped manually. Variables like 'event.operationType' change with each event, showing the current event type. Key moments include understanding that the listener runs continuously, what 'operationType' means, and that multiple event types can be handled in one listener. The quiz tests understanding of event types at specific steps, when the system waits, and how to add new event types.

Practice

1. What does a MongoDB change stream primarily allow you to do?

easy

A. Backup the entire database automatically

B. Listen to real-time insert, update, and delete events on a collection

C. Run queries faster by caching results

D. Create indexes on collections

Solution

1. Step 1: Understand the purpose of change streams

   Change streams provide a way to watch for changes like inserts, updates, and deletes in real time.

2. Step 2: Compare options with the purpose

   Only Listen to real-time insert, update, and delete events on a collection describes listening to these real-time events, while others describe unrelated features.

3. Final Answer:

   Listen to real-time insert, update, and delete events on a collection -> Option B

4. Quick Check:

   Change streams = real-time event listening [OK]

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

Common Mistakes:

• Confusing change streams with backups
• Thinking change streams speed up queries
• Mixing change streams with indexing

2. Which of the following is the correct way to start watching a collection for changes in MongoDB?

easy

A. db.collection.observe()

B. db.collection.listen()

C. db.collection.watch()

D. db.collection.monitor()

Solution

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

   The official method to watch changes is watch() on a collection object.

2. Step 2: Verify options

   Only db.collection.watch() uses the correct method name watch(). Others are invalid method names.

3. Final Answer:

   db.collection.watch() -> Option C

4. Quick Check:

   Correct method = watch() [OK]

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

Common Mistakes:

• Using listen() or observe() which don't exist
• Confusing with monitor() which is not a method
• Forgetting to call watch() on the collection

3. Given this code snippet, what type of change event will be logged when a document is deleted?

const changeStream = db.collection('users').watch();
changeStream.on('change', (change) => {
  console.log(change.operationType);
});
// Then a document is deleted from 'users'

medium

A. "delete"

B. "update"

C. "insert"

D. "replace"

Solution

1. Step 1: Understand operationType values in change streams

   When a document is deleted, the operationType is "delete".

2. Step 2: Match the event with the logged output

   The code logs change.operationType, so deleting a document logs "delete".

3. Final Answer:

   "delete" -> Option A

4. Quick Check:

   Delete event logs "delete" [OK]

Hint: Delete event = operationType "delete" [OK]

Common Mistakes:

• Confusing delete with update or insert
• Expecting 'remove' instead of 'delete'
• Not knowing operationType values

4. You wrote this code to watch changes but it throws an error:

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

What is the error?

medium

A. Using 'const' instead of 'let' for changeStream

B. Incorrect event name 'change'

C. No error, code is correct

D. Missing parentheses after watch() method call

Solution

1. Step 1: Identify how watch() is called

   The code assigns db.collection('orders').watch without parentheses, so it assigns the function itself, not the stream.

2. Step 2: Understand the error cause

   Without calling watch() with parentheses, changeStream is not a stream and has no on method, causing an error.

3. Final Answer:

   Missing parentheses after watch() method call -> Option D

4. Quick Check:

   Call watch() with () to get stream [OK]

Hint: Always call watch() with parentheses () [OK]

Common Mistakes:

• Forgetting parentheses after watch
• Thinking event name 'change' is wrong
• Confusing const vs let for streams

5. You want to listen only for insert events on a collection using change streams. Which of these code snippets correctly filters for inserts only?

const changeStream = db.collection('products').watch([
  { $match: { 'operationType': 'insert' } }
]);
changeStream.on('change', (change) => {
  console.log(change.fullDocument);
});

hard

A. The code correctly filters for insert events only

B. The $match stage should use 'operation_type' instead of 'operationType'

C. You must filter inside the on('change') callback, not in watch()

D. Change streams do not support filtering by operationType

Solution

1. Step 1: Understand change stream pipeline filtering

   You can pass an aggregation pipeline to watch() to filter events, using $match on 'operationType'.

2. Step 2: Verify the filter syntax

   The code uses { $match: { 'operationType': 'insert' } }, which is the correct way to filter for insert events.

3. Final Answer:

   The code correctly filters for insert events only -> Option A

4. Quick Check:

   Filter inserts with $match on operationType [OK]

Hint: Filter inserts using $match on operationType in watch() [OK]

Common Mistakes:

• Using wrong field name like operation_type
• Filtering inside callback instead of pipeline
• Thinking filtering is not supported