Skip to main content

Sets in Depth

Introduction​

Redis Sets are an important and versatile data structure, offering unique capabilities for use cases where uniqueness, fast membership checks, and set operations like unions or intersections are required. Unlike lists and hashes, sets are unordered collections of unique strings. In this lesson, we’ll dive deeply into Redis sets, exploring their commands, performance characteristics, use cases, and common pitfalls.

What Are Redis Sets?​

A set in Redis is a collection of unique, unordered strings. Sets do not allow duplicate members. The underlying implementation ensures that all set operations (add, remove, check existence) are extremely fast, typically O(1) time complexity.

Key Properties​

  • Uniqueness: No duplicates are allowed.
  • Unordered: No guarantee of order when retrieving elements.
  • Fast operations: Most set commands are O(1) or O(N) depending on the operation.

Creating and Managing Sets​

Adding Members​

To add one or more members to a set, use SADD:

> SADD colors red green blue
(integer) 3

> SADD colors blue yellow
(integer) 1   # Only 'yellow' was new; 'blue' was already present

Retrieving Members​

Get all members with SMEMBERS:

> SMEMBERS colors
1) "green"
2) "red"
3) "blue"
4) "yellow"

Checking Membership​

Use SISMEMBER to check if an element is in a set:

> SISMEMBER colors red
(integer) 1  # 1 = true, 0 = false

> SISMEMBER colors purple
(integer) 0

Removing Members​

Delete one or more members with SREM:

> SREM colors green yellow
(integer) 2

> SMEMBERS colors
1) "red"
2) "blue"

Counting Members​

Get the cardinality (number of elements) with SCARD:

> SCARD colors
(integer) 2

Advanced Set Operations​

Sets in Redis support powerful set-theoretic operations, which are efficient even for large datasets.

Set Union: SUNION​

Get all unique elements from multiple sets.

> SADD set1 a b c
> SADD set2 b c d

> SUNION set1 set2
1) "a"
2) "b"
3) "c"
4) "d"

Set Intersection: SINTER​

Find elements present in all sets.

> SINTER set1 set2
1) "b"
2) "c"

Set Difference: SDIFF​

Find elements in the first set that aren’t in subsequent sets.

> SDIFF set1 set2
1) "a"

Storing the Results​

You can store the result of these operations in a new set:

> SUNIONSTORE set3 set1 set2
(integer) 4

> SMEMBERS set3
1) "a"
2) "b"
3) "c"
4) "d"

Iterating Over Large Sets​

For large sets, avoid using SMEMBERS, as it could block the server. Use SSCAN for incremental iteration:

> SSCAN colors 0 MATCH b*
1) "0"
2) 1) "blue"

This is especially useful for paginating or streaming set members.

Use Cases for Redis Sets​

1. Unique Tag or Category Collections​

Store unique tags or categories for content:

> SADD article:123:tags redis nosql database

2. Tracking Online Users​

Maintain a set of currently online user IDs:

> SADD online_users 1001 1002 1003
> SREM online_users 1002

3. Social Features (Followers, Friends)​

Model the "followers" or "following" lists for users, and perform set operations for mutual followers:

> SADD user:alice:followers bob charlie
> SADD user:bob:followers alice

> SINTER user:alice:followers user:bob:followers
1) "bob"

4. Spam/Abuse Prevention​

Track unique IPs that have performed an action in a time window:

> SADD login:2024-06-21:ips 192.168.1.1

Sets in Python with redis-py​

Here’s how to work with sets using the redis Python library:

import redis

r = redis.Redis()

# Add members to a set
r.sadd('colors', 'red', 'green', 'blue')

# Check membership
print(r.sismember('colors', 'red'))  # True

# Get all members
print(r.smembers('colors'))  # {b'red', b'green', b'blue'}

# Perform intersection
r.sadd('warm', 'red', 'yellow')
print(r.sinter('colors', 'warm'))  # {b'red'}

Common Mistakes and Pitfalls​

1. Expecting Order​

Sets are unordered. Don’t expect members to come out in any particular order. If you need order, use lists or sorted sets.

2. Assuming Duplicates Can Be Stored​

Adding the same member multiple times has no effect; only one instance exists.

3. Large SMEMBERS Calls​

Fetching all members of a very large set with SMEMBERS can block your Redis server. Use SSCAN for safer, incremental access.

4. Confusing Set and Sorted Set Commands​

Commands for sets (SADD, SMEMBERS) are different from sorted sets (ZADD, ZRANGE). Ensure you use the correct command for your data type.

Summary​

  • Redis sets are unordered collections of unique strings.
  • Sets support efficient membership checks, additions, removals, and set-theoretic operations.
  • Use cases include unique collections, online user tracking, and social relationships.
  • Use SSCAN for large sets instead of SMEMBERS.
  • Sets are not ordered; duplicates are not stored.

Quiz​

  1. Which command would you use to check if "alice" is in the set "online_users"?

    a) SISMEMBER
    b) SMEMBERS
    c) SADD
    d) SREM

    Answer: a) SISMEMBER

  2. What does the following command return: SUNION set1 set2?

    a) Only elements in both sets
    b) All unique elements from both sets
    c) Elements only in set1
    d) Number of elements in set1

    Answer: b) All unique elements from both sets

  3. True or False: Redis sets maintain the order of insertion.

    Answer: False

  4. Which command is recommended for safely iterating over large sets?

    a) SMEMBERS
    b) SSCAN
    c) LRANGE
    d) ZRANGE

    Answer: b) SSCAN

  5. If you add the string "redis" twice to a set, how many times will it be stored?

    a) 0
    b) 1
    c) 2
    d) As many as you add

    Answer: b) 1

You are now ready to leverage Redis sets for efficient, real-world data modeling tasks. In the next lesson, we’ll explore Advanced Data Structures that build upon and extend these foundational types.