$limit and $skip stages in MongoDB

Introduction

We use $limit and $skip to control how many results we get and where to start in a list of data. This helps us see just the part we want.

When you want to show only the first 5 items from a big list of products.

When you want to skip the first 10 messages and see the next ones in a chat app.

When you want to create pages of results, like showing 10 users per page.

When you want to test a small part of your data without loading everything.

When you want to jump to a specific spot in your data list to continue reading.

Syntax

MongoDB

{ $limit: <number> },
{ $skip: <number> }

$limit sets the maximum number of documents to return.

$skip tells MongoDB to ignore a number of documents before returning results.

Examples

This will return only the first 3 documents from the collection.

MongoDB

[ { $limit: 3 } ]

This will skip the first 5 documents and return the rest.

MongoDB

[ { $skip: 5 } ]

This skips the first 2 documents, then returns the next 4 documents.

MongoDB

[ { $skip: 2 }, { $limit: 4 } ]

Sample Program

This query skips the first 2 books and then returns the next 3 books from the books collection.

MongoDB

db.books.aggregate([
  { $skip: 2 },
  { $limit: 3 }
])

Important Notes

Always use $skip before $limit to get the correct slice of data.

Using $skip with a large number can be slow because MongoDB still processes skipped documents.

These stages are often used together to create pagination in apps.

Summary

$limit controls how many results you get back.

$skip tells MongoDB to ignore some results before starting to return data.

Use them together to get specific parts of your data, like pages.

Practice

1. What does the $limit stage do in a MongoDB aggregation pipeline?

easy

A. It skips a number of documents before returning results.

B. It groups documents by a specified field.

C. It sorts the documents in ascending order.

D. It restricts the number of documents returned.

Solution

1. Step 1: Understand the purpose of $limit

   The $limit stage restricts the number of documents that pass through the pipeline to a specified count.

2. Step 2: Compare with other stages

   $skip skips documents, $sort orders them, and $group groups them. Only $limit restricts count.

3. Final Answer:

   It restricts the number of documents returned. -> Option D

4. Quick Check:

   $limit = restrict count [OK]

Hint: Remember: limit = how many results you get [OK]

Common Mistakes:

• Confusing $limit with $skip
• Thinking $limit sorts data
• Mixing $limit with $group

2. Which of the following is the correct syntax to skip 5 documents and then limit the result to 10 documents in a MongoDB aggregation pipeline?

easy

A. [{ $skip: 5 }, { $limit: 10 }]

B. [{ $limit: 10 }, { $skip: 5 }]

C. [{ $skip: 10 }, { $limit: 5 }]

D. [{ $limit: 5 }, { $skip: 10 }]

Solution

1. Step 1: Identify correct order of stages

   To skip first, use $skip then limit results with $limit.

2. Step 2: Match syntax with values

   Skipping 5 then limiting to 10 matches [{ $skip: 5 }, { $limit: 10 }].

3. Final Answer:

   [{ $skip: 5 }, { $limit: 10 }] -> Option A

4. Quick Check:

   Skip first, then limit [OK]

Hint: Skip first, then limit for paging [OK]

Common Mistakes:

• Reversing $limit and $skip order
• Using wrong numbers for skip and limit
• Confusing syntax with find() options

3. Given a collection with documents numbered 1 to 10, what will be the output of this aggregation pipeline?

[{ $skip: 3 }, { $limit: 4 }]

medium

A. [1, 2, 3, 4]

B. [4, 5, 6, 7]

C. [3, 4, 5, 6]

D. [5, 6, 7, 8]

Solution

1. Step 1: Apply $skip: 3 on documents 1 to 10

   Skipping 3 documents removes 1, 2, 3; remaining are 4 to 10.

2. Step 2: Apply $limit: 4 on remaining documents

   Limit to 4 documents returns 4, 5, 6, 7.

3. Final Answer:

   [4, 5, 6, 7] -> Option B

4. Quick Check:

   Skip 3, then take 4 [OK]

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

Common Mistakes:

• Counting skip as inclusive
• Mixing skip and limit values
• Assuming skip resets numbering

4. You wrote this aggregation pipeline but it returns only 2 documents instead of skipping the first 3 from the full collection and limiting to 5:

[{ $limit: 5 }, { $skip: 3 }]

What is the problem?

medium

A. You need to use find() instead of aggregation for skip and limit.

B. The syntax is invalid; $skip cannot be used in aggregation.

C. $skip must come before $limit to work correctly.

D. The pipeline is missing a $match stage before $limit.

Solution

1. Step 1: Understand stage order effect

   $limit first restricts to 5 documents, then $skip tries to skip 3 from those 5.

2. Step 2: Why it returns only 2 documents

   Because $skip after $limit skips from a smaller set (first 5), not the full collection.

3. Final Answer:

   $skip must come before $limit to work correctly. -> Option C

4. Quick Check:

   Skip first, then limit [OK]

Hint: Order matters: skip before limit [OK]

Common Mistakes:

• Placing $limit before $skip
• Thinking $skip is invalid in aggregation
• Confusing aggregation with find()

5. You want to implement pagination on a collection with 100 documents, showing 10 documents per page. Which aggregation pipeline correctly gets the 3rd page of results?

hard

A. [{ $skip: 20 }, { $limit: 10 }]

B. [{ $skip: 30 }, { $limit: 10 }]

C. [{ $limit: 10 }, { $skip: 20 }]

D. [{ $limit: 30 }, { $skip: 10 }]

Solution

1. Step 1: Calculate skip value for page 3

   Each page shows 10 documents, so page 3 skips 2 pages x 10 = 20 documents.

2. Step 2: Apply skip and limit in correct order

   Skip 20 documents, then limit to 10 documents to get page 3 results.

3. Final Answer:

   [{ $skip: 20 }, { $limit: 10 }] -> Option A

4. Quick Check:

   Skip (page-1)*size, then limit size [OK]

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

Common Mistakes:

• Using wrong skip calculation
• Reversing skip and limit order
• Confusing page number with skip count