Redis లో strings మరియు keys ఎలా పని చేస్తాయి?

Question

Accepted Answer

**Strings** అనేవి Redis యొక్క అత్యంత ప్రాథమిక విలువ రకం, మరియు **keys** Redis లోని అన్ని డేటాను గుర్తిస్తాయి. స్ట్రింగ్ కమాండ్‌లను (అటోమిక్ కౌంటర్‌లతో సహా) మరియు కీ సమావేశాలు/నిర్వహణను అర్థం చేసుకోవడం రోజువారీ Redis ఉపయోగానికి ప్రాథమికమైనది.

## String commands

```bash
SET name "Ann"              # set a value
GET name                    # => "Ann"
SET name "Bob" EX 60        # set with a 60-second expiry (TTL)
SETNX lock "1"              # set only if NOT exists (useful for locks)
MSET a "1" b "2"            # set multiple at once
APPEND name " Smith"        # append to a string
STRLEN name                 # string length
```

Strings టెక్స్ట్, సంఖ్యలు, లేదా బైనరీ డేటా (512MB వరకు) నిల్వ చేస్తాయి. అవి బహుముఖ — cached values, flags, serialized objects, మరియు counters కోసం ఉపయోగించబడతాయి.

## Atomic counters

```bash
SET views 0
INCR views                  # => 1 (atomic increment)
INCRBY views 10             # => 11
DECR views                  # decrement
# atomic — safe even with concurrent clients (no race conditions)
```

సంఖ్యలను కలిగి ఉన్న Strings **atomic increment/decrement** ను సపోర్ట్ చేస్తాయి — counters (page views, rate limits, IDs) కోసం ఆదర్శవంతమైనవి ఇవి సమకాలీన ప్రాప్తికి కూడా సరైనవి.

## Keys — naming and management

```bash
# convention: use colon-separated namespaces for organization
SET user:1000:name "Ann"      # user 1000's name
SET user:1000:email "ann@x.com"

EXISTS user:1000:name         # does the key exist? => 1
DEL user:1000:name            # delete a key
KEYS user:*                   # find keys by pattern (⚠️ slow on big DBs — avoid in prod)
SCAN 0 MATCH user:*           # iterate keys safely (preferred over KEYS)
TYPE user:1000                # the value's data type
RENAME oldkey newkey          # rename
```

**Key naming convention:** కోలన్-విభజిత namespaces (`user:1000:name`) keys లను తార్కికంగా నిర్వహిస్తాయి. **ముఖ్యమైనది:** production లో `KEYS` ని నివారించండి (ఇది అన్ని keys లను స్కాన్ చేస్తుంది, సర్వర్ బ్లాక్ చేస్తుంది) — సురక్షితమైన iteration కోసం `SCAN` ని ఉపయోగించండి.

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

Strings మరియు keys అనేవి రోజువారీ Redis ఉపయోగం యొక్క ఆధారం, కాబట్టి వాటిని అర్థం చేసుకోవడం అవసరం, తరచుగా ఉపయోగించే జ్ఞానం. **Strings** (Redis యొక్క అత్యంత ప్రాథమిక మరియు బహుముఖ విలువ రకం) నిరంతరం ఉపయోగించబడతాయి — cached values, flags, serialized data, మరియు ముఖ్యంగా **atomic counters** కోసం: atomic `INCR`/`DECR` కమాండ్‌లు strings లను సరిగ్గా గణించడానికి ఆదర్శవంతమైనవిగా చేస్తాయి (page views, rate limits, IDs) సమకాలీన ప్రాప్తి తో కూడా, race conditions లేకుండా — విలువైన, సాధారణంగా ఉపయోగించే సామర్థ్యం.

String commands (expiry కోసం `SET` తో సహా TTLs కోసం, `SETNX` set-if-not-exists కోసం ఇది locks కోసం ఉపయోగకరమైనది) అర్థం చేసుకోవడం రోజువారీ ఆచరణాత్మక జ్ఞానం. **Keys** అన్ని Redis డేటాను గుర్తిస్తాయి, మరియు **key management** అర్థం చేసుకోవడం సమానంగా ముఖ్యమైనది: కోలన్-విభజిత namespaces (`user:1000:name`) యొక్క **naming convention** keys లను తార్కికంగా నిర్వహించడానికి widely-used best practice, Redis డేటాను నిర్వహణీయంగా ఉంచుతుంది, మరియు key commands (`EXISTS`, `DEL`, `TYPE`, `RENAME`) తెలుసుకోవడం అవసరం.

ఎక్కువ ముఖ్యమైన ఆచరణాత్మక పాయింట్ **production లో `KEYS` నిర్ధారణ** (ఇది ప్రతి key ని స్కాన్ చేస్తుంది, ఏక-థ్రెడెడ్ సర్వర్ బ్లాక్ చేస్తుంది — నిజమైన performance/availability ప్రమాదం) అనుకూల **`SCAN`** సురక్షితమైన iteration కోసం — సాధారణ production pitfall తెలుసుకోవటానికి సరసరికైనది.

Strings మరియు keys వాస్తవంగా ప్రతి Redis ఇంటరঅ్యాక్షన్‌లో ఉంటాయి కాబట్టి, మరియు string commands (ముఖ్యంగా atomic counters), key naming conventions, మరియు key management (KEYS-vs-SCAN production concern తో సహా) అర్థం చేసుకోవడం Redis ను సరిగ్గా మరియు సురక్షితంగా ఉపయోగించడానికి ప్రాథమికమైనది, strings మరియు keys అర్థం చేసుకోవడం అవసరం, must-know knowledge రోజువారీ Redis కార్యం కోసం, Redis లో డేటా నిల్వ మరియు నిర్వహణ యొక్క ఆచరణాత్మక ఆధారం.