SCAN for safe key iteration in Redis - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What does the following Redis SCAN command return?

Consider a Redis database with keys: user:1, user:2, session:1, session:2. What will be the output of this command?

SCAN 0 MATCH user:*

Assume the database is static during the scan.

Redis

SCAN 0 MATCH user:*

A A cursor and a list containing keys starting with 'user:' such as ['user:1', 'user:2']

B All keys in the database regardless of pattern

C An error because SCAN does not accept MATCH

D Only the key 'user:*' if it exists

💡 Hint

Remember SCAN returns a cursor and a list of keys matching the pattern.

The SCAN command returns a cursor and a list of keys matching the pattern. Here, it returns keys starting with 'user:'.

🧠 Conceptual

intermediate

Why is SCAN preferred over KEYS for iterating keys in Redis?

Which reason best explains why SCAN is safer to use than KEYS in a production Redis environment?

A SCAN deletes keys as it scans, freeing memory

B SCAN returns all keys at once, making it faster than KEYS

C SCAN uses a cursor and returns keys incrementally, avoiding blocking the server

D SCAN only works on sorted sets, making it more efficient

💡 Hint

Think about server load and blocking behavior.

SCAN returns keys incrementally using a cursor, so it does not block the server like KEYS, which returns all keys at once.

📝 Syntax

advanced

Which SCAN command syntax correctly scans keys with a pattern and count?

Select the correct Redis SCAN command to scan keys matching 'cache:*' and return approximately 50 keys per iteration.

A SCAN 0 MATCH cache:* COUNT 50

B SCAN MATCH cache:* COUNT 50 0

C SCAN 0 COUNT 50 MATCH cache:*

D SCAN 0 MATCH cache:* LIMIT 50

💡 Hint

The order of MATCH and COUNT matters.

The correct syntax is SCAN MATCH COUNT . Option A follows this order.

❓ optimization

advanced

How to optimize SCAN usage to reduce server load?

You want to scan all keys matching 'temp:*' without causing high CPU usage. Which approach is best?

A Use SCAN without MATCH to get all keys faster

B Use KEYS command instead for faster results

C Use SCAN with a very large COUNT value to get all keys quickly

D Use SCAN with a small COUNT value and pause between calls

💡 Hint

Think about balancing speed and server load.

Using a small COUNT and pausing between calls reduces CPU spikes and server load.

🔧 Debug

expert

Why does this SCAN loop miss some keys?

A developer uses this loop to scan all keys matching 'data:*':

cursor = 0 keys = [] do { result = redis.scan(cursor, match='data:*') cursor = result[0] keys.extend(result[1]) } while cursor != 0

Some keys are missing after the loop finishes. What is the most likely cause?

Redis

cursor = 0
keys = []
do {
  result = redis.scan(cursor, match='data:*')
  cursor = result[0]
  keys.extend(result[1])
} while cursor != 0

A The MATCH pattern is incorrect and filters out keys

B Keys were added or deleted during the scan causing inconsistent results

C The loop should stop when cursor equals 1, not 0

D SCAN does not return all keys by design, so missing keys are normal

💡 Hint

Think about what happens if keys change during iteration.

If keys are added or deleted during SCAN, some keys may be missed or returned multiple times because SCAN is not atomic.