Rows vs documents thinking in MongoDB - Visual Side-by-Side Comparison

Concept Flow - Rows vs documents thinking

Start: Data to store

↓

Choose storage style

↓

Rows

↓

Table

↓

Fixed columns

↓

Each row = 1 record

↓

Query data accordingly

This flow shows how data can be stored as rows in tables or as documents in collections, highlighting the difference in structure and flexibility.

Execution Sample

MongoDB

db.users.insertOne({name: "Alice", age: 30, hobbies: ["reading", "hiking"]})
db.users.find({name: "Alice"})

Insert a document with flexible fields into a MongoDB collection and then query it by name.

Execution Table

Step	Action	Data State	Result
1	Insert document {name: 'Alice', age: 30, hobbies: ['reading', 'hiking']}	Collection empty	Document added as one record
2	Query documents where name = 'Alice'	Collection has 1 document	Returns the inserted document
3	Insert document {name: 'Bob', age: 25}	Collection has 1 document	Document added, no hobbies field needed
4	Query all documents	Collection has 2 documents	Returns both documents with their fields
5	Attempt to query by hobbies	Collection has 2 documents	Returns only documents with hobbies field
6	End	No further actions	Execution stops

💡 No more queries or inserts; demonstration complete

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
Collection 'users'	empty	[{name: 'Alice', age: 30, hobbies: ['reading', 'hiking']}]	[{name: 'Alice', age: 30, hobbies: ['reading', 'hiking']}, {name: 'Bob', age: 25}]	same

Key Moments - 2 Insights

Why can documents have different fields while rows cannot?

Documents in MongoDB are flexible and can have different fields per record, as shown in steps 1 and 3 where 'hobbies' is present only in Alice's document. Rows in tables require fixed columns for all records.

What happens when you query a field that some documents don't have?

As in step 5, querying by 'hobbies' returns only documents that have that field. Documents without it are excluded, unlike rows where all columns exist for every row.

Visual Quiz - 3 Questions

Look at the execution table, what is the state of the collection after step 3?

A Empty collection

B Contains one document with name 'Alice' only

C Contains two documents: one for 'Alice' and one for 'Bob'

D Contains one document with name 'Bob' only

💡 Hint

Check the 'Data State' column in row for step 3 in the execution table

At which step does the query return only documents that have the 'hobbies' field?

A Step 5

B Step 2

C Step 4

D Step 1

💡 Hint

Look at the 'Result' column for step 5 in the execution table

If we added a new document with an extra field 'email', how would the collection state change?

A All documents would have the 'email' field added

B Only the new document would have the 'email' field

C The collection would reject the new document

D The 'email' field would replace 'hobbies' in all documents

💡 Hint

Recall that MongoDB documents can have flexible fields as shown in steps 1 and 3

Concept Snapshot

Rows vs Documents Thinking:
- Rows: fixed columns, each row same structure
- Documents: flexible fields, each document can differ
- Rows stored in tables; documents in collections
- Query returns full rows or matching documents
- Documents allow nested data and arrays
- Choose based on data flexibility needs

Full Transcript

This visual execution shows how data storage differs between rows and documents. Rows are fixed in structure, stored in tables, where each row has the same columns. Documents, like in MongoDB, are flexible and stored in collections. Each document can have different fields, including nested arrays. The example inserts documents with different fields and queries them, showing how queries return only matching documents. This helps understand why documents are more flexible than rows and how queries behave differently.

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