skip method for offset in MongoDB - Step-by-Step Execution

Concept Flow - skip method for offset

Start Query

↓

Apply Filter

↓

Sort Documents

↓

Skip N Documents

↓

Return Remaining Documents

↓

End

The skip method tells MongoDB to ignore a number of documents at the start of the result, then return the rest.

Execution Sample

MongoDB

db.collection.find().sort({age: 1}).skip(3).limit(2)

This query sorts documents by age ascending, skips the first 3, then returns the next 2 documents.

Execution Table

Step	Action	Documents Before	Documents After	Notes
1	Start with all documents	[{age: 20}, {age: 25}, {age: 30}, {age: 35}, {age: 40}]	[{age: 20}, {age: 25}, {age: 30}, {age: 35}, {age: 40}]	Initial collection
2	Sort by age ascending	[{age: 20}, {age: 25}, {age: 30}, {age: 35}, {age: 40}]	[{age: 20}, {age: 25}, {age: 30}, {age: 35}, {age: 40}]	Already sorted in this example
3	Skip first 3 documents	[{age: 20}, {age: 25}, {age: 30}, {age: 35}, {age: 40}]	[{age: 35}, {age: 40}]	Documents with age 20, 25, 30 skipped
4	Limit to 2 documents	[{age: 35}, {age: 40}]	[{age: 35}, {age: 40}]	Only 2 documents returned
5	End	[{age: 35}, {age: 40}]	[{age: 35}, {age: 40}]	Query complete

💡 After skipping 3 documents, only documents from index 3 onward are returned, limited to 2.

Variable Tracker

Variable	Start	After Sort	After Skip	After Limit	Final
documents	[{age: 20}, {age: 25}, {age: 30}, {age: 35}, {age: 40}]	[{age: 20}, {age: 25}, {age: 30}, {age: 35}, {age: 40}]	[{age: 35}, {age: 40}]	[{age: 35}, {age: 40}]	[{age: 35}, {age: 40}]

Key Moments - 3 Insights

Why does skip(3) remove the first three documents instead of the last three?

skip(3) tells MongoDB to ignore the first 3 documents in the sorted list, so it removes documents at the start, not the end. See execution_table row 3 where the first three documents are skipped.

What happens if skip number is larger than total documents?

If skip is larger than the number of documents, no documents remain to return. The result will be empty. This is because all documents are skipped.

Does skip change the order of documents?

No, skip only removes documents from the start after sorting. The order of remaining documents stays the same. See execution_table rows 2 and 3.

Visual Quiz - 3 Questions

Look at the execution_table, what documents remain after the skip step (Step 3)?

A [{age: 20}, {age: 25}, {age: 30}]

B [{age: 35}, {age: 40}]

C [{age: 25}, {age: 30}, {age: 35}]

D [{age: 20}, {age: 25}, {age: 30}, {age: 35}, {age: 40}]

💡 Hint

Check the 'Documents After' column at Step 3 in the execution_table.

At which step does the query limit the number of documents returned?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for the action 'Limit to 2 documents' in the execution_table.

If skip(0) was used instead of skip(3), how would the documents after skip change at Step 3?

A All documents would remain, same as before skip

B Only first 3 documents would remain

C No documents would remain

D Only last 2 documents would remain

💡 Hint

skip(0) means skip zero documents, so no documents are removed at Step 3.

Concept Snapshot

skip(n) in MongoDB skips the first n documents in the query result.
Use it after sorting to offset results.
Commonly combined with limit() to paginate.
If n is larger than total docs, result is empty.
Order of remaining docs stays unchanged.

Full Transcript

The skip method in MongoDB is used to ignore a number of documents at the start of the query result. First, the query finds all documents and applies any filters. Then it sorts the documents if specified. After sorting, skip(n) removes the first n documents from the result. The remaining documents are returned, often limited by limit(). For example, if we have documents with ages 20, 25, 30, 35, and 40, and we skip 3, the first three documents (ages 20, 25, 30) are ignored. The query then returns documents starting from age 35 onward. This is useful for pagination to show results starting from a certain offset. If skip is zero, no documents are skipped. If skip is larger than the number of documents, the result is empty. The order of documents after skipping remains the same as after sorting.

Practice

1. What does the skip() method do in MongoDB queries?

easy

A. It limits the number of documents returned.

B. It skips a specified number of documents from the start of the result set.

C. It sorts the documents in ascending order.

D. It deletes documents from the collection.

Solution

1. Step 1: Understand the purpose of skip()

   The skip() method is used to ignore a certain number of documents from the beginning of the query result.

2. Step 2: Differentiate from other methods

   Unlike limit() which restricts the number of documents returned, skip() just moves the starting point forward.

3. Final Answer:

   It skips a specified number of documents from the start of the result set. -> Option B

4. Quick Check:

   skip() = skip documents [OK]

Hint: Remember: skip moves start point, limit controls count [OK]

Common Mistakes:

• Confusing skip with limit
• Thinking skip sorts documents
• Assuming skip deletes documents

2. Which of the following is the correct syntax to skip 5 documents in a MongoDB query on collection users?

easy

A. db.users.find().skip(5)

B. db.users.skip(5).find()

C. db.users.find().limit(5)

D. db.users.find().offset(5)

Solution

1. Step 1: Recall correct method chaining

   In MongoDB, skip() is chained after find() to skip documents.

2. Step 2: Check each option

   db.users.find().skip(5) uses find().skip(5) which is correct syntax. db.users.skip(5).find() incorrectly places skip() before find(). db.users.find().limit(5) uses limit() which limits results, not skips. db.users.find().offset(5) uses offset() which is not a MongoDB method.

3. Final Answer:

   db.users.find().skip(5) -> Option A

4. Quick Check:

   Correct chaining = find().skip() [OK]

Hint: Always chain skip() after find() in MongoDB [OK]

Common Mistakes:

• Using skip() before find()
• Confusing skip() with limit()
• Using offset() which is invalid

3. Given the collection products with documents [{"name": "A"}, {"name": "B"}, {"name": "C"}, {"name": "D"}], what will db.products.find().skip(2).limit(2).toArray() return?

medium

A. [{"name": "A"}, {"name": "B"}]

B. [{"name": "B"}, {"name": "C"}]

C. [{"name": "D"}]

D. [{"name": "C"}, {"name": "D"}]

Solution

1. Step 1: Understand skip and limit effect

   skip(2) ignores the first two documents: "A" and "B". Then limit(2) returns the next two documents.

2. Step 2: Identify returned documents

   After skipping "A" and "B", the next two are "C" and "D". So the result is [{"name": "C"}, {"name": "D"}].

3. Final Answer:

   [{"name": "C"}, {"name": "D"}] -> Option D

4. Quick Check:

   skip 2 + limit 2 = next 2 docs [OK]

Hint: Skip removes first N, limit picks next M [OK]

Common Mistakes:

• Forgetting skip removes documents
• Mixing order of skip and limit
• Assuming skip returns skipped docs

4. You wrote db.orders.skip(3).find() to skip 3 documents but it throws an error. What is the problem?

medium

A. The skip() method must be called after find().

B. The skip() method does not exist in MongoDB.

C. You must use limit() before skip().

D. The number inside skip() must be a string.

Solution

1. Step 1: Check method order in MongoDB queries

   In MongoDB, skip() is a cursor method and must be chained after find(), not before.

2. Step 2: Identify the error cause

   Calling skip() before find() causes a syntax error because skip() is not a collection method.

3. Final Answer:

   The skip() method must be called after find(). -> Option A

4. Quick Check:

   Correct chaining order = find().skip() [OK]

Hint: Always call skip() after find() to avoid errors [OK]

Common Mistakes:

• Calling skip() before find()
• Using string instead of number in skip()
• Thinking skip() requires limit() first

5. You want to display page 3 of a product list with 10 items per page using MongoDB. Which query correctly skips the right number of documents?

hard

A. db.products.find().skip(10).limit(3)

B. db.products.find().skip(30).limit(10)

C. db.products.find().skip(20).limit(10)

D. db.products.find().limit(10).skip(20)

Solution

1. Step 1: Calculate skip value for page 3

   Each page shows 10 items. Page 1 skips 0, page 2 skips 10, so page 3 skips 20 documents (2 pages x 10 items).

2. Step 2: Verify query correctness

   db.products.find().skip(20).limit(10) skips 20 and limits to 10, which is correct. db.products.find().skip(30).limit(10) skips 30 which is too many for page 3. db.products.find().skip(10).limit(3) skips 10 but limits to 3 items, wrong limit. db.products.find().limit(10).skip(20) places limit before skip, which limits to first 10 documents then skips 20 from them (impossible), returning empty.

3. Final Answer:

   db.products.find().skip(20).limit(10) -> Option C

4. Quick Check:

   Page 3 skip = (3-1)*10 = 20 [OK]

Hint: Skip = (page-1)*itemsPerPage, then limit itemsPerPage [OK]

Common Mistakes:

• Calculating skip as page*itemsPerPage
• Swapping skip and limit order
• Using wrong limit count