Change stream events (insert, update, delete) in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a change stream in MongoDB?

A change stream lets you watch real-time changes (like insert, update, delete) happening in your MongoDB database collections.

beginner

Which change stream event is triggered when a new document is added?

The insert event is triggered when a new document is added to a collection.

beginner

What does the update event in a change stream represent?

The update event means an existing document was changed, like modifying one or more fields.

beginner

What happens during a delete event in a MongoDB change stream?

A delete event means a document was removed from the collection.

intermediate

How can you use change streams to keep your app data updated?

You listen to change stream events (insert, update, delete) and update your app's data or UI instantly when changes happen in the database.

Which change stream event occurs when a document is removed?

A insert

B delete

C update

D replace

The delete event is triggered when a document is removed from the collection.

What type of change stream event is triggered when a document's field value changes?

A drop

B insert

C delete

D update

The update event happens when an existing document is modified.

Which event would you listen to if you want to know when new data is added?

A insert

B invalidate

C delete

D update

The insert event is for new documents added to the collection.

Can change streams detect multiple types of events?

A No, only update

B No, only insert

C Yes, insert, update, delete, and more

D No, only delete

Change streams can detect insert, update, delete, replace, and other events.

What is a practical use of MongoDB change streams?

A To watch real-time data changes and update apps instantly

B To backup data manually

C To create indexes

D To delete collections

Change streams help apps react instantly to data changes by watching events like insert, update, and delete.

Explain what insert, update, and delete events mean in MongoDB change streams.

Think about what happens to documents in a collection when these events occur.

Describe how change streams can help keep an application’s data in sync with the database.

Imagine your app needs to show live data changes without refreshing.

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