Redis hashes மற்றும் sets எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

**Hashes** ஒரு key-ல் field-value pair-களை (ஒரு object/record போல) சேமிக்கிறது; **sets** வரிசைப்படுத்தப்படாத unique strings-களின் சேகரணங்களை வேகமான membership tests மற்றும் set operations உடன் சேமிக்கிறது. இரண்டும் பொதுவான data-modeling தேவைகளுக்கான முக்கியமான Redis structures.

## Hashes — 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 ஒரு entity-ன் fields-களை ஒரு key-ல் சேர்த்து சேமிக்கிறது — ஒவ்வொரு field-க்கும் தனித்தனி keys-ஐ பயன்படுத்துவதைக் காட்டிலும் அधिक efficient மற்றும் ஒழுங்கான முறை (எ.கா. user object சேமிக்கல்). Fields-களை தனித்தனியாக read/write செய்யலாம்.

## Sets — unique collections மற்றும் 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 **unique** values-களை **வேகமான membership testing** (`SISMEMBER`) உடன் வைத்திருக்கிறது — tags, unique items tracking, மற்றும் "இதை நான் கண்டேனா?" checks-க்கு சிறந்தது.

## Set operations (ஒரு முக்கிய 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) உறவுகளை efficiently கணக்கிடுகிறது — "mutual friends", "common tags", recommendations, மற்றும் இதுபோன்றவற்றுக்கு சிறந்தது.

## இது ஏன் முக்கியமாக உள்ளது

Hashes மற்றும் sets பொதுவான modeling தேவைகளுக்கான முக்கியமான Redis data structures ஆகும், எனவே அவற்றைப் புரிந்துகொள்வது மதிப்புமிக்க, அடிக்கடி பயன்படுத்தப்படும் அறிவு. **Hashes** Redis-ல் **objects/records** சேமிக்க natural முறை — ஒரு entity-ன் fields (name, age, email) ஐ ஒரு key-ல் grouped செய்து வைக்கும், அவற்றை தனித்தனி keys-ல் scatter செய்வதைக் காட்டிலும், இது மிகவும் efficient (ஒரு key, individually accessible fields) மற்றும் user profiles அல்லது session objects போல structured data சேமிக்க organized; individual fields-களை read/write செய்ய மற்றும் atomically numeric fields increment செய்ய (`HINCRBY`) கூடிய ability entity storage-க்கு practical ஆக்குகிறது. **Sets** **unique collections with fast membership testing** வழங்குகிறது — tags, unique items tracking (unique visitors, seen items), மற்றும் "இது உள்ளதா?" checks (`SISMEMBER` in O(1))-க்கு சிறந்தது — பல applications-ல் பொதுவான தேவைகள்.

பிரத்யேக முறையில் powerful ஆனவை **set operations** (intersection, union, difference) ஆகும், அவை sets-க்கிடையேயான உறவுகளை efficiently கணக்கிடுகிறது — Redis-ல் directly "mutual friends" (follow sets-ன் intersection), "common interests", மற்றும் recommendations போன்ற features-களை enable செய்கிறது, இவை வேறு வழியில் compute செய்ய cumbersome ஆகும்.

Each-க்கு எப்போது பயன்படுத்த வேண்டும் என்பதை புரிந்துகொள்வது (hashes objects/records-க்கு, sets unique collections மற்றும் relationship computations-க்கு) Redis-ல் data model செய்ய சரியான Redis structure தேர்ந்தெடுப்பதனுடைய பாகம்.

Objects சேமிக்கல் மற்றும் unique collections/relationships manage செய்தல் பொதுவான தேவைகள் ஆகும், மற்றும் hashes (efficient object storage-க்கு) மற்றும் sets (unique collections, fast membership, மற்றும் powerful set operations-க்கு) அவற்றை naturally address செய்கும் என்பதால், Redis-ல் data effectively model செய்ய Redis hashes மற்றும் sets-ஐ புரிந்துகொள்வது மதிப்புமிக்க, practically-relevant அறிவு, simple key-value storage-ஐ விட Redis-ஐ versatile ஆக்கும் core data structures-ஐ இரண்டு.