$replaceRoot for restructuring in MongoDB - Mini Project: Build & Apply

$replaceRoot for restructuring documents in MongoDB

📖 Scenario: You work at a company that stores customer orders in a MongoDB collection. Each order document contains a nested customer object with details about the customer. You want to restructure the documents so that the customer details become the top-level fields, replacing the original root document.

🎯 Goal: Build a MongoDB aggregation pipeline that uses $replaceRoot to restructure each order document by replacing the root with the nested customer object.

📋 What You'll Learn

Create a collection named orders with sample documents containing a nested customer field.

Define a variable for the aggregation pipeline.

Use the $replaceRoot stage to replace the root document with the customer object.

Complete the aggregation pipeline to output the restructured documents.

💡 Why This Matters

🌍 Real World

Restructuring nested documents is common when you want to simplify data views or prepare data for reporting and analysis.

💼 Career

Understanding how to use MongoDB aggregation stages like <code>$replaceRoot</code> is valuable for backend developers and data engineers working with NoSQL databases.

1

Create the orders collection with sample documents

Create a variable called orders and assign it an array with two documents. Each document should have an orderId field and a nested customer object. The first document's orderId is 101 and customer has name as "Alice" and city as "New York". The second document's orderId is 102 and customer has name as "Bob" and city as "Los Angeles".

MongoDB

orders = [
    # Your code here
]

Hint

Use a list of dictionaries. Each dictionary has orderId and customer keys. The customer key holds another dictionary with name and city.

2

Define the aggregation pipeline variable

Create a variable called pipeline and assign it an empty array. This will hold the stages of the MongoDB aggregation pipeline.

MongoDB

orders = [
    {"orderId": 101, "customer": {"name": "Alice", "city": "New York"}},
    {"orderId": 102, "customer": {"name": "Bob", "city": "Los Angeles"}}
]

pipeline = [
    # Your code here
]

Hint

Just create an empty list named pipeline to start building the aggregation stages.

3

Add the $replaceRoot stage to the pipeline

Add a dictionary to the pipeline list. This dictionary should have the key $replaceRoot with a value that is another dictionary containing newRoot set to "$customer". This stage will replace the root document with the nested customer object.

MongoDB

orders = [
    {"orderId": 101, "customer": {"name": "Alice", "city": "New York"}},
    {"orderId": 102, "customer": {"name": "Bob", "city": "Los Angeles"}}
]

pipeline = [
    # Your code here
]

Hint

Use {"$replaceRoot": {"newRoot": "$customer"}} as a stage inside the pipeline list.

4

Complete the aggregation pipeline to restructure documents

Add a variable called restructuredOrders and assign it the result of calling db.orders.aggregate(pipeline). This runs the aggregation pipeline on the orders collection to produce documents where the root is replaced by the customer object.

MongoDB

orders = [
    {"orderId": 101, "customer": {"name": "Alice", "city": "New York"}},
    {"orderId": 102, "customer": {"name": "Bob", "city": "Los Angeles"}}
]

pipeline = [
    {"$replaceRoot": {"newRoot": "$customer"}}
]

restructuredOrders = None  # Your code here

Hint

Use db.orders.aggregate(pipeline) to run the pipeline and assign it to restructuredOrders.

Practice

1. What does the $replaceRoot stage do in a MongoDB aggregation pipeline?

easy

A. It groups documents by a specified key.

B. It filters documents based on a condition.

C. It replaces the entire document with the specified embedded document.

D. It sorts documents by a specified field.

Solution

1. Step 1: Understand the purpose of $replaceRoot

   $replaceRoot replaces the whole document with a specified nested document inside it.

2. Step 2: Compare with other stages

   Filtering, sorting, and grouping are done by $match, $sort, and $group respectively, not $replaceRoot.

3. Final Answer:

   It replaces the entire document with the specified embedded document. -> Option C

4. Quick Check:

   $replaceRoot changes document root [OK]

Hint: Remember: $replaceRoot swaps the whole document root [OK]

Common Mistakes:

• Confusing $replaceRoot with filtering or sorting stages
• Thinking it only modifies part of the document
• Assuming it adds fields instead of replacing

2. Which of the following is the correct syntax to use $replaceRoot to replace the root with the details field?

easy

A. { $replaceRoot: { newRoot: "$details" } }

B. { $replaceRoot: { root: "$details" } }

C. { $replaceRoot: { newRoot: details } }

D. { $replaceRoot: { newRoot: "$details" }, $match: {} }

Solution

1. Step 1: Recall correct $replaceRoot syntax

   The correct syntax requires newRoot with a string path starting with "$" to specify the field.

2. Step 2: Analyze options

   { $replaceRoot: { newRoot: "$details" } } uses newRoot: "$details" which is correct. { $replaceRoot: { root: "$details" } } uses wrong key root. { $replaceRoot: { newRoot: details } } misses quotes around field path. { $replaceRoot: { newRoot: "$details" }, $match: {} } adds an unrelated $match inside the same stage, which is invalid.

3. Final Answer:

   { $replaceRoot: { newRoot: "$details" } } -> Option A

4. Quick Check:

   Use newRoot: "$field" syntax [OK]

Hint: Use newRoot: "$fieldName" exactly [OK]

Common Mistakes:

• Omitting quotes around field path
• Using wrong key like 'root' instead of 'newRoot'
• Combining stages incorrectly

3. Given the collection documents:

{ "name": "Alice", "info": { "age": 30, "city": "NY" } }

What will be the output of this aggregation?

[{ $replaceRoot: { newRoot: "$info" } }]

medium

A. [{ "name": "Alice", "info": { "age": 30, "city": "NY" } }]

B. [{ "age": 30, "city": "NY" }]

C. [{ "info": { "age": 30, "city": "NY" } }]

D. [{ "age": 30 }]

Solution

1. Step 1: Understand $replaceRoot effect

   The stage replaces the whole document with the content of the info field.

2. Step 2: Apply to given document

   Original document has info as { "age": 30, "city": "NY" }, so output document is exactly that object.

3. Final Answer:

   [{ "age": 30, "city": "NY" }] -> Option B

4. Quick Check:

   Root replaced by info field content [OK]

Hint: Output matches the nested field content exactly [OK]

Common Mistakes:

• Expecting original fields to remain
• Confusing nested field with root
• Selecting wrong output format

4. You wrote this aggregation but it throws an error:

[{ $replaceRoot: { newRoot: info } }]

What is the error and how to fix it?

medium

A. Missing quotes around field path; fix with newRoot: "$info".

B. Wrong operator; use $setRoot instead of $replaceRoot.

C. Field info does not exist; add it first.

D. Aggregation pipeline must be an object, not an array.

Solution

1. Step 1: Identify syntax error in newRoot value

   The field path must be a string starting with "$" to indicate a field reference.

2. Step 2: Correct the syntax

   Change newRoot: info to newRoot: "$info" to fix the error.

3. Final Answer:

   Missing quotes around field path; fix with newRoot: "$info". -> Option A

4. Quick Check:

   Field paths need quotes and $ prefix [OK]

Hint: Always quote field paths with $ prefix [OK]

Common Mistakes:

• Omitting quotes around field names
• Confusing $replaceRoot with $setRoot
• Misunderstanding pipeline array structure

5. You have documents:

{ "user": { "id": 1, "name": "Bob" }, "score": 50 }

How do you write an aggregation pipeline using $replaceRoot to make the output documents only contain the user fields plus the score field at the root level?

hard

A. [{ $replaceRoot: { newRoot: "$score" } }]

B. [{ $replaceRoot: { newRoot: "$user" } }, { $addFields: { score: "$score" } }]

C. [{ $project: { user: 1, score: 1 } }]

D. [{ $replaceRoot: { newRoot: { $mergeObjects: ["$user", { score: "$score" }] } } }]

Solution

1. Step 1: Understand the goal

   We want to flatten user fields to root and keep score alongside.

2. Step 2: Use $mergeObjects inside $replaceRoot

   $mergeObjects combines user object and { score: "$score" } into one root document.

3. Step 3: Check options

   [{ $replaceRoot: { newRoot: { $mergeObjects: ["$user", { score: "$score" }] } } }] correctly merges and replaces root. [{ $replaceRoot: { newRoot: "$user" } }, { $addFields: { score: "$score" } }] tries to add fields after replacing root, but score is lost after first stage. [{ $project: { user: 1, score: 1 } }] only projects fields, not restructuring. [{ $replaceRoot: { newRoot: "$score" } }] replaces root with score only, losing user.

4. Final Answer:

   [{ $replaceRoot: { newRoot: { $mergeObjects: ["$user", { score: "$score" }] } } }] -> Option D

5. Quick Check:

   Use $mergeObjects to combine fields [OK]

Hint: Combine objects with $mergeObjects inside $replaceRoot [OK]

Common Mistakes:

• Replacing root with only one field losing others
• Trying to add fields after $replaceRoot without preserving data
• Using $project instead of restructuring