¿Qué es MVCC en PostgreSQL?

Question

Accepted Answer

**MVCC** (Multi-Version Concurrency Control) es cómo PostgreSQL maneja el acceso concurrente — en lugar de bloquear filas para lecturas, mantiene **múltiples versiones** de filas, para que cada transacción vea un **snapshot** consistente de los datos. El beneficio clave: **los lectores no bloquean a los escritores, y los escritores no bloquean a los lectores**, permitiendo alta concurrencia.

## El concepto central: múltiples versiones de filas

```text
When a row is UPDATED, Postgres doesn't overwrite it — it creates a NEW version and
marks the old one obsolete. Different transactions can see different versions.
→ Each transaction sees a consistent SNAPSHOT of the database as of its start
  (depending on isolation level), unaffected by others' uncommitted changes.
```

## El gran beneficio: sin bloqueos de lectura

```text
Without MVCC (lock-based): readers and writers BLOCK each other
  → a long-running report could block writes; a write could block reads.
With MVCC:
  ✓ READERS DON'T BLOCK WRITERS — a SELECT sees an old version while an UPDATE proceeds
  ✓ WRITERS DON'T BLOCK READERS
  ✓ Each transaction sees a stable, consistent view (no dirty reads)
→ Much higher concurrency for read-heavy and mixed workloads.
```

## Cómo funciona (simplificado)

```sql
-- Transaction A starts a long SELECT (sees a snapshot)
BEGIN; SELECT count(*) FROM orders;   -- sees data as of its snapshot

-- meanwhile Transaction B updates rows — creates new versions, doesn't block A
-- A still sees its consistent snapshot; B's changes are a new version
```

Postgres rastrea IDs de transacciones y visibilidad de filas para que cada transacción vea la versión correcta. Esto proporciona **aislamiento** sin bloqueos de lectura.

## El costo: tuplas muertas y VACUUM

```text
MVCC creates obsolete row versions ("dead tuples") that accumulate → bloat.
VACUUM (and AUTOVACUUM) reclaims this dead space and keeps the database healthy.
→ This is why VACUUM is important in Postgres — it's the cleanup for MVCC's versions.
```

## Por qué es importante

MVCC es fundamental para comprender el comportamiento de concurrencia y el rendimiento de PostgreSQL, por lo que es conocimiento valioso para trabajar con Postgres de manera efectiva.

El valor central que proporciona MVCC es **alta concurrencia**: al mantener múltiples versiones de filas y dar a cada transacción un snapshot consistente, **los lectores no bloquean a los escritores y los escritores no bloquean a los lectores** — lo cual es una ventaja importante para aplicaciones reales (un reporte de larga duración no bloquea actualizaciones, y las escrituras no bloquean lecturas), permitiendo mucha mejor concurrencia para cargas de trabajo de lectura intensiva y mixtas que enfoques basados en bloqueos.

Esta es la razón por la cual PostgreSQL maneja el acceso concurrente tan bien, y entender MVCC explica las características de concurrencia de la base de datos (snapshots consistentes, aislamiento sin bloqueos de lectura, sin lecturas sucias).

De manera crucial, entender MVCC también explica **por qué `VACUUM` es importante en Postgres**: MVCC crea versiones de filas obsoletas ("tuplas muertas") cuando las filas se actualizan y se eliminan, que se acumulan como fragmentación, y `VACUUM`/`AUTOVACUUM` es el mecanismo de limpieza que recupera este espacio y mantiene la base de datos saludable — así que MVCC y VACUUM están íntimamente conectados, y conocer esta conexión es importante para el mantenimiento y rendimiento de la base de datos (descuidar vacuum conduce a fragmentación y rendimiento degradado, una preocupación operacional real).

Ya que el comportamiento de concurrencia afecta fundamentalmente cómo se desempeña una base de datos bajo carga, y ya que MVCC (el modelo de concurrencia de Postgres) explica tanto la excelente concurrencia de lectura/escritura como la necesidad de mantenimiento VACUUM, entender MVCC es conocimiento valioso para trabajar con PostgreSQL — aclara las ventajas de concurrencia de la base de datos y el mantenimiento que requiere, importante tanto para razonar sobre el rendimiento como para operar Postgres correctamente, y es un tema común que demuestra la comprensión de cómo Postgres maneja el acceso concurrente.