Cum funcționează tranzacțiile Redis?

Question

Accepted Answer

Tranzacțiile Redis (prin `MULTI`/`EXEC`) grupează mai multe comenzi pentru a se executa **atomic** — toate împreună, fără ca alte comenzi să se intercaleze. Combinate cu `WATCH` pentru optimistic locking, ele gestionează scenarii care necesită ca mai multe operații să fie consistente. Tranzacțiile Redis diferă de tranzacțiile SQL în moduri importante.

## MULTI / EXEC — enumerare în coadă și execuție atomică

```bash
MULTI                  # start a transaction (begin queuing commands)
SET account:1 100      # QUEUED (not executed yet)
SET account:2 200      # QUEUED
INCR counter           # QUEUED
EXEC                   # execute ALL queued commands atomically (as one unit)
# → all commands run together, with NO other client's commands in between
```

`MULTI` începe enumerarea în coadă a comenzilor; `EXEC` le execută pe toate atomic (fără intercalare de la alți clienți). `DISCARD` anulează o tranzacție enumerată în coadă.

## WATCH — optimistic locking (check-and-set)

```bash
# WATCH a key; if it CHANGES before EXEC, the transaction ABORTS (returns nil)
WATCH balance
val = GET balance              # read the current value
MULTI
SET balance (val - 100)        # modify based on what we read
EXEC                           # → if "balance" changed since WATCH, EXEC fails (returns nil)
# → retry the whole thing if it failed (optimistic concurrency control)
```

`WATCH` oferă **optimistic locking**: dacă o cheie observată este modificată de un alt client înainte de `EXEC`, tranzacția se abandoneaza — permițând ție să faci în siguranță operații check-then-set (reîncercare la conflict).

## Cum diferă tranzacțiile Redis de SQL

```text
⚠️ Redis transactions are NOT like SQL transactions:
  ✗ NO ROLLBACK — if a command fails at EXEC time, OTHER commands still execute
    (errors don't roll back the transaction; Redis doesn't undo). Only syntax errors
    before EXEC abort the whole thing.
  ✓ Atomicity = commands run together without interleaving (isolation), NOT all-or-nothing
    with rollback on error.
→ Often Lua SCRIPTS are used instead for complex atomic logic (a script runs atomically).
```

## De ce contează

Înțelegerea tranzacțiilor Redis este valoroasă pentru **efectuarea mai multor operații consistent**, deci este cunoaștere utilă — și înțelegerea modului în care diferă de tranzacțiile SQL este deosebit de importantă pentru a evita presupunerile incorecte.

Capacitatea fundamentală — `MULTI`/`EXEC` pentru a grupa comenzile pentru a se **executa atomic** (toate împreună, fără ca comenzile altor clienți să se intercaleze) — abordează scenarii în care mai multe operații trebuie să se întâmple ca o unitate consistentă.

Mecanismul **`WATCH`** oferă **optimistic locking** (check-and-set): abandonând tranzacția dacă o cheie observată s-a schimbat înainte de `EXEC`, permițând operații check-then-modify sigure (cum ar fi decrementarea unui sold pe baza valorii sale actuale) cu reîncercare la conflict — important pentru operații concurente corecte.

Punctul **cel mai critic** este înțelegerea modului în care tranzacțiile Redis **diferă de tranzacțiile SQL**: Redis **nu are rollback** — dacă o comandă eșuează la momentul `EXEC`, celelalte comenzi se execută tot (Redis nu anulează), deci „atomicitatea