Memory-efficient data structures in Redis - Step-by-Step Execution

Concept Flow - Memory-efficient data structures

Start: Choose data to store

↓

Check data size and type

↓

Select memory-efficient structure

↓

Store data using structure

↓

Access or modify data

↓

Data remains compact in memory

↓

End

This flow shows how Redis selects and uses memory-efficient data structures to store and manage data compactly.

Execution Sample

Redis

HMSET user:1 name "Alice" age 30
HGETALL user:1
LPUSH tasks "task1" "task2"
LRANGE tasks 0 -1

Store user info in a hash and tasks in a list, then retrieve them showing compact storage.

Execution Table

Step	Command	Action	Data Structure Used	Memory Efficiency	Output
1	HMSET user:1 name "Alice" age 30	Create hash with fields	Hash	Compact for small fields	OK
2	HGETALL user:1	Retrieve all fields	Hash	Compact storage accessed	{"name":"Alice","age":"30"}
3	LPUSH tasks "task1" "task2"	Add tasks to list	List (quicklist)	Efficient linked list	2
4	LRANGE tasks 0 -1	Get all tasks	List (quicklist)	Compact list traversal	["task2","task1"]
5	Memory remains optimized	Data stored in memory-efficient structures	Hash and quicklist	Low memory usage	N/A

💡 All commands executed; data stored and retrieved using memory-efficient Redis structures.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
user:1	none	{"name":"Alice","age":"30"}	{"name":"Alice","age":"30"}	{"name":"Alice","age":"30"}
tasks	empty list	empty list	["task2","task1"]	["task2","task1"]

Key Moments - 2 Insights

Why does Redis use a hash for user data instead of a plain string?

Redis uses a hash because it stores multiple fields compactly, saving memory compared to storing a large JSON string. See execution_table row 1 and 2 where the hash stores 'name' and 'age' efficiently.

How does Redis keep the list of tasks memory-efficient?

Redis uses a quicklist, a compressed linked list, to store tasks compactly. This is shown in execution_table rows 3 and 4 where LPUSH and LRANGE operate on a quicklist.

Visual Quiz - 3 Questions

Look at the execution_table, what data structure is used to store user:1 after step 1?

A Hash

B List

C String

D Set

💡 Hint

Check the 'Data Structure Used' column in row 1 of execution_table.

At which step does Redis add tasks to the list?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Command' column in execution_table to find when LPUSH is called.

If we stored user data as a plain string instead of a hash, what would likely happen?

A Memory usage would decrease

B No change in memory usage

C Memory usage would increase

D Data would be lost

💡 Hint

Refer to key_moments about why hashes are memory-efficient compared to strings.

Concept Snapshot

Redis uses memory-efficient data structures like hashes and quicklists.
Hashes store multiple small fields compactly.
Quicklists combine linked lists and ziplists for efficient lists.
These structures reduce memory use and improve performance.
Use commands like HMSET and LPUSH to work with them.

Full Transcript

This lesson shows how Redis stores data using memory-efficient structures. First, Redis checks the data type and size, then selects a compact structure like a hash for user fields or a quicklist for lists. Commands like HMSET create hashes storing multiple fields in a small space. LPUSH adds items to a quicklist, which is a compressed linked list. Retrieving data with HGETALL or LRANGE accesses these compact structures efficiently. This approach saves memory and keeps Redis fast. The execution table traces each command and the structure used, showing how data changes step-by-step. Key moments explain why hashes and quicklists are better than plain strings or arrays for memory. The quiz tests understanding of which structures are used and why memory efficiency matters.

Practice

1. Which Redis data structure is best suited for storing many small key-value pairs efficiently in memory?

easy

A. List

B. Set

C. Hash

D. String

Solution

1. Step 1: Understand Redis data structures

   Hashes store multiple field-value pairs under one key, saving memory compared to many separate keys.

2. Step 2: Compare with other structures

   Lists and sets store collections but are less memory-efficient for many small pairs; strings store single values only.

3. Final Answer:

   Hash -> Option C

4. Quick Check:

   Hashes = memory-efficient key-value pairs [OK]

Hint: Use hashes for many small key-value pairs to save memory [OK]

Common Mistakes:

• Choosing List or Set for key-value pairs
• Thinking String can store multiple pairs
• Ignoring memory efficiency of Hashes

2. Which of the following is the correct Redis command to add a field-value pair to a hash named user:1?

easy

A. HSET user:1 name "Alice"

B. SADD user:1 name "Alice"

C. LPUSH user:1 name "Alice"

D. SET user:1 name "Alice"

Solution

1. Step 1: Identify the command for hashes

   HSET adds or updates a field in a hash key in Redis.

2. Step 2: Check other commands

   SADD is for sets, LPUSH for lists, SET for strings; none add fields to hashes.

3. Final Answer:

   HSET user:1 name "Alice" -> Option A

4. Quick Check:

   HSET = add field to hash [OK]

Hint: Use HSET to add fields to hashes in Redis [OK]

Common Mistakes:

• Using SADD or LPUSH for hashes
• Confusing SET with HSET
• Incorrect command syntax

3. Given the Redis commands:
HSET user:2 age 30
HSET user:2 city "NYC"
What will HGETALL user:2 return?

medium

A. ["age", "30", "city", "NYC"]

B. ["user:2", "age", "30", "city", "NYC"]

C. ["age", 30, "city", "NYC"]

D. ["age", "30", "city"]

Solution

1. Step 1: Understand HSET commands

   Two fields, 'age' and 'city', are set with values '30' and 'NYC' in hash 'user:2'.

2. Step 2: Check HGETALL output format

   HGETALL returns a flat list of field-value pairs as strings.

3. Final Answer:

   ["age", "30", "city", "NYC"] -> Option A

4. Quick Check:

   HGETALL returns field-value pairs list [OK]

Hint: HGETALL returns flat list of fields and values [OK]

Common Mistakes:

• Expecting key name in output
• Mixing data types (string vs integer)
• Missing value for a field

4. You run the command HSET user:3 name "Bob" but get an error. Which is the most likely cause?

medium

A. Redis does not support hashes with string fields

B. The key user:3 already holds a string value

C. HSET requires a numeric field value

D. The field name is reserved and cannot be used

Solution

1. Step 1: Understand Redis type errors

   If the key 'user:3' holds a string, trying to use HSET (hash command) causes a type error.

2. Step 2: Check other options

   Field names are not reserved, HSET accepts strings, and Redis supports string fields in hashes.

3. Final Answer:

   The key user:3 already holds a string value -> Option B

4. Quick Check:

   Type mismatch causes HSET error [OK]

Hint: Check key type before using hash commands [OK]

Common Mistakes:

• Assuming field names are restricted
• Thinking HSET needs numeric values
• Ignoring Redis data type rules

5. You want to store user preferences with many optional fields but minimize memory. Which Redis approach is best?

hard

A. Use a set with all field names as members

B. Use a list with all possible fields and empty strings for missing

C. Use separate string keys for each field

D. Use a hash with only fields that have values

Solution

1. Step 1: Consider memory efficiency

   Hashes store only existing fields, saving memory by omitting empty or missing fields.

2. Step 2: Evaluate other options

   Lists with empty strings waste memory; sets store unique members but not key-value pairs; separate keys increase overhead.

3. Final Answer:

   Use a hash with only fields that have values -> Option D

4. Quick Check:

   Hashes save memory by storing only present fields [OK]

Hint: Store only present fields in hashes to save memory [OK]

Common Mistakes:

• Using lists with empty placeholders
• Using sets for key-value data
• Creating many separate keys