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.