Pagination pattern with skip and limit in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What documents are returned by this pagination query?

Given a collection products with documents sorted by price ascending, what documents does this query return?

db.products.find().sort({price: 1}).skip(5).limit(3)

MongoDB

db.products.find().sort({price: 1}).skip(5).limit(3)

A Documents ranked 6th, 7th, and 8th by price ascending

B Documents ranked 3rd, 4th, and 5th by price ascending

C Documents ranked 5th, 6th, and 7th by price ascending

D Documents ranked 1st, 2nd, and 3rd by price ascending

💡 Hint

Remember that skip(n) skips the first n documents after sorting.

The query sorts all documents by price ascending, skips the first 5 documents, then returns the next 3 documents. So it returns documents ranked 6th, 7th, and 8th by price.

🧠 Conceptual

intermediate

Why can using skip with large offsets be inefficient?

In MongoDB pagination, why might using skip with a very large number cause performance issues?

A Because skip causes the database to lock the entire collection

B Because skip automatically sorts the documents again

C Because skip duplicates documents in the result set

D Because MongoDB must scan and discard all skipped documents before returning results

💡 Hint

Think about what the database does internally when skipping documents.

MongoDB still processes all skipped documents internally, which can be slow if the skip number is very large.

📝 Syntax

advanced

Which query correctly paginates documents sorted by date descending?

Choose the correct MongoDB query to get the 3rd page of documents, 10 per page, sorted by date descending.

A db.collection.find().sort({date: -1}).limit(10).skip(20)

B db.collection.find().sort({date: -1}).skip(20).limit(10)

C db.collection.find().sort({date: -1}).skip(10).limit(3)

D db.collection.find().sort({date: 1}).skip(30).limit(10)

💡 Hint

Page 3 with 10 per page means skipping how many documents?

Page 3 means skip 2 pages * 10 = 20 documents, then limit 10. Sorting descending by date is correct with -1.

❓ optimization

advanced

How to optimize pagination for large datasets instead of using skip?

For very large collections, which approach is better than using skip for pagination?

A Use skip with a smaller limit value

B Increase the skip value to a very large number

C Use range queries with a filter on a unique indexed field like _id or date

D Sort documents randomly before paginating

💡 Hint

Think about how to avoid scanning many documents to skip.

Using range queries with a filter on an indexed field allows the database to jump directly to the next page without scanning skipped documents.

🔧 Debug

expert

Why does this pagination query return fewer documents than expected?

A developer runs this query to get page 2 with 5 documents per page:

db.orders.find().skip(5).limit(5)

But the result only contains 5 documents total. Why?

A Because limit is applied before skip, so only the first 5 documents are considered

B Because skip must be called before limit in MongoDB queries

C Because the collection has only 5 documents total

D Because skip(5) removes all documents from the result

💡 Hint

Consider the order in which skip and limit are applied in the query.

In MongoDB, the order of skip and limit matters. Here, limit(5) is applied first, so only 5 documents are fetched, then skip(5) skips all those 5, resulting in zero documents. But MongoDB returns the limit first, so the query returns only 5 documents total.

Practice

1.

What does the skip method do in MongoDB pagination?

easy

A. It limits the number of documents returned.

B. It deletes documents from the collection.

C. It sorts the documents in ascending order.

D. It skips a specified number of documents before returning results.

Solution

1. Step 1: Understand the role of skip

   The skip method tells MongoDB to ignore a certain number of documents from the start of the result set.

2. Step 2: Compare with other methods

   limit controls how many documents to return, not skipping. Sorting and deleting are unrelated to skip.

3. Final Answer:

   It skips a specified number of documents before returning results. -> Option D

4. Quick Check:

   skip = skip documents [OK]

Hint: Skip jumps over documents, limit sets how many to show [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 get the second page of results with 5 documents per page in MongoDB?

db.collection.find().skip(?).limit(?)

easy

A. skip(1).limit(5)

B. skip(10).limit(5)

C. skip(5).limit(5)

D. skip(0).limit(5)

Solution

1. Step 1: Calculate skip value for page 2

   Each page has 5 documents, so page 1 skips 0, page 2 skips 5 documents (5 * (2-1) = 5).

2. Step 2: Set limit to page size

   Limit should be 5 to get 5 documents per page.

3. Final Answer:

   skip(5).limit(5) -> Option C

4. Quick Check:

   Page 2 skip = 5, limit = 5 [OK]

Hint: Skip = pageSize * (pageNumber - 1), limit = pageSize [OK]

Common Mistakes:

• Using skip(10) for page 2
• Setting skip to 1 instead of 5
• Confusing skip and limit values

3.

Given a collection with documents numbered 1 to 10, what documents will this query return?

db.collection.find().skip(3).limit(4)

medium

A. Documents 1 to 4

B. Documents 4 to 7

C. Documents 3 to 6

D. Documents 5 to 8

Solution

1. Step 1: Understand skip(3)

   Skip the first 3 documents: documents 1, 2, and 3 are ignored.

2. Step 2: Apply limit(4)

   Return the next 4 documents after skipping: documents 4, 5, 6, and 7.

3. Final Answer:

   Documents 4 to 7 -> Option B

4. Quick Check:

   Skip 3, then limit 4 = docs 4-7 [OK]

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

Common Mistakes:

• Counting skip as inclusive
• Starting limit count before skip
• Off-by-one errors in document numbers

4.

Identify the error in this pagination query to get page 3 with 10 documents per page:

db.collection.find().skip(20).limit(20)

medium

A. limit should be 10, not 20

B. skip value is too high

C. skip should be 30 for page 3

D. No error, query is correct

Solution

1. Step 1: Calculate correct skip and limit for page 3

   Skip should be 10 * (3-1) = 20, which is correct here.

2. Step 2: Check limit value

   Limit should be 10 to get 10 documents per page, but query uses limit(20), which is too many.

3. Final Answer:

   limit should be 10, not 20 -> Option A

4. Quick Check:

   Limit = page size = 10 [OK]

Hint: Limit equals page size, skip = pageSize*(page-1) [OK]

Common Mistakes:

• Setting limit equal to skip
• Using skip as page number
• Assuming no limit needed

5.

You want to display page 4 of a product list with 8 items per page. However, the total products are 30. Which query correctly handles this pagination without returning empty results?

db.products.find().skip(?).limit(?)

hard

A. skip(24).limit(8)

B. skip(32).limit(8)

C. skip(16).limit(8)

D. skip(30).limit(8)

Solution

1. Step 1: Calculate skip for page 4

   Skip = 8 * (4-1) = 24 documents to reach page 4.

2. Step 2: Check total documents and limit

   Total is 30, so skipping 24 leaves 6 documents (30-24). Limit 8 is okay; it will return only available 6 documents without error.

3. Step 3: Analyze other options

   skip(32) and skip(30) exceed total documents, returning empty results. skip(16) is for page 3, not page 4.

4. Final Answer:

   skip(24).limit(8) -> Option A

5. Quick Check:

   Page 4 skip = 24, limit = 8, total 30 [OK]

Hint: Skip = pageSize*(page-1), limit = pageSize, check total docs [OK]

Common Mistakes:

• Skipping beyond total documents
• Using wrong skip for page number
• Ignoring total document count