Rows vs documents thinking in MongoDB

Introduction

Understanding the difference between rows and documents helps you organize data the right way. It makes working with databases easier and faster.

When deciding how to store customer information in a database.

When choosing between a table in SQL or a collection in MongoDB.

When designing a database for an app that needs flexible data.

When you want to know how to retrieve data efficiently.

When you need to update or add data without breaking existing structure.

Syntax

MongoDB

SQL row example:
(id, name, age)
(1, 'Alice', 30)

MongoDB document example:
{
  _id: ObjectId(...),
  name: 'Alice',
  age: 30
}

Rows are used in SQL databases and look like simple tables with columns and rows.

Documents are used in MongoDB and store data as flexible JSON-like objects.

Examples

This gets the row where the user's id is 1.

MongoDB

SQL row:
SELECT * FROM users WHERE id = 1;

This finds one document by its unique ID.

MongoDB

MongoDB document:
db.users.findOne({ _id: ObjectId('507f1f77bcf86cd799439011') });

Adds a new row to the users table.

MongoDB

SQL row insert:
INSERT INTO users (id, name, age) VALUES (2, 'Bob', 25);

Adds a new document to the users collection.

MongoDB

MongoDB document insert:
db.users.insertOne({ name: 'Bob', age: 25 });

Sample Program

This example shows how to add a document with flexible fields and then find it by name.

MongoDB

use testdb;

// Insert a document in MongoDB
 db.users.insertOne({ name: 'Alice', age: 30, hobbies: ['reading', 'hiking'] });

// Find the document
 db.users.find({ name: 'Alice' }).pretty();

Important Notes

Rows have fixed columns; documents can have different fields in each record.

Documents store related data together, which can reduce the need for joins.

Think of rows like spreadsheet rows, and documents like folders with files inside.

Summary

Rows are simple and fixed; documents are flexible and nested.

Use rows for structured, uniform data; use documents for varied, complex data.

Understanding this helps you pick the right database and design your data well.

Practice

1. Which statement best describes the difference between rows in SQL and documents in MongoDB?

easy

A. Rows are flexible and can change structure easily; documents are rigid.

B. Rows can store nested data; documents only store flat data.

C. Rows have fixed columns; documents can have varied fields and nested data.

D. Rows and documents are exactly the same in structure and use.

Solution

1. Step 1: Understand row structure in SQL

   Rows have fixed columns defined by the table schema, so each row has the same fields.

2. Step 2: Understand document structure in MongoDB

   Documents can have different fields and nested objects, allowing flexible and varied data.

3. Final Answer:

   Rows have fixed columns; documents can have varied fields and nested data. -> Option C

4. Quick Check:

   Rows = fixed, Documents = flexible [OK]

Hint: Rows = fixed columns, documents = flexible fields [OK]

Common Mistakes:

• Thinking documents must have same fields like rows
• Assuming rows can store nested data easily
• Confusing flexibility of documents with rows

2. Which of the following is the correct way to insert a document with nested fields in MongoDB?

easy

A. db.collection.insertOne({name: 'Alice', address: {city: 'NY', zip: 10001}})

B. INSERT INTO collection VALUES ('Alice', {city: 'NY', zip: 10001})

C. db.collection.insertOne(name: 'Alice', address: 'NY')

D. INSERT document {name: 'Alice', address: {city: 'NY', zip: 10001}}

Solution

1. Step 1: Identify MongoDB insert syntax

   MongoDB uses db.collection.insertOne() with a JSON-like document as argument.

2. Step 2: Check nested field format

   Nested fields are represented as nested objects inside the document, like address: {city: 'NY', zip: 10001}.

3. Final Answer:

   db.collection.insertOne({name: 'Alice', address: {city: 'NY', zip: 10001}}) -> Option A

4. Quick Check:

   Correct MongoDB insert with nested document [OK]

Hint: Use insertOne() with nested JSON object for documents [OK]

Common Mistakes:

• Using SQL INSERT syntax in MongoDB
• Passing fields outside an object
• Not using curly braces for nested fields

3. Given the collection users with documents like {name: 'Bob', scores: [10, 20, 30]}, what will db.users.find({scores: 20}) return?

medium

A. All documents where scores array contains 20

B. Documents where scores equals exactly 20

C. Documents where scores is missing

D. Syntax error because scores is an array

Solution

1. Step 1: Understand MongoDB query on array fields

   Querying {scores: 20} matches documents where the array 'scores' contains the value 20.

2. Step 2: Apply to example document

   Document with scores: [10, 20, 30] contains 20, so it matches and will be returned.

3. Final Answer:

   All documents where scores array contains 20 -> Option A

4. Quick Check:

   Query matches array elements [OK]

Hint: Querying array field matches if any element equals value [OK]

Common Mistakes:

• Thinking query matches whole array exactly
• Expecting syntax error for array query
• Confusing missing field with array content

4. You run this MongoDB query: db.orders.find({items: {product: 'Book'}}) but get no results. What is the likely problem?

medium

A. The field name 'product' is misspelled.

B. The query expects items to be an object, but items is an array of objects.

C. MongoDB does not support querying nested fields.

D. The collection name 'orders' is incorrect.

Solution

1. Step 1: Analyze query structure

   The query matches documents where 'items' exactly equals {product: 'Book'}.

2. Step 2: Understand data structure

   If 'items' is an array of objects, the query must use dot notation or $elemMatch to match inside array elements.

3. Final Answer:

   The query expects items to be an object, but items is an array of objects. -> Option B

4. Quick Check:

   Querying array needs $elemMatch or dot notation [OK]

Hint: Use $elemMatch or dot notation to query inside arrays [OK]

Common Mistakes:

• Querying array field as if it was a single object
• Assuming MongoDB can't query nested fields
• Ignoring data structure of the field

5. You want to store customer orders where each order can have multiple items with different quantities and prices. Which data model fits best in MongoDB?

hard

A. One document per item, with order info duplicated in each document.

B. Separate collections for orders and items, no embedding.

C. One flat table with one row per item, no nesting.

D. One document per order, with an array of item objects inside each document.

Solution

1. Step 1: Understand MongoDB document flexibility

   MongoDB documents can embed arrays of objects, ideal for storing multiple items inside one order document.

2. Step 2: Compare options for data modeling

   Embedding items inside order documents keeps related data together and fits MongoDB's document model better than duplication or flat tables.

3. Final Answer:

   One document per order, with an array of item objects inside each document. -> Option D

4. Quick Check:

   Embed related data in arrays for flexible documents [OK]

Hint: Embed related items as arrays inside order documents [OK]

Common Mistakes:

• Duplicating order info in many documents
• Using flat tables like SQL in MongoDB
• Splitting related data unnecessarily