$out and $merge for writing results in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the $out stage do in a MongoDB aggregation pipeline?

The $out stage writes the results of the aggregation pipeline to a specified collection, replacing the existing data in that collection.

intermediate

How does $merge differ from $out in MongoDB?

$merge writes results to a collection but can merge with existing documents based on a specified key, allowing updates or inserts without replacing the whole collection.

intermediate

Can $out be used to write results to a different database than the source?

Yes, $out can write to a collection in a different database by specifying the database name along with the collection name.

beginner

What happens if the target collection does not exist when using $merge?

If the target collection does not exist, $merge creates it and inserts the aggregation results.

intermediate

Which stage would you use to update existing documents based on a matching field during aggregation: $out or $merge?

You would use $merge because it supports updating existing documents based on a matching field, while $out replaces the entire collection.

What does the $out stage do in MongoDB aggregation?

A Filters documents based on a condition

B Merges results with existing documents

C Writes aggregation results to a collection, replacing it

D Sorts documents in the pipeline

$out writes the aggregation results to a collection and replaces the existing data.

Which stage allows updating existing documents during aggregation?

A <code>$merge</code>

B <code>$out</code>

C <code>$match</code>

D <code>$group</code>

$merge can update existing documents based on a matching key.

If you want to write aggregation results to a new database, which stage can you use?

A <code>$merge</code> only

B <code>$out</code> only

C Both <code>$out</code> and <code>$merge</code>

D Neither <code>$out</code> nor <code>$merge</code>

$out supports writing to a collection in a different database by specifying the database name.

What happens if the target collection does not exist when using $merge?

A The collection is created and results are inserted

B Existing collection is dropped

C The pipeline stops without writing

D The operation fails

$merge creates the target collection if it does not exist.

Which stage replaces the entire target collection with aggregation results?

A <code>$lookup</code>

B <code>$merge</code>

C <code>$project</code>

D <code>$out</code>

$out replaces the entire target collection with the aggregation output.

Explain the main differences between $out and $merge stages in MongoDB aggregation.

Think about how each stage handles existing data in the target collection.

Describe a scenario where using $merge is better than $out.

Consider when you want to keep some existing data and only update parts.

Practice

1. What is the main difference between the $out and $merge stages in MongoDB aggregation?

easy

A. $out updates documents, and $merge deletes the target collection.

B. $out only works with sharded clusters, $merge does not.

C. $out replaces the entire target collection, while $merge updates or inserts documents based on matching keys.

D. $out appends documents without replacing, $merge replaces the collection.

Solution

1. Step 1: Understand $out behavior

   $out writes aggregation results by replacing the entire target collection with new data.

2. Step 2: Understand $merge behavior

   $merge writes results by updating existing documents or inserting new ones based on matching keys, preserving unmatched documents.

3. Final Answer:

   $out replaces collection; $merge updates/inserts by keys -> Option C

4. Quick Check:

   $out replaces, $merge merges [OK]

Hint: Remember: $out replaces, $merge merges by keys [OK]

Common Mistakes:

• Thinking $out appends data instead of replacing
• Confusing $merge with deleting collections
• Assuming $merge always replaces entire collection

2. Which of the following is the correct syntax to use $out in a MongoDB aggregation pipeline?

easy

A. { $out: "targetCollection" }

B. { $out: { collection: "targetCollection" } }

C. { $out: ["targetCollection"] }

D. { $out: { db: "targetDB" } }

Solution

1. Step 1: Recall $out syntax

   The $out stage requires the target collection name as a string directly, like { $out: "collectionName" }.

2. Step 2: Check options

   { $out: "targetCollection" } matches the correct syntax. The other options use incorrect formats such as extra objects or arrays.

3. Final Answer:

   { $out: "targetCollection" } -> Option A

4. Quick Check:

   $out needs collection name string [OK]

Hint: Use simple string for collection name in $out [OK]

Common Mistakes:

• Using object or array instead of string for collection name
• Trying to specify database inside $out stage
• Adding extra braces or brackets around collection name

3. Given the aggregation pipeline below, what will be the result in the summary collection after running it?

db.sales.aggregate([
  { $group: { _id: "$category", total: { $sum: "$amount" } } },
  { $merge: { into: "summary", on: "_id", whenMatched: "replace", whenNotMatched: "insert" } }
])

medium

A. The summary collection will remain unchanged.

B. The summary collection will be completely replaced with the aggregation results.

C. The aggregation will fail due to missing $out stage.

D. The summary collection will contain documents with total sales per category, replacing existing matching documents.

Solution

1. Step 1: Understand the $group stage

   This groups sales by category and sums amounts, producing documents like { _id: category, total: sum }.

2. Step 2: Understand the $merge stage

   $merge writes results into summary collection, replacing documents with matching _id or inserting new ones.

3. Final Answer:

   summary collection updated with total sales per category, replacing matches -> Option D

4. Quick Check:

   $merge updates or inserts by key [OK]

Hint: Remember $merge updates matching keys, inserts new [OK]

Common Mistakes:

• Thinking $merge replaces entire collection like $out
• Assuming aggregation fails without $out
• Believing collection stays unchanged after $merge

4. You run this aggregation pipeline but get an error:

db.orders.aggregate([
  { $match: { status: "shipped" } },
  { $out: { collection: "shippedOrders" } }
])

What is the likely cause of the error?

medium

A. You cannot use $out after $match stage.

B. The $out stage syntax is incorrect; it should be a string, not an object.

C. The $match stage is invalid and causes the error.

D. The target collection shippedOrders does not exist.

Solution

1. Step 1: Check $out syntax

   $out requires the target collection name as a string, not an object with a collection field.

2. Step 2: Analyze error cause

   Using { collection: "shippedOrders" } causes syntax error; correct usage is { $out: "shippedOrders" }.

3. Final Answer:

   Incorrect $out syntax using object instead of string -> Option B

4. Quick Check:

   $out needs string collection name [OK]

Hint: Use string for $out target, not object [OK]

Common Mistakes:

• Assuming $match causes error
• Thinking $out requires existing collection
• Believing $out cannot follow $match

5. You want to aggregate user activity data and save results into a collection named userStats. You want to update existing documents by userId and insert new ones if missing, but keep other fields unchanged when matched. Which $merge option should you use?

hard

A. { into: "userStats", on: "userId", whenMatched: "merge", whenNotMatched: "insert" }

B. { into: "userStats", on: "userId", whenMatched: "replace", whenNotMatched: "insert" }

C. { into: "userStats", on: "userId", whenMatched: "fail", whenNotMatched: "insert" }

D. { into: "userStats", on: "userId", whenMatched: "keepExisting", whenNotMatched: "discard" }

Solution

1. Step 1: Understand whenMatched options

   whenMatched: "merge" updates only specified fields, keeping others unchanged; replace overwrites entire document.

2. Step 2: Choose correct $merge options

   To update existing documents by userId and insert new ones, use whenMatched: "merge" and whenNotMatched: "insert".

3. Final Answer:

   { into: "userStats", on: "userId", whenMatched: "merge", whenNotMatched: "insert" } -> Option A

4. Quick Check:

   whenMatched: "merge" updates fields, inserts new [OK]

Hint: Use whenMatched: "merge" to update fields, not replace [OK]

Common Mistakes:

• Using replace which overwrites entire documents
• Choosing fail which errors on matches
• Using invalid whenNotMatched options