$out and $merge for writing results in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What does this $out stage do?

Consider this aggregation pipeline on a collection named sales:

[{ $match: { status: "completed" } }, { $out: "completed_sales" }]

What is the result after running this pipeline?

MongoDB

[{ $match: { status: "completed" } }, { $out: "completed_sales" }]

A It creates or replaces the collection 'completed_sales' with documents where status is 'completed'.

B It appends documents with status 'completed' to the existing 'completed_sales' collection.

C It updates documents in 'completed_sales' to have status 'completed'.

D It returns documents with status 'completed' without modifying any collection.

💡 Hint

Think about what $out does to the target collection.

The $out stage writes the aggregation results to a specified collection, replacing it if it exists. Here, it creates or replaces 'completed_sales' with only documents where status is 'completed'.

❓ query_result

intermediate

What happens when using $merge with 'whenMatched: replace'?

Given this pipeline:

[{ $match: { category: "books" } }, { $merge: { into: "inventory", on: "_id", whenMatched: "replace", whenNotMatched: "insert" } }]

What is the effect on the 'inventory' collection?

MongoDB

[{ $match: { category: "books" } }, { $merge: { into: "inventory", on: "_id", whenMatched: "replace", whenNotMatched: "insert" } }]

A All documents are appended to 'inventory' without checking _id.

B Documents with matching _id are merged by adding fields; new documents are ignored.

C Documents with matching _id are replaced; new documents are inserted into 'inventory'.

D Documents with matching _id are updated by incrementing fields; new documents are rejected.

💡 Hint

Check the meaning of 'whenMatched: replace' and 'whenNotMatched: insert'.

The $merge stage merges documents into the target collection. With whenMatched: 'replace', matching documents are fully replaced. With whenNotMatched: 'insert', new documents are added.

📝 Syntax

advanced

Which $merge option syntax is invalid?

Identify the option that will cause a syntax error when used in a $merge stage:

MongoDB

{ $merge: { into: "users", on: "userId", whenMatched: "merge", whenNotMatched: "insert" } }

A { $merge: { into: "users", on: ["userId", "email"], whenMatched: "keepExisting", whenNotMatched: "insert" } }

B { $merge: { into: "users", on: "userId", whenMatched: "update", whenNotMatched: "insert" } }

C { $merge: { into: "users", on: "userId", whenMatched: "fail", whenNotMatched: "discard" } }

D { $merge: { into: "users", on: "userId", whenMatched: "merge", whenNotMatched: "insert" } }

💡 Hint

Check the valid values for 'whenMatched'.

The valid whenMatched values are 'replace', 'merge', 'keepExisting', and 'fail'. 'update' is not valid and causes a syntax error.

❓ optimization

advanced

Optimizing $merge for large datasets

You want to merge a large aggregation result into a collection without replacing entire documents, only updating specific fields. Which $merge option is best for this?

A Use 'whenMatched: "merge"' to update only specified fields and 'whenNotMatched: "insert"'.

B Use 'whenMatched: "replace"' to replace entire documents for consistency.

C Use 'whenMatched: "fail"' to avoid any updates and only insert new documents.

D Use 'whenMatched: "keepExisting"' to keep old documents and ignore new data.

💡 Hint

Think about updating only parts of documents efficiently.

whenMatched: 'merge' updates only the fields in the incoming documents, which is efficient for large datasets where full replacement is costly.

🧠 Conceptual

expert

Difference between $out and $merge in concurrency

Which statement best describes the difference between $out and $merge regarding concurrent writes and atomicity?

A Both <code>$out</code> and <code>$merge</code> block all concurrent writes until operation completes.

B <code>$merge</code> atomically replaces the entire target collection; <code>$out</code> merges documents individually allowing concurrent writes.

C Neither <code>$out</code> nor <code>$merge</code> guarantee atomicity or affect concurrent writes.

D <code>$out</code> atomically replaces the entire target collection, blocking concurrent writes; <code>$merge</code> allows concurrent writes by merging documents individually.

💡 Hint

Consider how each stage writes results to the target collection.

$out replaces the entire collection atomically, which blocks concurrent writes during the operation. $merge updates or inserts documents individually, allowing concurrent writes to other documents.