Redis ਵਿੱਚ Lua ਸਕ੍ਰਿਪਟਿੰਗ ਕਿਵੇਂ ਕਾਰਜ ਕਰਦੀ ਹੈ?

Question

Accepted Answer

Redis ਸਰਵਰ-ਸਾਈਡ **Lua ਸਕ੍ਰਿਪਟਾਂ** ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ — ਮਲਟੀਪਲ ਕਮਾਂਡਾਂ ਨੂੰ ਇੱਕ **atomic** ਓਪਰੇਸ਼ਨ ਵਜੋਂ ਚਲਾਉਂਦਾ ਹੈ। ਸਕ੍ਰਿਪਟਾਂ ਕੰਪਲੈਕਸ atomic logic ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦੀਆਂ ਹਨ, ਨੈੱਟਵਰਕ ਰਾਊਂਡ-ਟ੍ਰਿਪਸ ਨੂੰ ਘਟਾਉਂਦੀਆਂ ਹਨ, ਅਤੇ Redis ਵਿੱਚ multi-step atomic ਓਪਰੇਸ਼ਨਸ ਕਰਨ ਦਾ ਸਿਫਾਰਸ਼ ਕੀਤਾ ਤਰੀਕਾ ਹਨ।

## Lua ਸਕ੍ਰਿਪਟ ਚਲਾਉਣਾ

```bash
# EVAL runs a Lua script; KEYS[] and ARGV[] pass keys and arguments
EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 mykey myvalue

# a script can run multiple commands and logic atomically
EVAL "
  local current = redis.call('GET', KEYS[1])
  if current == ARGV[1] then
    return redis.call('DEL', KEYS[1])   -- delete only if value matches (atomic check-and-delete)
  end
  return 0
" 1 lock:resource mytoken
```

ਸਕ੍ਰਿਪਟਾਂ `redis.call()` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਮਾਂਡਾਂ ਨੂੰ ਚਲਾਉਂਦੀਆਂ ਹਨ, `KEYS[]` (key ਨਾਮ) ਅਤੇ `ARGV[]` (ਆਰਗੂਮੈਂਟਾਂ) ਦੇ ਨਾਲ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਪੂਰੀ ਸਕ੍ਰਿਪਟ **atomically** ਇੱਕ ਯੂਨਿਟ ਵਜੋਂ ਚਲਦੀ ਹੈ।

## ਕਿਉਂ ਸਕ੍ਰਿਪਟਾਂ atomic ਅਤੇ ਲਾਭਕਾਰੀ ਹਨ

```text
✓ ATOMICITY — the ENTIRE script runs as one unit, no other commands interleave
  → perfect for read-modify-write logic that must be atomic (locks, conditional updates,
    rate limiting, complex counters) — better than MULTI/EXEC for conditional logic
✓ FEWER ROUND-TRIPS — multiple operations in ONE call to Redis (less network latency)
✓ Custom LOGIC server-side — conditionals, loops, computations near the data
```

## EVALSHA — ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਕੈਸ਼ ਕਰਨਾ

```bash
# load a script once, then call by its SHA hash (avoids resending the script each time)
SCRIPT LOAD "return redis.call('GET', KEYS[1])"   # => returns a SHA1 hash
EVALSHA <sha> 1 mykey                              # run the cached script by hash
```

`EVALSHA` ਪਹਿਲਾਂ-ਲੋਡ ਕੀਤੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸਦੇ hash ਦੁਆਰਾ ਚਲਾਉਂਦਾ ਹੈ — ਅਕਸਰ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਕੁਸ਼ਲ (ਸਕ੍ਰਿਪਟ ਸਰਵਰ-ਸਾਈਡ ਕੈਸ਼ ਹੋਈ ਹੁੰਦੀ ਹੈ)।

## ਸਾਵਧਾਨੀਆਂ

```text
⚠️ Scripts BLOCK the server while running (Redis is single-threaded) → keep them FAST
   and simple (no slow loops/operations — they'd stall ALL clients)
⚠️ Scripts should be deterministic; pass keys via KEYS[] (for cluster correctness)
→ Use scripts for short, atomic logic — not heavy computation.
```

## ਇਸ ਦੀ ਮਹੱਤਤਾ

Redis ਵਿੱਚ Lua ਸਕ੍ਰਿਪਟਿੰਗ ਨੂੰ ਸਮਝਣਾ **complex atomic ਓਪਰੇਸ਼ਨਸ ਪ੍ਰਦਰਸ਼ਤ ਕਰਨ ਲਈ** ਸੀਨੀਅਰ-ਲੈਵਲ ਦਾ ਜਾਣਕਾਰੀ ਹੈ, ਇਸਲਈ ਇਹ ਐਡਵਾਂਸਡ Redis ਵਰਤੋਂ ਲਈ ਲਾਭਕਾਰੀ ਹੈ।

ਮੂਲ ਮੁੱਲ **multi-step logic ਲਈ atomicity** ਹੈ: ਇੱਕ Lua ਸਕ੍ਰਿਪਟ **ਪੂਰੀ ਤਰ੍ਹਾਂ ਇੱਕ atomic ਯੂਨਿਟ ਵਜੋਂ** ਚਲਦੀ ਹੈ (ਕੋਈ ਹੋਰ ਕਮਾਂਡਾਂ ਦਖਲ ਨਹੀਂ ਦਿੰਦੀਆਂ), ਇਸ ਕਾਰਨ ਇਹ ਖੋਜ-ਸੋਧ-ਲਿਖੋ ਓਪਰੇਸ਼ਨਸ ਕਰਨ ਲਈ ਸਿਫਾਰਸ਼ ਕੀਤਾ ਤਰੀਕਾ ਹੈ ਜੋ atomic ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ — ਜਿਵੇਂ ਕਿ ਕੰਡੀਸ਼ਨਲ ਅਪਡੇਟਸ, ਸੁਰੱਖਿਅਤ lock ਰਿਲੀਜ਼ (token ਮੇਲ ਹੋਣ ਸਿਰਫ ਫਿਰ ਹਟਾਓ), rate limiting, ਅਤੇ ਕੰਪਲੈਕਸ counters — ਅਕਸਰ `MULTI`/`EXEC` ਨਾਲੋਂ ਬਿਹਤਰ ਹੈ ਕਿਉਂਕਿ ਸਕ੍ਰਿਪਟਾਂ **ਕੰਡੀਸ਼ਨਲ logic** ਨੂੰ ਸਪੋਰਟ ਕਰਦੀਆਂ ਹਨ (ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿਚਕਾਰਲੀ ਖੋਜਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਫੈਸਲੇ ਨਹੀਂ ਲੈ ਸਕਦੇ, ਪਰ ਇੱਕ ਸਕ੍ਰਿਪਟ ਕਰ ਸਕਦੀ ਹੈ)।

ਇਹ atomic ਓਪਰੇਸ਼ਨਸ ਦੀ ਅਸਲ ਲੋੜ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ ਜੋ ਸਿੰਗਲ ਕਮਾਂਡਾਂ ਨਾਲੋਂ ਜਿਆਦਾ ਕੰਪਲੈਕਸ ਹੋਵੇ।

ਇੱਕ ਸੈਕਿਂਡਰੀ ਲਾਭ **ਘੱਟ ਨੈੱਟਵਰਕ ਰਾਊਂਡ-ਟ੍ਰਿਪਸ** ਹਨ (ਮਲਟੀਪਲ ਓਪਰੇਸ਼ਨਸ ਇੱਕ ਕਾਲ ਵਿੱਚ, latency ਘਟਾਉਂਦੇ ਹੋਏ) ਅਤੇ **ਸਰਵਰ-ਸਾਈਡ ਕਸਟਮ logic ਚਲਾਉਣਾ** (ਡੇਟਾ ਦੇ ਨਿਕਟ)।

**`EVALSHA`** ਨੂੰ ਸਮਝਣਾ (ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ hash ਦੁਆਰਾ ਕੈਸ਼ ਕਰਨਾ ਜਾਂ ਉਹਨਾਂ ਨੂੰ ਦੁਬਾਰਾ ਭੇਜਣਾ ਤੋਂ ਬਚਨਾ) ਅਕਸਰ-ਵਰਤੀ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਇੱਕ ਵਿਹਾਰਕ ਕੁਸ਼ਲਤਾ ਤਕਨੀਕ ਹੈ।

ਗੰਭੀਰ ਤੌਰ ਤੇ, **ਸਾਵਧਾਨੀਆਂ** ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ: ਸਕ੍ਰਿਪਟਾਂ ਚੱਲ ਰਹੀਆਂ ਹੋਣ ਦੌਰਾਨ **single-threaded ਸਰਵਰ ਨੂੰ ਬਲੌਕ ਕਰਦੀਆਂ ਹਨ**, ਇਸਲਈ ਉਹਨਾਂ ਨੂੰ ਤੇਜ਼ ਅਤੇ ਸਾਦੀ ਰਖੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ (ਇੱਕ ਹੌਲੀ ਸਕ੍ਰਿਪਟ ਸਾਰੇ ਕਲਾਂਟਸ ਨੂੰ ਰੋਕ ਦਿੰਦੀ ਹੈ — ਇੱਕ ਸਾਧਾਰਨ performance ਖਤਰਾ), ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ deterministic ਹੋਣੀ ਚਾਹੀਦੀਆਂ ਹਨ keys ਦੇ ਨਾਲ `KEYS[]` ਦੇ ਰਾਹੀਂ ਪਾਸ ਕੀਤੀਆਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ (cluster ਸਹੀਪਣ ਲਈ)।

ਇਹ ਸਭਿਆਚਤਾ ਭਾਰੀ computation ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਗਲਤ ਵਰਤੋਂ ਨੂੰ ਰੋਕਦੀ ਹੈ।

COMPLEX atomic ਓਪਰੇਸ਼ਨਸ ਇੱਕ ਖੋਜੀ ਲੋੜ ਹਨ (locks, ਕੰਡੀਸ਼ਨਲ logic, atomic multi-step ਅਪਡੇਟਸ), ਅਤੇ ਕਿਉਂ Lua ਸਕ੍ਰਿਪਟਾਂ atomic, ਸਿੰਗਲ-ਰਾਊਂਡ-ਟ੍ਰਿਪ, ਸਰਵਰ-ਸਾਈਡ logic ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ ਜੋ ਉਹਨਾਂ ਲਈ ਸਿਫਾਰਸ਼ ਕੀਤਾ ਤਰੀਕਾ ਹੈ (ਤੇਜ਼ ਰੱਖਣ ਦੀਆਂ ਮਹੱਤਵਪੂਰਨ ਸਾਵਧਾਨੀਆਂ ਦੇ ਨਾਲ), Lua ਸਕ੍ਰਿਪਟਿੰਗ ਨੂੰ ਸਮਝਣਾ — ਇਹ ਕੰਮ ਕਿਵੇਂ ਕਰਦੀ ਹੈ, ਕਿਉਂ ਇਹ atomic ਅਤੇ ਲਾਭਕਾਰੀ ਹੈ, EVALSHA ਕੈਸ਼ਿੰਗ, ਅਤੇ ਸਧਾਂ-ਰੱਖੋ ਸਾਵਧਾਨੀਆਂ — ਸੀਨੀਅਰ-ਲੈਵਲ ਜਾਣਕਾਰੀ ਹੈ advanced Redis ਵਰਤੋਂ ਲਈ, atomic multi-step logic ਲਈ ਸਹੀ ਟੂਲ ਹੈ ਅਤੇ ਇੱਕ ਟਾਪਿਕ ਜੋ ਡਿੱਪਰ Redis ਜਾਣਕਾਰੀ ਨੂੰ ਪ੍ਰਦਰਸ਼ਤ ਕਰਦਾ ਹੈ।