$limit and $skip stages in MongoDB - Time & Space Complexity

Time Complexity: $limit and $skip stages

O(skip + limit)

Understanding Time Complexity

When using MongoDB, it's important to know how stages like $limit and $skip affect the work the database does.

We want to understand how the time to get results changes as we ask for more or skip more documents.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

db.collection.aggregate([
  { $skip: 100 },
  { $limit: 50 }
])
    

This pipeline skips the first 100 documents and then returns the next 50 documents from the collection.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Scanning documents to skip and then to limit.
• How many times: The database reads documents up to the number skipped plus the number limited.

How Execution Grows With Input

As the number of documents to skip and limit grows, the work grows roughly by adding those two numbers.

Input Size (skip + limit)	Approx. Operations
10 + 5 = 15	About 15 document reads
100 + 50 = 150	About 150 document reads
1000 + 500 = 1500	About 1500 document reads

Pattern observation: The work grows linearly with the total number of documents skipped and limited.

Final Time Complexity

Time Complexity: O(skip + limit)

This means the time to get results grows in a straight line as you increase how many documents you skip plus how many you want to return.

Common Mistake

[X] Wrong: "Skipping documents is free and does not affect performance."

[OK] Correct: The database still has to read and count each skipped document, so skipping many documents takes more time.

Interview Connect

Understanding how $skip and $limit affect performance helps you explain how queries scale and how to handle large data sets efficiently.

Self-Check

"What if we replaced $skip with a range query filter? How would the time complexity change?"

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