Why modeling decisions matter in MongoDB - See It in Action

Why Modeling Decisions Matter in MongoDB

📖 Scenario: You are working for a small online bookstore. You want to store information about books and their authors in a MongoDB database. How you decide to organize this data affects how easy it is to find and update information later.

🎯 Goal: Build a simple MongoDB collection that shows two different ways to model books and authors: embedding author details inside each book document, and referencing authors in a separate collection. This will help you understand why modeling decisions matter.

📋 What You'll Learn

Create a books collection with embedded author details.

Create an authors collection with author documents.

Create a books_ref collection where each book references an author by author_id.

Write queries to find books with embedded authors and books with referenced authors.

💡 Why This Matters

🌍 Real World

Choosing how to model data in MongoDB is important for building efficient and maintainable applications like online stores, blogs, or social networks.

💼 Career

Understanding data modeling helps database developers and backend engineers design databases that perform well and are easy to work with.

1

Create the books collection with embedded author details

Create a MongoDB collection called books and insert two documents. Each document should have the fields title and author. The author field should be an embedded document with name and birth_year. Use these exact entries: { title: "The Great Gatsby", author: { name: "F. Scott Fitzgerald", birth_year: 1896 } } and { title: "1984", author: { name: "George Orwell", birth_year: 1903 } }.

MongoDB

// Insert two books with embedded author details into the books collection
// Your code here

Hint

Use db.books.insertMany() with an array of documents. Each document should have title and an embedded author document.

2

Create the authors collection with separate author documents

Create a MongoDB collection called authors and insert two documents. Each document should have the fields _id, name, and birth_year. Use these exact entries: { _id: 1, name: "F. Scott Fitzgerald", birth_year: 1896 } and { _id: 2, name: "George Orwell", birth_year: 1903 }.

MongoDB

db.books.insertMany([
  { title: "The Great Gatsby", author: { name: "F. Scott Fitzgerald", birth_year: 1896 } },
  { title: "1984", author: { name: "George Orwell", birth_year: 1903 } }
])
// Insert authors into the authors collection
// Your code here

Hint

Use db.authors.insertMany() with an array of author documents. Each must have an _id field.

3

Create the books_ref collection with author references

Create a MongoDB collection called books_ref and insert two documents. Each document should have the fields title and author_id. Use these exact entries: { title: "The Great Gatsby", author_id: 1 } and { title: "1984", author_id: 2 }.

MongoDB

db.books.insertMany([
  { title: "The Great Gatsby", author: { name: "F. Scott Fitzgerald", birth_year: 1896 } },
  { title: "1984", author: { name: "George Orwell", birth_year: 1903 } }
])
db.authors.insertMany([
  { _id: 1, name: "F. Scott Fitzgerald", birth_year: 1896 },
  { _id: 2, name: "George Orwell", birth_year: 1903 }
])
// Insert books with author references into books_ref collection
// Your code here

Hint

Use db.books_ref.insertMany() with documents that have title and author_id fields.

4

Query books with embedded authors and referenced authors

Write two queries: one to find all books in the books collection showing embedded author details, and one to find all books in the books_ref collection joined with author details from the authors collection using $lookup. Assign the results to variables embeddedBooks and referencedBooks respectively.

MongoDB

db.books.insertMany([
  { title: "The Great Gatsby", author: { name: "F. Scott Fitzgerald", birth_year: 1896 } },
  { title: "1984", author: { name: "George Orwell", birth_year: 1903 } }
])
db.authors.insertMany([
  { _id: 1, name: "F. Scott Fitzgerald", birth_year: 1896 },
  { _id: 2, name: "George Orwell", birth_year: 1903 }
])
db.books_ref.insertMany([
  { title: "The Great Gatsby", author_id: 1 },
  { title: "1984", author_id: 2 }
])
// Query embedded books
const embeddedBooks = db.books.find().toArray()
// Query referenced books with author details
const referencedBooks = db.books_ref.aggregate([
  { $lookup: {
      from: "authors",
      localField: "author_id",
      foreignField: "_id",
      as: "author"
  } },
  { $unwind: "$author" }
]).toArray()

Hint

Use db.books.find().toArray() to get embedded books. Use db.books_ref.aggregate() with $lookup and $unwind to join authors.

Practice

1. Why is choosing the right data model important in MongoDB?

easy

A. It decides the font used in the database shell

B. It changes the color of the database interface

C. It affects how fast and easy your app can access data

D. It controls the network speed of your internet

Solution

1. Step 1: Understand data model impact

   The data model determines how data is stored and accessed, affecting speed and ease of use.

2. Step 2: Eliminate unrelated options

   Options about colors, fonts, or internet speed do not relate to data modeling.

3. Final Answer:

   It affects how fast and easy your app can access data -> Option C

4. Quick Check:

   Data model affects app speed and ease [OK]

Hint: Data model = app speed and ease [OK]

Common Mistakes:

• Confusing UI features with data modeling
• Thinking data model affects internet speed
• Ignoring performance impact of modeling

2. Which of the following is the correct way to embed an address inside a user document in MongoDB?

easy

A. { name: 'Alice', address: { city: 'NY', zip: '10001' } }

B. { name: 'Alice', address: ['NY', '10001'] }

C. { name: 'Alice', address: 'NY, 10001' }

D. { name: 'Alice', address: ObjectId('abc123') }

Solution

1. Step 1: Identify embedding format

   Embedding means placing a sub-document inside the main document as a nested object.

2. Step 2: Check options for nested object

   { name: 'Alice', address: { city: 'NY', zip: '10001' } } uses a nested object for address, which is correct embedding syntax.

3. Final Answer:

   { name: 'Alice', address: { city: 'NY', zip: '10001' } } -> Option A

4. Quick Check:

   Embedding uses nested objects [OK]

Hint: Embed with nested objects, not arrays or strings [OK]

Common Mistakes:

• Using array instead of object for embedding
• Storing address as a plain string
• Referencing with ObjectId instead of embedding

3. Given the following MongoDB documents, what will be the result of querying for users with embedded orders having product 'Book'?

{ _id: 1, name: 'John', orders: [{ product: 'Book', qty: 2 }, { product: 'Pen', qty: 5 }] }

{ _id: 2, name: 'Jane', orders: [{ product: 'Notebook', qty: 1 }] }

db.users.find({ 'orders.product': 'Book' })

medium

A. [{ _id: 1, name: 'John', orders: [...] }]

B. [{ _id: 2, name: 'Jane', orders: [...] }]

C. []

D. Error: Invalid query

Solution

1. Step 1: Understand query condition

   The query looks for documents where any order's product is 'Book'.

2. Step 2: Match documents with 'Book' product

   Only John has an order with product 'Book', so only his document matches.

3. Final Answer:

   [{ _id: 1, name: 'John', orders: [...] }] -> Option A

4. Quick Check:

   Query matches embedded product 'Book' [OK]

Hint: Query embedded fields with dot notation [OK]

Common Mistakes:

• Assuming query matches documents without 'Book'
• Expecting syntax error from dot notation
• Confusing array matching with string matching

4. You have a user document with an embedded array of comments. You try to update a comment's text but the update does not work. Which is the likely error?

db.users.updateOne(
  { _id: 1, comments.id: 5 },
  { $set: { 'comments.text': 'Updated' } }
)

medium

A. Using updateOne instead of updateMany

B. Syntax error in query filter

C. Incorrect collection name

D. Missing $ positional operator to target the correct array element

Solution

1. Step 1: Analyze update query

   The filter matches the comment with id 5, but the update sets 'comments.text' without specifying which array element.

2. Step 2: Identify missing positional operator

   To update a specific array element, the $ positional operator is needed in the update path: 'comments.$.text'.

3. Final Answer:

   Missing $ positional operator to target the correct array element -> Option D

4. Quick Check:

   Use $ to update matched array element [OK]

Hint: Use $ to update specific array item [OK]

Common Mistakes:

• Forgetting $ in update path for arrays
• Changing updateOne to updateMany unnecessarily
• Assuming collection name or filter syntax is wrong

5. You want to model a blog app where each post has many comments. Comments can be very large and users often read posts without comments. Which modeling choice is best and why?

hard

A. Embed comments inside posts to get all data in one query

B. Store comments in a separate collection and reference posts to avoid large post documents

C. Store comments as strings inside posts to save space

D. Duplicate comments in both posts and a separate collection

Solution

1. Step 1: Analyze data size and access pattern

   Comments are large and often not needed when reading posts, so embedding would make posts heavy.

2. Step 2: Choose referencing for efficiency

   Referencing comments separately keeps post documents small and loads comments only when needed.

3. Final Answer:

   Store comments in a separate collection and reference posts to avoid large post documents -> Option B

4. Quick Check:

   Large optional data = use referencing [OK]

Hint: Large optional data? Use referencing [OK]

Common Mistakes:

• Embedding large optional data causing slow reads
• Storing comments as strings losing structure
• Duplicating data causing inconsistency