$limit and $skip stages in MongoDB - Step-by-Step Execution

Concept Flow - $limit and $skip stages

Start with full dataset

↓

Apply $skip: remove first N documents

↓

Apply $limit: keep only next M documents

↓

Output the resulting documents

The data flows first through $skip which removes a number of documents from the start, then through $limit which keeps only a set number of documents after skipping.

Execution Sample

MongoDB

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

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

Execution Table

Step	Input Documents	$skip Applied	Documents After $skip	$limit Applied	Documents After $limit
1	[D1, D2, D3, D4, D5, D6]	Skip 2	[D3, D4, D5, D6]	Limit 3	[D3, D4, D5]
2	[D3, D4, D5, D6]	Skip 2 (already done)	[D3, D4, D5, D6]	Limit 3 (already done)	[D3, D4, D5]
Exit	No more stages	N/A	N/A	N/A	Final output: [D3, D4, D5]

💡 After skipping 2 documents, limit keeps only 3 documents, so output is [D3, D4, D5].

Variable Tracker

Variable	Start	After $skip	After $limit
Documents	[D1, D2, D3, D4, D5, D6]	[D3, D4, D5, D6]	[D3, D4, D5]

Key Moments - 2 Insights

Why does $skip remove documents before $limit selects them?

Because in the execution_table, $skip is applied first (Step 1), reducing the dataset before $limit chooses how many to keep.

What happens if $limit is larger than the remaining documents after $skip?

The output will include all remaining documents after $skip.

Visual Quiz - 3 Questions

Look at the execution_table at Step 1, what documents remain after applying $skip?

A [D1, D2]

B [D3, D4, D5, D6]

C [D3, D4, D5]

D [D4, D5, D6]

💡 Hint

Check the 'Documents After $skip' column in Step 1 of execution_table.

At which step does the $limit stage reduce the documents to 3?

A Exit

B Step 2

C Step 1

D Before Step 1

💡 Hint

Look at the 'Documents After $limit' column in Step 1 of execution_table.

If we change $skip to 3, how many documents will remain after $skip?

A 3

B 4

C 2

D 6

💡 Hint

Original dataset has 6 documents; skipping 3 removes first 3, so 3 remain.

Concept Snapshot

$skip and $limit stages in MongoDB aggregation:
- $skip N: skips first N documents
- $limit M: limits output to M documents
- Order matters: $skip runs before $limit
- Use to paginate or slice data
- Syntax: [{ $skip: N }, { $limit: M }]

Full Transcript

This visual execution shows how MongoDB aggregation stages $skip and $limit work together. Starting with a dataset of 6 documents, $skip removes the first 2 documents, leaving 4. Then $limit keeps only the next 3 documents. The final output is 3 documents after skipping 2. Variables track the documents at each stage. Key moments clarify why order matters and what happens if limits exceed remaining documents. Quizzes test understanding of the steps and effects of changing skip values.

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