Watch method for real-time updates in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What does this change stream watch output?

Consider a MongoDB collection named orders. You run this watch method to listen for insertions:

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

If a new document { _id: 1, item: 'book', qty: 3 } is inserted, what will the change object contain?

MongoDB

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

A An object with <code>operationType</code> as 'delete' and <code>documentKey</code> containing the _id of the deleted document.

B An object with <code>operationType</code> as 'update' and <code>fullDocument</code> containing the inserted document.

C An object with <code>operationType</code> as 'insert' and <code>fullDocument</code> containing the inserted document.

D No output because watch only listens for updates, not inserts.

💡 Hint

Remember that the $match stage filters events by operation type.

The watch method listens for changes matching the filter. Since the filter is for 'insert', the change event will have operationType 'insert' and include the inserted document in fullDocument.

🧠 Conceptual

intermediate

What is the purpose of the resumeToken in MongoDB watch streams?

When using the watch method for real-time updates, MongoDB provides a resumeToken with each change event. What is its main purpose?

A To uniquely identify the change event so the stream can resume from this point if interrupted.

B To encrypt the data sent over the change stream for security.

C To filter change events by document fields.

D To limit the number of change events returned in a batch.

💡 Hint

Think about what happens if the connection drops and you want to continue listening without missing changes.

The resumeToken marks the last seen event so the watch stream can restart from that point, avoiding missed or duplicated events.

📝 Syntax

advanced

Which watch method syntax correctly listens for updates and deletes only?

You want to listen to a MongoDB collection for only update and delete operations using the watch method. Which of the following code snippets is correct?

A db.collection.watch([{ $match: { operationType: { $or: ['update', 'delete'] } } }])

B db.collection.watch([{ $match: { operationType: { $in: ['update', 'delete'] } } }])

C db.collection.watch([{ $match: { operationType: ['update', 'delete'] } }])

D db.collection.watch({ operationType: ['update', 'delete'] })

💡 Hint

Use MongoDB query operators to match multiple values in an array.

The $in operator matches any value in the specified array. The other options use invalid syntax for matching multiple values.

❓ optimization

advanced

How to reduce resource usage when watching a large collection?

You have a large MongoDB collection with frequent changes. Watching all changes causes high resource use. Which approach best reduces resource usage while still capturing relevant changes?

A Use the watch method without a pipeline and rely on polling the collection periodically.

B Watch the entire collection without any filters and discard unwanted events in your application code.

C Increase the batch size of the watch cursor to receive more events at once.

D Use a <code>$match</code> stage in the watch pipeline to filter only needed operation types or fields.

💡 Hint

Filtering early reduces the amount of data sent over the stream.

Applying a $match filter in the watch pipeline limits events sent to the client, reducing network and processing load.

🔧 Debug

expert

Why does this watch stream never receive events?

You run this code to watch a MongoDB collection for inserts:

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

But no events are logged even after inserting documents. What is the most likely cause?

A The MongoDB deployment is a standalone server, which does not support change streams.

B The <code>$match</code> stage is incorrectly filtering for 'insert' instead of 'insertOne'.

C The change stream requires a <code>fullDocument</code> option to receive events.

D The collection is a capped collection, which does not support change streams.

💡 Hint

Change streams require a specific type of MongoDB deployment.

Change streams only work on replica sets or sharded clusters. Standalone servers do not support them, so no events are received.

Practice

1. What is the main purpose of the watch method in MongoDB?

easy

A. To backup the database automatically

B. To create indexes on collections

C. To listen for real-time changes in the database

D. To delete documents in bulk

Solution

1. Step 1: Understand the watch method's role

   The watch method is designed to monitor changes in the database as they happen.

2. Step 2: Compare with other options

   Backup, indexing, and deleting are unrelated to real-time monitoring.

3. Final Answer:

   To listen for real-time changes in the database -> Option C

4. Quick Check:

   watch method = real-time updates [OK]

Hint: Remember: watch means 'listen' for changes [OK]

Common Mistakes:

• Confusing watch with backup or indexing
• Thinking watch deletes data
• Assuming watch modifies data

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

easy

A. db.orders.watch()

B. db.orders.listen()

C. db.orders.observe()

D. db.orders.track()

Solution

1. Step 1: Recall the correct method name

   The method to watch changes is watch(), not listen, observe, or track.

2. Step 2: Apply method to collection

   Calling watch() on db.orders is the correct syntax.

3. Final Answer:

   db.orders.watch() -> Option A

4. Quick Check:

   Correct method is watch() [OK]

Hint: watch() is the exact method name to monitor changes [OK]

Common Mistakes:

• Using listen(), observe(), or track() which don't exist
• Forgetting parentheses after watch
• Calling watch on the database instead of collection

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

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

medium

A. 'insert'

B. 'update'

C. 'delete'

D. No output

Solution

1. Step 1: Understand the event listener

   The code listens for any change event on the users collection and logs the operationType.

2. Step 2: Identify the operation type for insertion

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

3. Final Answer:

   'insert' -> Option A

4. Quick Check:

   Insert triggers operationType 'insert' [OK]

Hint: Insert operationType is 'insert' in change events [OK]

Common Mistakes:

• Expecting 'update' or 'delete' for insert events
• Thinking no output occurs without explicit fetch
• Confusing operationType with full document

4. Identify the error in this MongoDB watch usage:

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

medium

A. The watch method does not accept an object as argument

B. The options should be passed as the second argument, not as the first argument object

C. fullDocument option should be set to 'default', not 'updateLookup'

D. The on method is not valid for change streams

Solution

1. Step 1: Check watch method parameters

   The watch method accepts an optional array pipeline as the first argument, not an object with options.

2. Step 2: Understand where options go

   Options like fullDocument should be passed as the second argument, not inside the pipeline array.

3. Final Answer:

   The options should be passed as the second argument, not as the first argument object -> Option B

4. Quick Check:

   Pipeline is array, options are separate [OK]

Hint: Pass pipeline as array, options as separate object [OK]

Common Mistakes:

• Passing options as first argument instead of second
• Using invalid values for fullDocument
• Misusing event handlers on change streams

5. You want to watch only update operations on the messages collection and get the full updated document in real-time. Which code snippet correctly achieves this?

hard

A. db.messages.watch([{ $match: { operationType: 'update' } }])

B. db.messages.watch({ operationType: 'update' }, { fullDocument: 'default' })

C. db.messages.watch([{ $match: { operationType: 'update' } }], { fullDocument: 'default' })

D. db.messages.watch([{ $match: { operationType: 'update' } }], { fullDocument: 'updateLookup' })

Solution

1. Step 1: Filter for update operations

   Use a pipeline with $match to watch only update operation types.

2. Step 2: Get full updated document

   Set fullDocument option to 'updateLookup' to receive the full document on update.

3. Step 3: Verify correct syntax

   Pass the pipeline array as first argument and options object as second argument to watch.

4. Final Answer:

   db.messages.watch([{ $match: { operationType: 'update' } }], { fullDocument: 'updateLookup' }) -> Option D

5. Quick Check:

   Pipeline filter + fullDocument 'updateLookup' = db.messages.watch([{ $match: { operationType: 'update' } }], { fullDocument: 'updateLookup' }) [OK]

Hint: Use $match pipeline and fullDocument: 'updateLookup' option [OK]

Common Mistakes:

• Passing options as first argument instead of second
• Using fullDocument: 'default' which doesn't guarantee full doc on update
• Not filtering operationType in pipeline