List vs sorted set for sequences in Redis - Hands-On Comparison

Using Redis Lists and Sorted Sets for Sequences

📖 Scenario: You are building a simple message queue system where messages need to be stored and retrieved in order. You want to explore two ways to store these messages in Redis: using a List and using a Sorted Set.

🎯 Goal: Learn how to create a Redis List and a Sorted Set to store sequences of messages, add messages to them, and retrieve messages in order.

📋 What You'll Learn

Create a Redis List called message_list with three messages: 'msg1', 'msg2', 'msg3'

Create a variable called score and set it to 1

Add the same three messages to a Sorted Set called message_sorted_set with increasing scores starting from score

Retrieve all messages from both message_list and message_sorted_set in order

💡 Why This Matters

🌍 Real World

Message queues and ordered event logs often use Redis Lists or Sorted Sets to store sequences of events or messages.

💼 Career

Understanding how to use Redis data structures for ordered data is important for backend developers working with caching, messaging, and real-time data.

1

Create a Redis List with messages

Use the Redis command LPUSH to create a List called message_list and add the messages 'msg1', 'msg2', and 'msg3' in that order.

Redis

# Use LPUSH to add 'msg1', 'msg2', 'msg3' to 'message_list'
# Your code here

Hint

Remember that LPUSH adds elements to the head of the list, so add messages in reverse order to keep the sequence.

2

Create a score variable for Sorted Set

Create a variable called score and set it to 1. This will be used as the starting score for adding messages to the Sorted Set.

Redis

LPUSH message_list msg3
LPUSH message_list msg2
LPUSH message_list msg1

# Create a variable called score and set it to 1
# Your code here

Hint

Use the Redis SET command to create the variable score.

3

Add messages to a Sorted Set with scores

Use the Redis command ZADD to add the messages 'msg1', 'msg2', and 'msg3' to a Sorted Set called message_sorted_set. Use the variable score for the first message's score, then increment the score by 1 for each next message.

Redis

LPUSH message_list msg3
LPUSH message_list msg2
LPUSH message_list msg1

SET score 1

# Add 'msg1', 'msg2', 'msg3' to 'message_sorted_set' with increasing scores
# Your code here

Hint

Use ZADD with increasing scores starting from 1 for each message.

4

Retrieve messages from List and Sorted Set

Use the Redis commands LRANGE and ZREVRANGE to retrieve all messages from message_list and message_sorted_set respectively, in the order they were added.

Redis

LPUSH message_list msg3
LPUSH message_list msg2
LPUSH message_list msg1

SET score 1

ZADD message_sorted_set 1 msg1
ZADD message_sorted_set 2 msg2
ZADD message_sorted_set 3 msg3

# Retrieve all messages from 'message_list' using LRANGE
# Retrieve all messages from 'message_sorted_set' using ZREVRANGE
# Your code here

Hint

Use LRANGE message_list 0 -1 to get all list items and ZREVRANGE message_sorted_set 0 -1 to get all sorted set items in ascending order by score.

Practice

1. Which Redis data structure allows storing duplicate elements while preserving their order?

easy

A. Hash

B. List

C. Sorted Set

D. Set

Solution

1. Step 1: Understand List behavior

   Lists in Redis keep elements in the order they were added and allow duplicates.

2. Step 2: Compare with Sorted Set

   Sorted sets store unique elements sorted by score, so duplicates are not allowed.

3. Final Answer:

   List -> Option B

4. Quick Check:

   Duplicates allowed and order preserved = List [OK]

Hint: Duplicates allowed? Use List, not Sorted Set. [OK]

Common Mistakes:

• Thinking Sorted Set allows duplicates
• Confusing Sets with Lists
• Assuming Hashes store sequences

2. Which of the following Redis commands correctly adds an element with a score to a sorted set?

easy

A. HSET myhash field element

B. LPUSH mylist element

C. SADD myset element

D. ZADD myzset 10 element

Solution

1. Step 1: Identify command for sorted set insertion

   ZADD adds elements with a score to a sorted set.

2. Step 2: Check other commands

   LPUSH adds to list, SADD adds to set, HSET adds to hash field.

3. Final Answer:

   ZADD myzset 10 element -> Option D

4. Quick Check:

   ZADD = add with score [OK]

Hint: ZADD is for sorted sets with scores. [OK]

Common Mistakes:

• Using LPUSH for sorted sets
• Confusing SADD with ZADD
• Using HSET for sequences

3. Given the following Redis commands executed in order:
LPUSH mylist a
LPUSH mylist b
LPUSH mylist c
What will LRANGE mylist 0 -1 return?

medium

A. ["a", "b", "c"]

B. ["b", "c", "a"]

C. ["c", "b", "a"]

D. Error

Solution

1. Step 1: Understand LPUSH order

   LPUSH adds elements to the head (start) of the list, so last pushed is first.

2. Step 2: Trace the list after pushes

   LPUSH mylist a: ["a"], then LPUSH mylist b: ["b", "a"], then LPUSH mylist c: ["c", "b", "a"]. LRANGE mylist 0 -1 returns ["c", "b", "a"].

3. Final Answer:

   ["c", "b", "a"] -> Option C

4. Quick Check:

   LPUSH adds to head, so newest first [OK]

Hint: LPUSH adds to front; last pushed appears first. [OK]

Common Mistakes:

• Assuming LPUSH adds to tail
• Mixing order of elements
• Expecting error from LRANGE

4. You tried to add duplicate elements with different scores to a sorted set using:
ZADD myzset 1 element
ZADD myzset NX 2 element
But the score did not update as expected. What is the likely issue?

medium

A. Sorted sets do not allow duplicate elements; score updates require special flag

B. ZADD command syntax is incorrect

C. You must remove the element before adding it again

D. Redis lists should be used instead

Solution

1. Step 1: Understand sorted set uniqueness

   Sorted sets store unique elements; adding the same element updates its score by default.

2. Step 2: Check if score updates require flags

   By default, ZADD updates score if element exists; if it did not update, likely a misunderstanding or missing flag like NX or XX.

3. Final Answer:

   Sorted sets do not allow duplicate elements; score updates require special flag -> Option A

4. Quick Check:

   Sorted sets unique, score updates need care [OK]

Hint: Sorted sets unique; score updates may need flags. [OK]

Common Mistakes:

• Thinking duplicates allowed in sorted sets
• Assuming ZADD syntax is wrong
• Trying to remove before adding

5. You want to store a sequence of user actions with timestamps and retrieve them sorted by time, allowing multiple actions at the same timestamp. Which Redis data structure and approach is best?

hard

A. Use a Sorted Set with timestamps as scores; append a unique suffix to actions to allow duplicates

B. Use a List and store actions with timestamps as strings; order is insertion order

C. Use a Hash with timestamps as fields and actions as values

D. Use a Set to store actions; order does not matter

Solution

1. Step 1: Analyze requirement for sorting by timestamp

   Sorted sets sort elements by numeric score, perfect for timestamps.

2. Step 2: Handle duplicates with same timestamp

   Sorted sets require unique elements, so append unique suffix to actions to allow duplicates with same score.

3. Step 3: Compare with other options

   Lists preserve order but cannot sort by timestamp easily; hashes and sets do not maintain order or allow sorting by score.

4. Final Answer:

   Use a Sorted Set with timestamps as scores; append a unique suffix to actions to allow duplicates -> Option A

5. Quick Check:

   Sorted set + unique elements for timestamp sorting [OK]

Hint: Sorted set + unique suffix for duplicates with same score. [OK]

Common Mistakes:

• Using List but losing timestamp sorting
• Ignoring uniqueness in sorted sets
• Using Hash or Set which don't sort