Redis-ல் Lua scripting எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Redis **Lua scripts**-ஐ server-side-ல் execute செய்ய முடியும் — பல commands-ஐ ஒரு **atomic** operation-ஆக run செய்கிறது. Scripts சிக்கலான atomic logic-ஐ enable செய்கிறது, network round-trips-ஐ குறைக்கிறது, மேலும் Redis-ல் multi-step atomic operations செய்வதற்கான recommended way ஆகும்.

## Lua script-ஐ run செய்தல்

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

Scripts `redis.call()`-ஐ பயன்படுத்தி commands-ஐ run செய்கிறது, `KEYS[]` (key names) மற்றும் `ARGV[]` (arguments) pass செய்யப்படுகிறது. முழு script **atomically** ஒரு unit-ஆக execute ஆகிறது.

## Scripts atomic ஆகவும் useful-ஆகவும் இருப்பது ஏன்

```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 — scripts-ஐ cache செய்தல்

```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` முன்பு load செய்யப்பட்ட script-ஐ அதன் hash-ஆல் run செய்கிறது — frequently-used scripts-க்கு efficient (script server-side-ல் cached ஆகிறது).

## Cautions

```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 scripting-ஐ புரிந்துகொள்ளுதல் **சிக்கலான atomic operations perform செய்வது**க்கான valuable senior-level knowledge ஆகும், எனவே advanced Redis use-க்கு useful ஆகும்.

மূல value ஆனது **multi-step logic-க்கான atomicity**: ஒரு Lua script **முழுவதுமாக ஒரு atomic unit**-ஆக execute ஆகிறது (வேறு commands interleave ஆவதில்லை), இது read-modify-write operations-ஐ atomic ஆக செய்வதற்கான recommended way ஆகிறது — conditional updates, safe lock release (token match செய்தால் மட்டுமே delete), rate limiting, மற்றும் complex counters போன்றவை — பெரும்பாலும் `MULTI`/`EXEC`-க்கு மேலாக ஆகும் ஏனெனில் scripts **conditional logic**-ஐ support செய்கிறது (transaction intermediate reads-ஐ based-ஆக decisions செய்ய முடியாது, ஆனால் script செய்ய முடியும்).

இது multi-step logic-க்கான atomic operations-ன் real need-ஐ solve செய்கிறது.

ஒரு secondary benefit ஆனது **fewer network round-trips** (ஒரு call-ல் multiple operations, latency-ஐ குறைக்கிறது) மற்றும் **custom logic server-side**-ல் run செய்தல் (data-க்கு near).

**`EVALSHA`**-ஐ புரிந்துகொள்ளுதல் (scripts-ஐ hash-ஆல் cache செய்வது அவற்றை resend செய்வதை தவிர்க்க) frequently-used scripts-க்கான practical efficiency technique ஆகும்.

சிறப்பாக, **cautions**-ஐ புரிந்துகொள்ளுதல் முக்கியமாகும்: scripts **single-threaded server-ஐ block** செய்கிறது run செய்யும் போது, எனவே அவை fast மற்றும் simple ஆக வைக்கப்பட வேண்டும் (slow script அனைத்து clients-ஐ stall செய்கிறது — real performance hazard), மற்றும் scripts deterministic ஆக இருக்க வேண்டும் keys `KEYS[]`-ல் pass செய்யப்பட்டு (cluster correctness-க்கு).

இந்த awareness scripts-ஐ heavy computation-க்கு misuse செய்வதை தடுக்கிறது.

Complex atomic operations ஒரு genuine need ஆக இருப்பதால் (locks, conditional logic, atomic multi-step updates), மற்றும் Lua scripts atomic, single-round-trip, server-side logic-ஐ provide செய்வதால் அவை recommended approach ஆகும் அவற்றுக்கு (blocking பற்றிய important cautions-உடன்), Lua scripting-ஐ புரிந்துகொள்ளுதல் — அது எவ்வாறு செயல்படுகிறது, ஏன் atomic மற்றும் useful, EVALSHA caching, மற்றும் keep-it-fast cautions — advanced Redis use-க்கான valuable senior-level knowledge ஆகும், atomic multi-step logic-க்கான right tool மற்றும் deeper Redis expertise-ஐ reflecting topic ஆகும்.