SCAN for safe key iteration in Redis - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start scanning keys from the beginning.

Redis

cursor = [1]

Drag options to blanks, or click blank then click option'

ANone

B0

C-1

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting cursor at 1 instead of 0.

Using None or negative numbers as cursor.

The SCAN command starts with cursor 0 to begin iteration over keys.

2fill in blank

medium

Complete the code to scan keys matching the pattern 'user:*'.

Redis

cursor, keys = redis.scan(cursor, match=[1])

Drag options to blanks, or click blank then click option'

A'user*'

B'user#*'

C'user:*'

D'user?*'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'user*' which matches keys starting with 'user' but no colon.

Using incorrect wildcard characters like '?' or '#'.

The pattern 'user:*' matches keys starting with 'user:' followed by anything.

3fill in blank

hard

Fix the error in the loop condition to continue scanning until cursor is zero.

Redis

while cursor != [1]:
    cursor, keys = redis.scan(cursor)

Drag options to blanks, or click blank then click option'

A0

B-1

CNone

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for cursor != None or -1 which are invalid.

Using cursor != 1 which causes infinite loop.

The SCAN command returns cursor 0 when the iteration is complete.

4fill in blank

hard

Fill both blanks to scan keys with count 100 and match pattern 'session:*'.

Redis

cursor, keys = redis.scan(cursor, match=[1], count=[2])

Drag options to blanks, or click blank then click option'

A'session:*'

B50

C100

D'user:*'

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong match pattern like 'user:*'.

Setting count to 50 instead of 100.

Use match='session:*' to filter keys and count=100 to limit keys per scan.

5fill in blank

hard

Fill all three blanks to safely iterate all keys and collect them in a list.

Redis

all_keys = []
cursor = [1]
while cursor != [2]:
    cursor, keys = redis.scan(cursor, match=[3])
    all_keys.extend(keys)

Drag options to blanks, or click blank then click option'

A0

BNone

C'*'

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using None or 1 as cursor start or end condition.

Using a match pattern other than '*'.

Start cursor at 0, loop until cursor is 0, and match '*' to get all keys.

Practice

1. What is the main advantage of using SCAN over KEYS in Redis for iterating keys?

easy

A. SCAN returns all keys at once for faster access.

B. SCAN only works with sorted sets.

C. SCAN deletes keys while iterating.

D. SCAN does not block Redis and returns keys in batches.

Solution

1. Step 1: Understand KEYS behavior

   KEYS returns all matching keys at once and blocks Redis during execution.

2. Step 2: Understand SCAN behavior

   SCAN returns keys in small batches without blocking Redis, allowing safe iteration.

3. Final Answer:

   SCAN does not block Redis and returns keys in batches. -> Option D

4. Quick Check:

   Safe iteration = SCAN non-blocking [OK]

Hint: Remember: SCAN is non-blocking, KEYS blocks [OK]

Common Mistakes:

• Thinking SCAN returns all keys at once
• Confusing SCAN with key deletion
• Assuming SCAN only works on sorted sets

2. Which of the following is the correct syntax to start a SCAN iteration from the beginning in Redis CLI?

easy

A. SCAN 1

B. SCAN 0

C. SCAN *

D. SCAN start

Solution

1. Step 1: Identify the starting cursor for SCAN

   The SCAN command requires a cursor argument; starting cursor is always 0.

2. Step 2: Check options for correct cursor

   SCAN 0 starts iteration from the beginning; other options are invalid.

3. Final Answer:

   SCAN 0 -> Option B

4. Quick Check:

   Start cursor = 0 [OK]

Hint: Always start SCAN with cursor 0 [OK]

Common Mistakes:

• Starting with cursor 1 instead of 0
• Using wildcard * as cursor
• Using invalid strings like 'start'

3. Given the following Redis commands executed sequentially, what will be the output of the last SCAN command?

SET user:1 Alice
SET user:2 Bob
SET admin:1 Carol
SCAN 0 MATCH user:*

medium

A. [cursor, ["user:1", "user:2"]]

B. [0, ["user:1", "user:2"]]

C. [cursor, ["user:1", "user:2", "admin:1"]]

D. [0, ["admin:1"]]

Solution

1. Step 1: Understand SCAN with MATCH

   The MATCH user:* filters keys starting with 'user:'. So keys 'user:1' and 'user:2' match; 'admin:1' does not.

2. Step 2: Understand SCAN output format

   SCAN returns a two-element array: a cursor (string) and a list of keys matching the pattern in this batch. Cursor is not necessarily 0 unless iteration is complete.

3. Final Answer:

   [cursor, ["user:1", "user:2"]] -> Option A

4. Quick Check:

   Filtered keys = user keys only [OK]

Hint: MATCH filters keys; cursor is a string, not always 0 [OK]

Common Mistakes:

• Expecting cursor 0 on first SCAN call
• Including keys not matching pattern
• Confusing cursor with count

4. You wrote this Redis command to iterate keys safely:

SCAN 0 MATCH user:*

But you notice it returns only a partial list of keys matching the pattern. What is the likely mistake?

medium

A. Not repeating SCAN with the returned cursor until it returns 0.

B. Using MATCH with an incorrect pattern.

C. Starting SCAN with cursor 1 instead of 0.

D. Using COUNT option with a value too high.

Solution

1. Step 1: Understand SCAN iteration process

   SCAN returns a cursor and a batch of keys; to get all keys, you must repeat SCAN with the new cursor until it returns 0.

2. Step 2: Identify the mistake

   Running SCAN 0 MATCH user:* only once returns partial keys; not looping causes incomplete results.

3. Final Answer:

   Not repeating SCAN with the returned cursor until it returns 0. -> Option A

4. Quick Check:

   Repeat SCAN until cursor 0 [OK]

Hint: Always loop SCAN calls until cursor returns 0 [OK]

Common Mistakes:

• Expecting all keys in one SCAN call
• Misusing MATCH pattern syntax
• Starting with wrong cursor

5. You want to safely iterate all keys starting with session: in Redis but avoid blocking the server. You also want to limit each batch to about 10 keys. Which command sequence correctly achieves this?

hard

A. Use SCAN 0 COUNT 10 without MATCH.

B. Run KEYS session:* once to get all keys.

C. Repeat SCAN cursor MATCH session:* COUNT 10 until cursor returns 0.

D. Use SCAN 0 MATCH session:* once without COUNT.

Solution

1. Step 1: Use SCAN with MATCH and COUNT

   To filter keys starting with 'session:' and limit batch size, use MATCH session:* and COUNT 10.

2. Step 2: Repeat SCAN calls until cursor is 0

   Iterate by passing the returned cursor each time until it returns 0 to get all keys safely without blocking.

3. Final Answer:

   Repeat SCAN cursor MATCH session:* COUNT 10 until cursor returns 0. -> Option C

4. Quick Check:

   Safe iteration + filter + batch size = Repeat SCAN cursor MATCH session:* COUNT 10 until cursor returns 0. [OK]

Hint: Combine MATCH and COUNT, loop until cursor 0 [OK]

Common Mistakes:

• Using KEYS which blocks Redis
• Not looping SCAN calls
• Omitting MATCH or COUNT when needed