Why document databases over relational in MongoDB - See It in Action

Why Document Databases Over Relational Databases

📖 Scenario: You are working for a small online bookstore. The store wants to keep track of books, authors, and customer reviews. You need to decide how to store this data efficiently.

🎯 Goal: Build a simple document database structure using MongoDB that shows why document databases can be better than relational databases for this use case.

📋 What You'll Learn

Create a collection called books with embedded author and reviews data

Add a configuration variable maxReviews to limit the number of reviews stored

Write a query to find books with more than maxReviews reviews

Add a final index on the title field to speed up searches

💡 Why This Matters

🌍 Real World

Document databases like MongoDB are great for storing complex data with nested structures, such as books with authors and reviews all in one place. This reduces the need for complex joins and makes data retrieval faster and simpler.

💼 Career

Many modern applications use document databases for flexible and scalable data storage. Knowing how to design and query these databases is valuable for backend developers, data engineers, and database administrators.

1

DATA SETUP: Create the books collection with embedded documents

Create a MongoDB collection called books with these exact documents: one book titled 'Learn MongoDB' by author { name: 'Alice', age: 30 } and two reviews { user: 'Bob', rating: 5 } and { user: 'Carol', rating: 4 } embedded inside the book document.

MongoDB

# Your code here to create the books collection with embedded author and reviews

Hint

Use insertOne to add a document with embedded author and reviews arrays.

2

CONFIGURATION: Add a variable to limit reviews

Create a variable called maxReviews and set it to 1 to limit how many reviews you want to consider for filtering.

MongoDB

db.books.insertOne({
  title: 'Learn MongoDB',
  author: { name: 'Alice', age: 30 },
  reviews: [
    { user: 'Bob', rating: 5 },
    { user: 'Carol', rating: 4 }
  ]
})

// Your code here to create maxReviews variable

Hint

Use const maxReviews = 1 to create the variable.

3

CORE LOGIC: Query books with more than maxReviews reviews

Write a MongoDB query using find to get all books where the number of reviews is greater than maxReviews. Use $expr and $gt operators with $size on the reviews array.

MongoDB

db.books.insertOne({
  title: 'Learn MongoDB',
  author: { name: 'Alice', age: 30 },
  reviews: [
    { user: 'Bob', rating: 5 },
    { user: 'Carol', rating: 4 }
  ]
})

const maxReviews = 1;

// Your code here to query books with more than maxReviews reviews

Hint

Use db.books.find({ $expr: { $gt: [ { $size: '$reviews' }, maxReviews ] } }) to filter.

4

COMPLETION: Add an index on the title field

Create an index on the title field in the books collection using createIndex to speed up searches by title.

MongoDB

db.books.insertOne({
  title: 'Learn MongoDB',
  author: { name: 'Alice', age: 30 },
  reviews: [
    { user: 'Bob', rating: 5 },
    { user: 'Carol', rating: 4 }
  ]
})

const maxReviews = 1;

const booksWithManyReviews = db.books.find({
  $expr: { $gt: [ { $size: '$reviews' }, maxReviews ] }
})

// Your code here to create an index on title

Hint

Use db.books.createIndex({ title: 1 }) to create the index.

Practice

1. Why might someone choose a document database like MongoDB over a traditional relational database?

easy

A. Because document databases store data in flexible JSON-like documents that can change structure easily.

B. Because document databases require fixed schemas and strict table relations.

C. Because document databases only work with numeric data.

D. Because document databases do not support indexing.

Solution

1. Step 1: Understand data storage formats

   Document databases store data as JSON-like documents, allowing flexible and dynamic structures.

2. Step 2: Compare with relational databases

   Relational databases require fixed schemas and tables, making changes harder.

3. Final Answer:

   Because document databases store data in flexible JSON-like documents that can change structure easily. -> Option A

4. Quick Check:

   Flexible JSON-like storage [OK]

Hint: Flexible JSON documents mean easier schema changes [OK]

Common Mistakes:

• Thinking document DBs require fixed schemas
• Believing document DBs only handle numbers
• Assuming no indexing in document DBs

2. Which of the following is the correct way to insert a document into a MongoDB collection named users?

easy

A. insert document into users {name: 'Alice', age: 30}

B. INSERT INTO users VALUES ('Alice', 30)

C. db.users.insertOne({name: 'Alice', age: 30})

D. db.users.add({name: 'Alice', age: 30})

Solution

1. Step 1: Recall MongoDB insert syntax

   MongoDB uses insertOne() to add a single document to a collection.

2. Step 2: Check options for correct syntax

   db.users.insertOne({name: 'Alice', age: 30}) uses db.users.insertOne({name: 'Alice', age: 30}), which is correct MongoDB syntax.

3. Final Answer:

   db.users.insertOne({name: 'Alice', age: 30}) -> Option C

4. Quick Check:

   MongoDB insertOne() [OK]

Hint: MongoDB uses insertOne() for single document inserts [OK]

Common Mistakes:

• Using SQL syntax in MongoDB
• Using non-existent methods like add()
• Writing commands as plain English

3. Given the following MongoDB document stored in the products collection:

{ "_id": 1, "name": "Pen", "details": { "color": "blue", "price": 1.5 } }

What will the query db.products.find({"details.color": "blue"}) return?

medium

A. All products with a details field containing color blue.

B. Only products with a top-level field named color equal to blue.

C. An error because nested fields cannot be queried.

D. No results because the query syntax is wrong.

Solution

1. Step 1: Understand dot notation in queries

   MongoDB allows querying nested fields using dot notation like "details.color".

2. Step 2: Analyze the query and document

   The document has a nested field details.color with value "blue", so the query matches this document.

3. Final Answer:

   All products with a details field containing color blue. -> Option A

4. Quick Check:

   Dot notation queries nested fields [OK]

Hint: Use dot notation to query nested document fields [OK]

Common Mistakes:

• Thinking nested fields can't be queried
• Confusing top-level and nested fields
• Assuming query syntax is SQL-like

4. You wrote this MongoDB query to find users aged over 25:

db.users.find({age: > 25})

Why does this query fail and how to fix it?

medium

A. Use SQL syntax: SELECT * FROM users WHERE age > 25.

B. The query is correct; failure is due to missing collection.

C. Replace > with >= for correct MongoDB syntax.

D. The operator > should be inside $gt like {age: {$gt: 25}}.

Solution

1. Step 1: Identify MongoDB comparison operator syntax

   MongoDB uses special operators like $gt for 'greater than' inside query objects.

2. Step 2: Correct the query syntax

   The correct query is {age: {$gt: 25}}, not using > directly.

3. Final Answer:

   The operator > should be inside $gt like {age: {$gt: 25}}. -> Option D

4. Quick Check:

   Use $gt for greater than in MongoDB queries [OK]

Hint: Use $gt, $lt for comparisons, not > or < directly [OK]

Common Mistakes:

• Using > directly in query object
• Mixing SQL syntax with MongoDB
• Assuming >= fixes the error

5. You have a blog application storing posts and comments. Why is a document database better than a relational one for storing posts with many comments?

hard

A. Because relational databases cannot store comments at all.

B. Because you can store each post and its comments together in one document, making reads faster.

C. Because document databases require all comments to be in separate collections.

D. Because relational databases do not support indexing on comments.

Solution

1. Step 1: Understand data embedding in document databases

   Document databases allow embedding related data (like comments) inside a single document (post).

2. Step 2: Compare with relational approach

   Relational databases store posts and comments in separate tables, requiring joins to combine them.

3. Step 3: Benefits of embedding

   Embedding comments inside posts reduces the need for joins and speeds up reading a post with its comments.

4. Final Answer:

   Because you can store each post and its comments together in one document, making reads faster. -> Option B

5. Quick Check:

   Embedding related data = faster reads [OK]

Hint: Embed related data in one document for faster access [OK]

Common Mistakes:

• Thinking relational DBs can't store comments
• Believing comments must be separate collections
• Assuming relational DBs lack indexing