Bird
Raised Fist0
MongoDBquery~5 mins

TTL indexes for auto-expiry in MongoDB - Time & Space Complexity

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallTime
Time Complexity: TTL indexes for auto-expiry
O(log n + m)
Understanding Time Complexity

When using TTL indexes in MongoDB, it's important to understand how the system handles automatic deletion of expired documents.

We want to know how the time to remove expired data grows as the collection gets bigger.

Scenario Under Consideration

Analyze the time complexity of this TTL index setup and expiry process.


// Create TTL index on 'createdAt' field with 3600 seconds expiry
db.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 })

// MongoDB background thread periodically removes expired documents
// No explicit query needed; system handles expiry automatically

This code creates a TTL index that automatically deletes documents older than one hour.

Identify Repeating Operations

MongoDB runs a background thread that periodically scans for expired documents.

  • Primary operation: Scanning documents with the TTL index to find expired ones.
  • How many times: This scan repeats regularly, roughly every 60 seconds.
How Execution Grows With Input

The background thread uses the TTL index to quickly find expired documents without scanning the whole collection.

Input Size (n)Approx. Operations
10Few index lookups, very fast
100More index lookups, still quick
1000More lookups but still efficient due to index

Pattern observation: The time to find expired documents grows slowly because the TTL index helps avoid scanning all documents.

Final Time Complexity

Time Complexity: O(log n + m)

This means the time to find expired documents grows slowly as the collection grows, thanks to the index, plus the time to delete the expired documents (m).

Common Mistake

[X] Wrong: "TTL expiry scans every document in the collection each time it runs."

[OK] Correct: MongoDB uses the TTL index to quickly locate expired documents, so it does not scan all documents every time.

Interview Connect

Understanding how TTL indexes work and their time complexity shows you know how databases handle automatic cleanup efficiently.

Self-Check

"What if the TTL index was on a non-indexed field? How would the time complexity change?"

Practice

(1/5)
1. What is the main purpose of a TTL index in MongoDB?
easy
A. Automatically delete documents after a specified time
B. Encrypt documents for security
C. Create backups of collections
D. Improve query speed by sorting data

Solution

  1. Step 1: Understand TTL index function

    A TTL index is designed to remove documents automatically after a certain time period.

  2. Step 2: Compare options with TTL purpose

    Only Automatically delete documents after a specified time describes automatic deletion after time, which matches TTL index behavior.

  3. Final Answer:

    Automatically delete documents after a specified time -> Option A

  4. Quick Check:

    TTL index = auto-delete documents [OK]
Hint: TTL means auto-delete documents after time [OK]
Common Mistakes:
  • Thinking TTL encrypts data
  • Confusing TTL with backup or sorting
  • Assuming TTL speeds up queries
2. Which of the following is the correct way to create a TTL index on a field named createdAt that expires documents after 3600 seconds?
easy
A. db.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 })
B. db.collection.createIndex({ createdAt: 1 }, { ttl: 3600 })
C. db.collection.createTTLIndex({ createdAt: 1 }, 3600)
D. db.collection.createIndex({ createdAt: 1 }, { expireAfter: 3600 })

Solution

  1. Step 1: Recall correct TTL index syntax

    The correct syntax uses createIndex with the option expireAfterSeconds set to the expiry time in seconds.

  2. Step 2: Match options with correct syntax

    Only db.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }) uses createIndex and expireAfterSeconds correctly.

  3. Final Answer:

    db.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }) -> Option A

  4. Quick Check:

    expireAfterSeconds option = correct TTL syntax [OK]
Hint: Use expireAfterSeconds option in createIndex [OK]
Common Mistakes:
  • Using wrong option names like ttl or expireAfter
  • Using non-existent createTTLIndex method
  • Forgetting to specify expireAfterSeconds
3. Given a collection with documents having a timestamp field and a TTL index created as db.logs.createIndex({ timestamp: 1 }, { expireAfterSeconds: 120 }), what happens to a document inserted with { timestamp: new Date() } after 3 minutes?
medium
A. The document remains indefinitely
B. The document is automatically deleted
C. The document is archived but not deleted
D. The document causes an error on insertion

Solution

  1. Step 1: Understand TTL expiry timing

    The TTL index deletes documents after expireAfterSeconds from the timestamp field value.

  2. Step 2: Calculate expiry for 3 minutes

    3 minutes = 180 seconds, which is more than 120 seconds, so the document will be deleted.

  3. Final Answer:

    The document is automatically deleted -> Option B

  4. Quick Check:

    TTL expiry after 120s means deletion after 3 minutes [OK]
Hint: TTL deletes after expireAfterSeconds from date field [OK]
Common Mistakes:
  • Thinking document stays forever
  • Assuming TTL archives instead of deletes
  • Believing TTL causes insertion errors
4. You created a TTL index with expireAfterSeconds: 0 on a field expireAt, but documents are not being deleted. What is the likely cause?
medium
A. TTL indexes only work on _id field
B. expireAfterSeconds cannot be zero
C. You must restart MongoDB for TTL to work
D. The expireAt field is not a date type

Solution

  1. Step 1: Check TTL index requirements

    TTL indexes require the indexed field to be a date type to calculate expiry.

  2. Step 2: Analyze why documents not deleted

    If expireAt is not a date, TTL cannot determine expiry time, so documents stay.

  3. Final Answer:

    The expireAt field is not a date type -> Option D

  4. Quick Check:

    TTL needs date field type to delete documents [OK]
Hint: Ensure TTL field is a date type [OK]
Common Mistakes:
  • Thinking expireAfterSeconds cannot be zero
  • Believing TTL only works on _id
  • Assuming MongoDB restart is needed
5. You want documents in a collection to expire exactly at a specific date and time stored in the expireAt field. Which TTL index configuration achieves this?
hard
A. Create TTL index on createdAt with expireAfterSeconds set to document age
B. Create TTL index on expireAt with expireAfterSeconds: 3600
C. Create TTL index on expireAt with expireAfterSeconds: 0
D. Use a background job to delete documents at expireAt

Solution

  1. Step 1: Understand TTL with exact expiry date

    Setting expireAfterSeconds to 0 means documents expire exactly at the date/time in the field.

  2. Step 2: Compare options for exact expiry

    Only Create TTL index on expireAt with expireAfterSeconds: 0 uses expireAfterSeconds: 0 on expireAt field to expire exactly at that time.

  3. Final Answer:

    Create TTL index on expireAt with expireAfterSeconds: 0 -> Option C

  4. Quick Check:

    expireAfterSeconds: 0 = expire exactly at date field [OK]
Hint: Use expireAfterSeconds: 0 for exact expiry date [OK]
Common Mistakes:
  • Using non-zero expireAfterSeconds for exact expiry
  • Confusing createdAt with expireAt field
  • Relying on manual background jobs unnecessarily
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard