How do Redis hashes and sets work?

Question

Accepted Answer

**Hashes** store field-value pairs (like an object/record) under one key; **sets** store unordered collections of unique strings with fast membership tests and set operations. Both are important Redis structures for common data-modeling needs.

## Hashes — store objects/records

```bash
# a hash groups multiple fields under one key (like an object)
HSET user:1 name "Ann" age 30 email "ann@x.com"
HGET user:1 name           # => "Ann" (one field)
HGETALL user:1             # => all fields and values
HMGET user:1 name age      # => multiple fields
HINCRBY user:1 age 1       # increment a numeric field atomically
HDEL user:1 email          # delete a field
HEXISTS user:1 name        # field exists? => 1
```

Hashes store an entity's fields together under one key — more efficient and organized than separate keys per field (e.g. storing a user object). Fields can be read/written individually.

## Sets — unique collections and membership

```bash
SADD tags "redis" "cache" "db"   # add members (duplicates ignored — unique)
SISMEMBER tags "redis"           # is it a member? => 1 (fast O(1))
SMEMBERS tags                     # all members
SCARD tags                        # count of members
SREM tags "db"                    # remove a member
```

Sets hold **unique** values with **fast membership testing** (`SISMEMBER`) — ideal for tags, tracking unique items, and "have I seen this?" checks.

## Set operations (a key feature)

```bash
# set algebra across multiple sets
SADD user:1:follows "a" "b" "c"
SADD user:2:follows "b" "c" "d"
SINTER user:1:follows user:2:follows   # INTERSECTION => "b","c" (common follows)
SUNION user:1:follows user:2:follows   # UNION => all
SDIFF user:1:follows user:2:follows    # DIFFERENCE => "a" (only user:1 follows)
```

**Set operations** (intersection, union, difference) compute relationships efficiently — great for "mutual friends", "common tags", recommendations, and similar.

## Why it matters

Hashes and sets are important Redis data structures for common modeling needs, so understanding them is valuable, frequently-applied knowledge. **Hashes** are the natural way to store **objects/records** in Redis — grouping an entity's fields (name, age, email) together under one key rather than scattering them across separate keys, which is more efficient (one key, individually accessible fields) and organized for storing structured data like user profiles or session objects; the ability to read/write individual fields and atomically increment numeric fields (`HINCRBY`) makes hashes practical for entity storage. **Sets** provide **unique collections with fast membership testing** — ideal for tags, tracking unique items (unique visitors, seen items), and "does this exist?" checks (`SISMEMBER` in O(1)) — common needs in many applications.

Particularly powerful are **set operations** (intersection, union, difference) that efficiently compute relationships between sets — enabling features like "mutual friends" (intersection of follow sets), "common interests", and recommendations directly in Redis, which would be cumbersome to compute otherwise.

Understanding when to use each (hashes for objects/records, sets for unique collections and relationship computations) is part of choosing the right Redis structure.

Since storing objects and managing unique collections/relationships are common needs, and since hashes (for efficient object storage) and sets (for unique collections, fast membership, and powerful set operations) address them naturally, understanding Redis hashes and sets is valuable, practically-relevant knowledge for modeling data in Redis effectively, two of the core data structures that make Redis versatile beyond simple key-value storage.