Redis hashes మరియు sets ఎలా పని చేస్తాయి?

Question

Accepted Answer

**Hashes** ఒక కీ కింద field-value pairs లను (object/record లాగా) సংరక్షిస్తాయి; **sets** ఆదేశరహితమైన ప్రత్యేక స్ట్రింగ్‌ల సংগ్రహాలను వేగవంతమైన సభ్యత్వ పరీక్షలు మరియు సెట్ ఆపరేషన్‌లతో సంరక్షిస్తాయి. రెండూ సాధారణ డేటా-మోడలింగ్ అవసరాల కోసం ముఖ్యమైన Redis నిర్మాణాలు.

## 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 లను ఒక కీ కింద కలిసి సంరక్షిస్తాయి — field కు ప్రత్యేక keys వేటిని ఉపయోగించడం కంటే మరింత సమర్థవంతమైనది మరియు సంఘటితమైనది (ఉదా. user object సంరక్షించడం). Fields లను వ్యక్తిగతంగా చదవవచ్చు/వ్రాయవచ్చు.

## Sets — ప్రత్యేక సంగ్రహాలు మరియు సభ్యత్వం

```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 **ప్రత్యేక** విలువలను **వేగవంతమైన సభ్యత్వ పరీక్ష** (`SISMEMBER`) తో ఉంచుతాయి — tags, ప్రత్యేక items ట్రాకింగ్, మరియు "నేను దీన్ని చూశానా?" పరీక్షల కోసం ఆదర్శవంతమైనది.

## సెట్ ఆపరేషన్‌లు (ఒక కీ ఫీచర్)

```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)
```

**సెట్ ఆపరేషన్‌లు** (intersection, union, difference) సంబంధాలను సమర్థవంతంగా గణిస్తాయి — "పరస్పర స్నేహితులు", "సాధారణ tags", సిఫారసులు, మరియు సమానమైనవాటి కోసం గొప్ప.

## ఇది ఎందుకు ముఖ్యమైనది

Hashes మరియు sets సాధారణ మోడలింగ్ అవసరాల కోసం ముఖ్యమైన Redis డేటా నిర్మాణాలు, కాబట్టి వాటిని అర్థం చేసుకోవడం విలువైన, తరచుగా-ఉపయోగించిన జ్ఞానం. **Hashes** Redis లో **objects/records** సంరక్షించడానికి సహజ మార్గం — entity యొక్క fields (name, age, email) లను ఒక కీ కింద కలిసి సమూహం చేయడం వాటిని ప్రత్యేక keys లో చెదరబెట్టడం కంటే, ఇది మరింత సమర్థవంతమైనది (ఒక కీ, వ్యక్తిగతంగా accessible fields) మరియు user profiles లేదా session objects వంటి నిర్మితమైన డేటా సంరక్షించడానికి సంఘటితమైనది; వ్యక్తిగత fields లను చదవడానికి/రాయడానికి మరియు numeric fields (`HINCRBY`) లను సమర్థవంతంగా incremented చేయడానికి సామర్థ్యం hashes ను entity storage కోసం ఆచరణీయమైనదిగా చేస్తుంది. **Sets** **ప్రత్యేక సంగ్రహాలు వేగవంతమైన సభ్యత్వ పరీక్షతో** కలిపి అందిస్తాయి — tags, ప్రత్యేక items ట్రాకింగ్ (ప్రత్యేక visitors, చూసిన items), మరియు "ఇది ఉందా?" పరీక్షల కోసం ఆదర్శవంతమైనది (`SISMEMBER` O(1) లో) — చాలా అనువర్తనాలలో సాధారణ అవసరాలు.

ప్రత్యేకంగా శక్తివంతమైనవి **సెట్ ఆపరేషన్‌లు** (intersection, union, difference) sets మధ్య సంబంధాలను సమర్థవంతంగా గణిస్తాయి — "పరస్పర స్నేహితులు" (follow sets యొక్క intersection), "సాధారణ ఆసక్తులు", మరియు సిఫారసులు నేరుగా Redis లో చేతిలో లేనిదిగా ఉండే features ను చేతికి చేస్తుంది.

ప్రతిదాన్ని ఉపయోగించాలో అర్థం చేసుకోవడం (hashes objects/records కోసం, sets ప్రత్యేక సంగ్రహాలు మరియు సంబంధ గణనల కోసం) సరైన Redis నిర్మాణాన్ని ఎంచుకోవటం భాగం.

Objects సంరక్షించడం మరియు ప్రత్యేక సంగ్రహాలు/సంబంధాలను నిర్వహించడం సాధారణ అవసరాలు కాబట్టి, మరియు hashes (సమర్థవంతమైన object storage కోసం) మరియు sets (ప్రత్యేక సంగ్రహాల కోసం, వేగవంతమైన సభ్యత్వ, మరియు శక్తివంతమైన సెట్ ఆపరేషన్‌ల) వాటిని సహజంగా సంబోధిస్తాయి, Redis లో డేటా సమర్థవంతంగా మోడల్ చేయడానికి Redis hashes మరియు sets అర్థం చేసుకోవడం విలువైన, ఆచరణీయమైన సంబంధిత జ్ఞానం, simple key-value storage మీద Redis versatile చేసే కోర్ డేటా నిర్మాణాలలో రెండు.