Joins vs embedding decision in MongoDB - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

When to prefer embedding over referencing in MongoDB?

Which scenario best suggests using embedding documents instead of referencing (joins) in MongoDB?

A When data needs to be normalized to avoid duplication.

B When related data is very large and updated independently.

C When related data is frequently accessed together and changes rarely.

D When you want to enforce strict foreign key constraints.

💡 Hint

Think about data locality and update frequency.

Embedding is best when related data is accessed together and changes rarely, improving read performance by avoiding joins.

❓ query_result

intermediate

Output of a $lookup join in MongoDB aggregation

Given two collections, orders and customers, what will be the output of this aggregation?

{
  $lookup: {
    from: "customers",
    localField: "customerId",
    foreignField: "_id",
    as: "customerInfo"
  }
}

MongoDB

db.orders.aggregate([
  {
    $lookup: {
      from: "customers",
      localField: "customerId",
      foreignField: "_id",
      as: "customerInfo"
    }
  }
])

A Each order document will include an array field 'customerInfo' with matching customer documents.

B The query will return only customer documents matching orders.

C The query will fail because $lookup requires a pipeline.

D Each customer document will include an array of orders.

💡 Hint

Recall what $lookup does in aggregation pipelines.

$lookup performs a left outer join, adding an array of matching documents from the 'from' collection to each input document.

📝 Syntax

advanced

Identify the syntax error in this embedding example

Which option contains a syntax error in embedding a subdocument inside a MongoDB insert?

MongoDB

db.products.insertOne({
  name: "Laptop",
  specs: {
    cpu: "Intel i7",
    ram: "16GB",
    storage: "512GB SSD"
  }
})

A db.products.insertOne({ name: "Laptop", specs: { cpu: "Intel i7", ram: "16GB", storage: "512GB SSD" } })

B db.products.insertOne({ name: "Laptop", specs: [ cpu: "Intel i7", ram: "16GB", storage: "512GB SSD" ] })

C )} } "DSS BG215" :egarots ,"BG61" :mar ,"7i letnI" :upc { :sceps ,"potpaL" :eman {(enOtresni.stcudorp.bd

D b.products.insertOne({ name: "Laptop", specs: { cpu: "Intel i7", ram: "16GB", storage: "512GB SSD" } })

💡 Hint

Check the use of brackets for subdocuments.

Option B uses square brackets [] instead of curly braces {} for the embedded document, which is invalid syntax.

❓ optimization

advanced

Optimizing read performance with embedding vs referencing

You have a blog application where each post has many comments. Which data modeling choice optimizes read performance when displaying posts with comments?

A Duplicate comments in both posts and comments collections.

B Store comments in a separate collection and reference post IDs.

C Use a relational database instead of MongoDB.

D Embed all comments inside each post document.

💡 Hint

Consider how many queries are needed to read posts with comments.

Embedding comments inside posts reduces the number of queries needed to fetch all related data, improving read speed.

🔧 Debug

expert

Why does this referencing query return empty arrays?

Given collections users and orders, this aggregation returns empty arrays in the orders field. Why?

db.users.aggregate([
  {
    $lookup: {
      from: "orders",
      localField: "_id",
      foreignField: "userId",
      as: "orders"
    }
  }
])

A The <code>userId</code> field in orders is stored as a string, but <code>_id</code> in users is an ObjectId.

B The <code>from</code> collection name is misspelled.

C MongoDB does not support $lookup on these collections.

D The <code>as</code> field must be a string, not an array.

💡 Hint

Check data types of join fields.

If the join fields have different data types (ObjectId vs string), the join will not match any documents, resulting in empty arrays.