Modelos de Consistência: strong, eventual, causal, read-your-writes

Operações de 3 clientes em paralelo:

Client A: ──── write(x=1) ─── [ack] ─────────────────────────────
Client B: ─────── read(x) ──────── [retorna 1] ──────────────────
Client C: ─────────────── read(x) ─────── [retorna 1] ───────────

Linearizability exige: tudo parece ter ocorrido em UM instante entre
início e fim de cada op, respeitando ordem real. Se B começou READ
APÓS o ack de A, B DEVE ver x=1.

Cenário clássico de chat:
  Alice posta:  "Acabei de me casar!"              (evento e1)
  Bob responde: "Parabéns!"                         (evento e2, depende de e1)

  Carol abre o app e lê os dois. Causal exige que Carol veja e1 ANTES de e2.
  Eventual não garante — Carol poderia ver só "Parabéns!" até o post chegar.
  Linearizability garante, mas cobra ordem total global — caro demais.

Vector clocks ou dependency tracking resolvem causal com custo razoável.

# Read-your-writes em Postgres com read replicas — pattern com LSN no cookie
import psycopg

def write(conn, user_id: str, bio: str) -> int:
    with conn.cursor() as cur:
        cur.execute("UPDATE users SET bio=%s WHERE id=%s RETURNING pg_current_wal_lsn()", (bio, user_id))
        lsn = cur.fetchone()[0]
    conn.commit()
    return lsn                 # envia para client (cookie/header)

def read(user_id: str, client_lsn: str | None) -> dict:
    # Se o client tem LSN, obrigue leitura em replica com replay >= LSN
    if client_lsn:
        replica = pick_replica_at_or_after(client_lsn)      # sua função de routing
        if not replica:
            replica = PRIMARY                                # fallback
    else:
        replica = pick_any_replica()
    with replica.cursor() as cur:
        cur.execute("SELECT bio FROM users WHERE id=%s", (user_id,))
        return {"bio": cur.fetchone()[0]}

# OR-Set simples (CRDT) — adiciona e remove sem perder operações concorrentes
from dataclasses import dataclass, field
import uuid

@dataclass
class ORSet:
    adds:    dict[str, set[str]] = field(default_factory=dict)   # item -> set de uids
    removes: dict[str, set[str]] = field(default_factory=dict)

    def add(self, item: str) -> None:
        uid = str(uuid.uuid4())
        self.adds.setdefault(item, set()).add(uid)

    def remove(self, item: str) -> None:
        for uid in self.adds.get(item, set()):
            self.removes.setdefault(item, set()).add(uid)

    def value(self) -> set[str]:
        return {
            it for it, uids in self.adds.items()
            if uids - self.removes.get(it, set())
        }

    def merge(self, other: "ORSet") -> "ORSet":
        r = ORSet()
        for it in set(self.adds) | set(other.adds):
            r.adds[it] = self.adds.get(it, set()) | other.adds.get(it, set())
        for it in set(self.removes) | set(other.removes):
            r.removes[it] = self.removes.get(it, set()) | other.removes.get(it, set())
        return r