Time-based event queues in Redis - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Retrieve events scheduled before a specific timestamp

Given a Redis sorted set named events where the score is the event timestamp, which command returns all events scheduled before timestamp 1650000000?

A ZRANGEBYSCORE events -inf 1650000000

B ZRANGEBYSCORE events 1650000000 +inf

C ZRANGE events 0 1650000000

D ZREVRANGEBYSCORE events 1650000000 -inf

💡 Hint

Remember that scores in sorted sets represent timestamps and you want all events with scores less than or equal to 1650000000.

ZRANGEBYSCORE with -inf to 1650000000 returns all members with scores up to that timestamp. Option A returns events after that timestamp. Option A reverses the order but with wrong bounds. Option A uses index range, not score range.

📝 Syntax

intermediate

Identify the correct syntax to add a timed event

Which Redis command correctly adds an event named event42 scheduled at timestamp 1680000000 to a sorted set events?

A ZADD events 1680000000 event42

B ZADD events event42 1680000000

C ZADD events (1680000000) event42

D ZADD events event42

💡 Hint

ZADD syntax requires the score first, then the member.

Option A uses correct syntax: ZADD key score member. Option A swaps score and member causing error. Option A uses parentheses incorrectly. Option A misses the score argument.

❓ optimization

advanced

Efficiently removing expired events

You want to remove all events from the events sorted set that have timestamps less than the current time 1690000000. Which command is the most efficient to do this?

A ZREM events 1690000000

B ZREMRANGEBYSCORE events -inf (1690000000

C ZREM events -inf 1690000000

D ZREMRANGEBYRANK events 0 1690000000

💡 Hint

Removing by score range is best for timestamp-based removals.

ZREMRANGEBYSCORE removes all members with scores in the given range efficiently. Option B tries to remove a member named '1690000000' which likely doesn't exist. Option B is invalid syntax. Option B removes by rank, which is unrelated to timestamps.

🔧 Debug

advanced

Why does this time-based event retrieval return no results?

A developer runs this command to get events before timestamp 1700000000: ZRANGEBYSCORE events (1700000000 -inf. Why does it return no results?

A The command syntax is correct; the sorted set is empty

B Parentheses around 1700000000 exclude that score, causing no matches

C The score range is reversed; min should be less than max

D ZRANGEBYSCORE does not support negative infinity

💡 Hint

Check the order of min and max arguments in ZRANGEBYSCORE.

ZRANGEBYSCORE requires the min score first, then max score. Here max is given first, so no results are returned. Parentheses exclude the boundary but do not cause empty results if order is correct. Negative infinity is supported.

🧠 Conceptual

expert

Choosing the best data structure for time-based event queues

Which Redis data structure is best suited for implementing a time-based event queue where events must be processed in order of their scheduled timestamps?

A List because it maintains insertion order and supports push/pop operations

B Set because it stores unique members without order

C Hash because it stores key-value pairs for fast lookup

D Sorted Set (ZSET) because it stores members with scores and supports range queries by score

💡 Hint

Consider which structure supports ordering by timestamp and efficient range queries.

Sorted Sets store members with scores, allowing ordering by timestamp and efficient retrieval of events in time order. Lists maintain insertion order but do not support score-based queries. Hashes and Sets do not maintain order by score.

Practice

1. What is the main purpose of using a Redis sorted set for a time-based event queue?

easy

A. To store events in a hash for quick lookup

B. To store events with timestamps as scores for ordered retrieval

C. To store only unique event names without timestamps

D. To store events without any order

Solution

1. Step 1: Understand Redis sorted sets

   Redis sorted sets store members with a score that determines their order.

2. Step 2: Apply to time-based event queues

   Using timestamps as scores allows events to be retrieved in chronological order.

3. Final Answer:

   To store events with timestamps as scores for ordered retrieval -> Option B

4. Quick Check:

   Sorted sets + timestamps = ordered event queue [OK]

Hint: Remember: sorted sets order by score (timestamp) [OK]

Common Mistakes:

• Thinking sorted sets don't keep order
• Confusing hashes with sorted sets
• Ignoring the timestamp as score

2. Which Redis command correctly adds an event with a timestamp score to a sorted set named events?

easy

A. SADD events 1625097600 "event1"

B. HSET events 1625097600 "event1"

C. ZADD events 1625097600 "event1"

D. LPUSH events 1625097600 "event1"

Solution

1. Step 1: Identify the command for sorted sets

   ZADD adds members with scores to sorted sets; others are for different data types.

2. Step 2: Check syntax correctness

   ZADD events 1625097600 "event1" adds "event1" with score 1625097600 to sorted set events.

3. Final Answer:

   ZADD events 1625097600 "event1" -> Option C

4. Quick Check:

   ZADD = add to sorted set [OK]

Hint: Use ZADD for sorted sets, not SADD or HSET [OK]

Common Mistakes:

• Using SADD which is for sets without scores
• Using HSET which is for hashes
• Using LPUSH which is for lists

3. Given the sorted set events with members and scores:
{"event1": 1000, "event2": 1500, "event3": 2000}
What will the command ZREVRANGEBYSCORE events 1500 -inf return?

medium

A. ["event1"]

B. ["event3", "event2", "event1"]

C. ["event1", "event2"]

D. ["event2", "event1"]

Solution

1. Step 1: Understand ZREVRANGEBYSCORE command

   This command returns members with scores between max and min in descending order.

2. Step 2: Apply to given scores

   Scores ≤ 1500 are event1 (1000) and event2 (1500). Descending order: event2, event1.

3. Final Answer:

   ["event2", "event1"] -> Option D

4. Quick Check:

   Descending scores ≤ 1500 = event2, event1 [OK]

Hint: ZREVRANGEBYSCORE returns descending order by score [OK]

Common Mistakes:

• Confusing ascending with descending order
• Including events with scores above max
• Misreading score boundaries

4. You run this Redis command to fetch due events:
ZREVRANGEBYSCORE events 1625097600 -inf
But you notice the same events are returned repeatedly. What is the likely mistake?

medium

A. Not removing processed events from the sorted set

B. Using ZREVRANGEBYSCORE instead of ZRANGEBYSCORE

C. Using the wrong key name for the sorted set

D. Using a timestamp that is too high

Solution

1. Step 1: Understand event queue behavior

   After processing events, they must be removed to avoid duplicates.

2. Step 2: Identify cause of repeated events

   If events are not removed, the same events appear on every fetch.

3. Final Answer:

   Not removing processed events from the sorted set -> Option A

4. Quick Check:

   Remove events after processing to avoid repeats [OK]

Hint: Always delete processed events from sorted set [OK]

Common Mistakes:

• Thinking order command causes repeats
• Ignoring event removal step
• Assuming wrong key name causes repeats

5. You want to implement a Redis time-based event queue that fetches all events due up to now and removes them atomically to avoid duplicates. Which sequence of commands is best?

hard

A. Use ZRANGEBYSCORE to get events ≤ now, then ZREM to remove them

B. Use ZREVRANGEBYSCORE to get events ≥ now, then ZREM to remove them

C. Use ZRANGEBYSCORE with a future timestamp, then LPUSH to add events

D. Use SPOP to pop events from a set

Solution

1. Step 1: Fetch due events with ZRANGEBYSCORE

   ZRANGEBYSCORE with max = current timestamp fetches all events due up to now.

2. Step 2: Remove fetched events with ZREM

   Removing them prevents duplicates; doing both steps atomically avoids race conditions.

3. Final Answer:

   Use ZRANGEBYSCORE to get events ≤ now, then ZREM to remove them -> Option A

4. Quick Check:

   Fetch ≤ now + remove = atomic event processing [OK]

Hint: Fetch with ZRANGEBYSCORE ≤ now, then remove with ZREM [OK]

Common Mistakes:

• Using ZREVRANGEBYSCORE with wrong score range
• Using sets or lists instead of sorted sets
• Not removing events after fetching