---
title: "PostgreSQL 19: REPACK, Plan Advice, JIT Off y Guía"
description: "PostgreSQL 19 salió el 19 nov 2026 con REPACK (CONCURRENTLY), pg_plan_advice, WAIT FOR LSN, JIT desactivado y LZ4 en TOAST. Probado en Docker."
date: 2026-11-20
categories: ["self-hosting"]
tags: ["postgresql","docker","self-hosted"]
---

PostgreSQL 19 salió el 19 de noviembre de 2026, unos dos meses más tarde de su ventana habitual de septiembre después de que el equipo principal pasara el otoño lidiando con una oleada de reportes de fallos generados con IA. La espera mereció la pena. A nivel operativo es la versión más útil de Postgres en varios años.

Dos cambios lo resumen bien: `REPACK (CONCURRENTLY)` permite por fin recuperar espacio muerto en tablas desde el propio núcleo sin bloquear lecturas ni escrituras, y `jit` viene desactivado por defecto tras años provocando picos de latencia inesperados en cargas OLTP. Detrás de esos dos llegan `pg_plan_advice`, `WAIT FOR LSN` para lecturas consistentes en réplicas, replicación lógica sin reiniciar el servidor, `INSERT ... ON CONFLICT DO SELECT`, salida JSON en `COPY` y `lz4` como compresión TOAST predeterminada.

Levanté hoy un contenedor `postgres:19-alpine` en Docker y probé cada función de esta guía para darte SQL real, salidas de `EXPLAIN` verificadas y las trampas que pasan desapercibidas en las [notas oficiales de la versión](https://www.postgresql.org/docs/release/19.0/).

## Qué cambió por defecto en PostgreSQL 19

Antes de probar comandos nuevos, revisa los valores por defecto que cambiaron por debajo. Todos los datos de esta tabla salen de `pg_settings` en un contenedor `postgres:19-alpine` recién iniciado:

| Parámetro | Por defecto PG 18 | Por defecto PG 19 | Por qué importa |
|---|---|---|---|
| `jit` | `on` | `off` | Evita picos de compilación JIT en consultas OLTP; cargas analíticas deben reactivarlo |
| `default_toast_compression` | `pglz` | `lz4` | Compresión y descompresión más rápidas para columnas grandes si está compilado con LZ4 |
| `log_lock_waits` | `off` | `on` | Las esperas largas por bloqueos aparecen en los logs desde el primer día |
| `max_locks_per_transaction` | `64` | `128` | Cambió el cálculo de la tabla de bloqueos; duplica tu valor anterior si lo ajustaste |
| `io_workers` | `3` | eliminado | Sustituido por `io_min_workers` (`2`) e `io_max_workers` (`8`) con escalado automático |
| `autovacuum_max_parallel_workers` | n/a | `0` | El vacuum paralelo de índices en autovacuum es opcional; sube este valor para usarlo |
| `md5_password_warnings` | n/a | `on` | Registra un aviso de obsolescencia tras cada inicio de sesión con MD5 |
| `standard_conforming_strings` | `on` (editable) | `on` (fijo) | Desactivarlo ya no está soportado en el servidor |

**Dos trampas de configuración antes de cambiar la etiqueta del contenedor**

Primero: si tu `postgresql.conf` define `io_workers`, PostgreSQL 19 no arrancará porque el parámetro desapareció en favor de `io_min_workers` e `io_max_workers`. Segundo: `postgres:19-alpine` usa `PGDATA=/var/lib/postgresql/19/docker`, igual que la 18. Monta `/var/lib/postgresql` en Docker Compose y no `/var/lib/postgresql/data`, o perderás los datos la próxima vez que recrees el contenedor.

## Prueba PostgreSQL 19 primero en Docker

Si quieres ejecutar las consultas de esta guía sin tocar un servidor real, guarda este archivo como `compose.yaml` en una carpeta temporal:

```yaml
services:
  postgres:
    image: postgres:19-alpine
    container_name: pg19-lab
    restart: unless-stopped
    ports:
      - "127.0.0.1:5432:5432"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: change-me-locally
      POSTGRES_DB: demo
    volumes:
      - pg19_data:/var/lib/postgresql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d demo"]
      interval: 5s
      timeout: 5s
      retries: 5

volumes:
  pg19_data:
```

Arráncalo y comprueba la versión:

```bash
docker compose up -d
docker compose exec postgres psql -U postgres -d demo -c "SELECT version();"
```

Deberías ver `PostgreSQL 19.0`. Vincular el puerto a `127.0.0.1` evita exponerlo a internet; recuerda que [Docker se salta el firewall UFW](/es/docker-evita-firewall/) si publicas `5432:5432` sin interfaz. Para entornos reales saca la contraseña de las variables de entorno con [secretos en Docker Compose](/es/secretos-docker-compose/), y si quieres alojar varias bases de datos en un solo contenedor, el patrón de script de inicialización de mi guía sobre [múltiples bases de datos Postgres en Docker](/es/multiples-bases-datos-postgres-docker/) funciona igual en la 19.

## REPACK (CONCURRENTLY): recupera espacio sin bloquear la tabla

Las tablas con muchos `UPDATE` y `DELETE` acumulan espacio muerto (bloat). El `VACUUM` normal marca esos huecos como reutilizables, pero casi nunca devuelve espacio al sistema operativo. Hasta ahora, en Postgres puro solo tenías `VACUUM FULL` y `CLUSTER`, y ambos toman un bloqueo `ACCESS EXCLUSIVE` durante toda la reescritura. En una tabla de 40 GB eso obligaba a abrir ventana de mantenimiento o instalar la extensión externa `pg_repack`.

PostgreSQL 19 mete ese flujo en el núcleo con `REPACK` (que sustituye tanto a `VACUUM FULL` como a `CLUSTER`, aunque los nombres antiguos se mantienen por compatibilidad). Con `CONCURRENTLY`, la tabla se reescribe en segundo plano bajo un bloqueo `SHARE UPDATE EXCLUSIVE` y solo pide un breve `ACCESS EXCLUSIVE` al final para intercambiar los archivos.

Lo probé con una tabla de 50,000 filas en `postgres:19-alpine`, borré la mitad y ejecuté `REPACK (CONCURRENTLY)` reordenando por índice:

```sql
CREATE TABLE orders (
  id bigserial PRIMARY KEY,
  customer_id int NOT NULL,
  payload text NOT NULL
);
CREATE INDEX idx_orders_customer ON orders (customer_id);

INSERT INTO orders (customer_id, payload)
SELECT (g % 500) + 1, repeat('x', 200)
FROM generate_series(1, 50000) AS g;

DELETE FROM orders WHERE id % 2 = 0;

SELECT pg_size_pretty(pg_relation_size('orders')) AS before_repack,
       pg_size_pretty(pg_total_relation_size('orders')) AS total_before;
```

Antes de reempaquetar, `orders` ocupaba `12 MB` (`13 MB` con índices). Después ejecuté:

```sql
REPACK (CONCURRENTLY) orders USING INDEX idx_orders_customer;
```

Al terminar, `pg_relation_size('orders')` bajó a `6144 kB` (`6928 kB` en total). En trabajos largos puedes seguir el avance en tiempo real con la nueva vista `pg_stat_progress_repack`.

Cuatro límites reales que conviene tener claros antes de meter esto en un cron:

1. **La tabla necesita un índice de identidad.** Ejecutar `REPACK (CONCURRENTLY)` sobre una tabla sin clave primaria ni `REPLICA IDENTITY USING INDEX` falla al instante con `Relation "..." has no identity index`.
2. **No puede ejecutarse dentro de un bloque de transacción.** La mayoría de herramientas de migración envuelven los scripts en `BEGIN ... COMMIT` por defecto, así que lánzalo fuera de transacción, igual que `CREATE INDEX CONCURRENTLY`.
3. **Necesitas aproximadamente el doble de espacio en disco.** `REPACK` crea una copia nueva de la tabla y de todos sus índices antes de borrar los archivos viejos, más espacio temporal de ordenación si `USING INDEX` elige ordenar en disco.
4. **Ojo con transacciones concurrentes largas.** La documentación advierte que `REPACK (CONCURRENTLY)` no es seguro para MVCC: cualquier transacción que abrió su snapshot *antes* de iniciar el repack verá la tabla vacía cuando este haga commit. No lo lances mientras haya consultas largas de reporting abiertas.

## Fijar malos planes con pg_plan_advice y pg_stash_advice

Todo el que lleva tiempo con Postgres ha vivido esa tarde de martes en la que un `ANALYZE` mueve un poco las estimaciones de filas, el planificador cambia un nested loop por un hash join (o abandona un índice) y la latencia p99 se multiplica por diez. Antes había que tocar el SQL de la aplicación, pelearse con parámetros `enable_*` o instalar `pg_hint_plan`.

PostgreSQL 19 incluye dos módulos escritos por Robert Haas: `pg_plan_advice`, para describir y forzar decisiones del planificador con un mini-lenguaje compacto, y `pg_stash_advice`, para asociar esas indicaciones a un identificador de consulta de forma automática sin tocar el código de la app.

Para ver la cadena exacta que genera Postgres para una consulta, carga `pg_plan_advice` y pídesela a `EXPLAIN`:

```sql
LOAD 'pg_plan_advice';

EXPLAIN (PLAN_ADVICE)
SELECT o.id, o.customer_id
FROM orders o
WHERE o.customer_id = 42;
```

Salida real en nuestro contenedor Docker:

```text
 Bitmap Heap Scan on orders o  (cost=5.26..335.57 rows=125 width=12)
   Recheck Cond: (customer_id = 42)
   ->  Bitmap Index Scan on idx_orders_customer  (cost=0.00..5.22 rows=125 width=0)
         Index Cond: (customer_id = 42)
 Generated Plan Advice:
   BITMAP_HEAP_SCAN(o)
   NO_GATHER(o)
```

Fuerza un plan distinto en la sesión actual para probar alternativas:

```sql
SET pg_plan_advice.advice = 'SEQ_SCAN(o)';

EXPLAIN (COSTS OFF)
SELECT o.id, o.customer_id
FROM orders o
WHERE o.customer_id = 42;
```

```text
          QUERY PLAN
------------------------------
 Seq Scan on orders o
   Filter: (customer_id = 42)
 Supplied Plan Advice:
   SEQ_SCAN(o) /* matched */
```

Para aplicarlo automáticamente en producción sin redesplegar la aplicación, añade `pg_stash_advice` a `shared_preload_libraries`, reinicia Postgres y guarda la indicación con el `Query Identifier` que muestra `EXPLAIN (VERBOSE, PLAN_ADVICE)`:

```sql
CREATE EXTENSION pg_stash_advice;

-- Obtén el Query Identifier con EXPLAIN (VERBOSE, PLAN_ADVICE)
SELECT pg_create_advice_stash('prod');
SELECT pg_set_stashed_advice('prod', 4904561378319701717, 'BITMAP_HEAP_SCAN(items)');
ALTER DATABASE demo SET pg_stash_advice.stash_name = 'prod';
```

Mi opinión honesta: trata `pg_stash_advice` como un torniquete, no como rutina diaria. Es buenísimo cuando tienes una incidencia ardiendo y necesitas recuperar el plan anterior en 60 segundos. Dejar planes fijados para siempre solo esconde índices que faltan o estadísticas desactualizadas, y la propia documentación avisa de que evaluar plan advice añade coste al planificador incluso cuando no cambia el plan. Arregla la consulta o las estadísticas y borra el stash después.

## Mejoras de SQL que de verdad vas a usar

Buena parte de las novedades SQL de Postgres 19 eliminan código incómodo que llevábamos años rodeando con trucos. Si ya concentras varias piezas de tu stack en Postgres como cuento en [qué puede reemplazar Postgres](/es/que-reemplaza-postgres/), estas mejoras lo dejan aún más limpio.

### ON CONFLICT DO SELECT

El clásico patrón "obtener o crear" te obligaba antes a hacer dos viajes de red o un `DO UPDATE SET slug = EXCLUDED.slug` falso (que escribía tuplas muertas y WAL solo para que `RETURNING` devolviera la fila). Ahora existe `DO SELECT`:

```sql
CREATE TABLE tags (
  id bigserial PRIMARY KEY,
  slug text UNIQUE NOT NULL
);

INSERT INTO tags (slug) VALUES ('postgresql')
ON CONFLICT (slug) DO SELECT RETURNING id, slug;

-- La segunda ejecución detecta el conflicto y devuelve la fila sin escribir tuplas muertas
INSERT INTO tags (slug) VALUES ('postgresql')
ON CONFLICT (slug) DO SELECT RETURNING id, slug;
```

Si necesitas bloquear la fila existente durante el resto de la transacción, añade `FOR UPDATE` o `FOR SHARE` (`ON CONFLICT (slug) DO SELECT FOR UPDATE RETURNING id, slug`).

### COPY JSON y ON_ERROR

`COPY TO` exporta ahora JSON directamente, línea por línea o envuelto en un único array con `FORCE_ARRAY`:

```sql
COPY (SELECT id, slug FROM tags) TO STDOUT (FORMAT json);
-- {"id":1,"slug":"postgresql"}

COPY (SELECT id, slug FROM tags) TO STDOUT (FORMAT json, FORCE_ARRAY);
-- [{"id":1,"slug":"postgresql"}]
```

`COPY TO` también funciona directamente sobre tablas particionadas sin tener que envolverlas en `COPY (SELECT * FROM ...)`. Al importar, `COPY FROM` permite saltar varias cabeceras (`HEADER 2`) y convertir valores mal formados en `NULL` en lugar de abortar toda la carga:

```sql
CREATE TABLE imports (id int, amount int);

COPY imports FROM STDIN (FORMAT csv, HEADER 2, ON_ERROR set_null);
# Exported from billing
id,amount
1,500
2,not_a_number
3,750
\.
-- NOTICE:  in 1 row, columns were set to null due to data type incompatibility
-- La fila 2 entra con amount = NULL sin tumbar la importación
```

### Ventanas IGNORE NULLS

Rellenar huecos en series temporales con SQL solía requerir trucos feos con `COUNT()` particionados. Ahora `lead()`, `lag()`, `first_value()`, `last_value()` y `nth_value()` aceptan `IGNORE NULLS`:

```sql
CREATE TABLE metrics (day date, price numeric);
INSERT INTO metrics VALUES
  ('2026-11-01', 100),
  ('2026-11-02', NULL),
  ('2026-11-03', NULL),
  ('2026-11-04', 115),
  ('2026-11-05', NULL);

SELECT day,
       price,
       last_value(price) IGNORE NULLS OVER (ORDER BY day) AS filled_price
FROM metrics
ORDER BY day;
```

Las filas 2 y 3 arrastran `100` limpiamente; la fila 5 arrastra `115`.

### jsonpath, random y base64url

Tres pequeños añadidos que quitan código pegamento:

```sql
-- Nuevos métodos de texto en jsonpath: ltrim, rtrim, btrim, lower, upper, initcap, replace, split_part
SELECT jsonb_path_query(
  '{"email": "  Admin@Bitdoze.COM  "}',
  '$.email.btrim().lower()'
);
-- "admin@bitdoze.com"

-- Fechas y timestamps aleatorios sin aritmética de epochs
SELECT random('2026-01-01'::date, '2026-12-31'::date);

-- base64url apto para URLs y base32hex ordenable de serie
SELECT encode(E'\\x68656c6c6f3f'::bytea, 'base64url');
-- aGVsbG8_
```

## Replicación y réplicas: slots lógicos sin reinicio y WAIT FOR LSN

Dos dolores de cabeza clásicos de la replicación desaparecen en PostgreSQL 19.

### Activar replicación lógica sin reiniciar Postgres

Antes de la 19, configurar CDC o una réplica lógica implicaba cambiar `wal_level = logical` y reiniciar el servidor. Ahora, mientras `wal_level` esté en `replica` (el valor por defecto), crear el primer slot de replicación lógica eleva automáticamente `effective_wal_level` a `logical`. Borras el último slot y vuelve solo a `replica`.

Esta es la secuencia exacta que ejecuté en Docker sin ningún reinicio:

```sql
SHOW wal_level;           -- replica
SHOW effective_wal_level; -- replica

SELECT slot_name, lsn FROM pg_create_logical_replication_slot('test_slot', 'pgoutput');
SHOW effective_wal_level; -- logical

SELECT pg_drop_replication_slot('test_slot');
SHOW effective_wal_level; -- replica
```

La replicación lógica suma además dos peticiones pendientes desde Postgres 10:

- **Replicación de secuencias** con `CREATE PUBLICATION seq_pub FOR ALL SEQUENCES;` y `ALTER SUBSCRIPTION ... REFRESH SEQUENCES`. Los failovers ya no se arriesgan a colisiones de claves primarias por secuencias desfasadas.
- **Excluir tablas ruidosas** dentro de `FOR ALL TABLES` con `EXCEPT`:

```sql
CREATE PUBLICATION app_pub FOR ALL TABLES EXCEPT (TABLE audit_scratch);
```

Fíjate en que `TABLE` va *dentro* de los paréntesis. Al primer intento en `psql` lo puse fuera y saltó error de sintaxis, así que quédate con la forma de arriba.

### Consistencia read-your-writes en réplicas con WAIT FOR LSN

Cuando una aplicación escribe en el primario y lee de una réplica en streaming, siempre existe una pequeña ventana de retardo en la que un usuario guarda un cambio, recarga y ve el dato viejo. PostgreSQL 19 añade `WAIT FOR LSN` en réplicas para que la sesión espere hasta que el WAL haya reproducido la posición exacta de la escritura.

En el primario tras escribir:

```sql
UPDATE orders SET payload = 'shipped' WHERE id = 101;
SELECT pg_current_wal_insert_lsn();
-- devuelve p. ej. 0/038D7788 (guárdalo en sesión o cookie firmada)
```

En la réplica antes de leer:

```sql
WAIT FOR LSN '0/038D7788' WITH (TIMEOUT '100ms', NO_THROW);
SELECT payload FROM orders WHERE id = 101;
```

Sin `NO_THROW`, agotar el timeout lanza un error para que tu aplicación pueda redirigir la lectura al primario. También puedes pasar `MODE` (`standby_replay`, `standby_write`, `standby_flush` o `primary_flush`).

## Rendimiento, monitorización y TLS SNI en servidor

### Velocidad y valores por defecto más sensatos

Desactivar `jit` por defecto es el cambio que más notarán los servidores autoalojados. En consultas pequeñas y medianas, compilar con LLVM JIT solía gastar más CPU de la que ahorraba en cuanto la estimación cruzaba `jit_above_cost`. Dejarlo apagado quita un ajuste que yo metía en todos los `postgresql.conf` de producción desde Postgres 14. Si mueves un data warehouse o agregaciones analíticas pesadas, activa `jit = on` para ese rol o base de datos.

Cualquier compilación de PostgreSQL 19 con soporte LZ4, incluidas las imágenes oficiales de Docker, usa ahora `default_toast_compression = lz4` en lugar de `pglz`. Las columnas anchas de tipo `text` y `jsonb` se comprimen y descomprimen mucho más rápido casi sin gasto de CPU.

En almacenamiento, PostgreSQL 19 amplía la capa de E/S asíncrona de la 18: `io_method = worker` ajusta ahora los workers de fondo automáticamente entre `io_min_workers` (2) e `io_max_workers` (8), y cierra los inactivos tras `io_worker_idle_timeout` (60 segundos). Autovacuum también gana limpieza paralela de índices y un sistema de puntuación que puedes consultar en `pg_stat_autovacuum_scores`. Un detalle: `autovacuum_max_parallel_workers` viene en `0`, así que súbelo (o configura `autovacuum_parallel_workers` por tabla) si tienes tablas con muchos índices que se quedan atrás.

Otras mejoras llegan sin tocar nada: `NOT IN (SELECT ...)` se convierte en anti-join cuando las columnas son `NOT NULL` (comprobado como `Merge Anti Join` en `EXPLAIN` sobre nuestra tabla `orders`), algunas agregaciones pueden ejecutarse antes de los joins para reducir filas intermedias, las comprobaciones de claves foráneas se reescribieron haciendo las inserciones masivas casi el doble de rápidas en pruebas, y `NOTIFY` ahora despierta solo a los backends suscritos al canal correspondiente.

### Observabilidad y TLS SNI

Depurar E/S lenta y bloqueos requiere menos adivinación en la 19. `EXPLAIN (ANALYZE, BUFFERS, IO)` imprime métricas de prefetch asíncrono directamente en el plan (`Prefetch: avg=1.00 max=1 capacity=94`), `pg_stat_lock` registra conteos y tiempos por tipo de bloqueo, y `pg_stat_recovery` muestra el estado de recuperación de la réplica. Además `log_lock_waits` viene en `on` por defecto, algo que llevaba años pendiente.

Para servidores multi-inquilino llega por fin TLS SNI en el servidor mediante `PGDATA/pg_hosts.conf`. Una sola instancia de Postgres puede presentar certificados TLS distintos según el dominio al que se conecte el cliente.

## Cambios incompatibles y checklist de actualización

Los saltos de versión mayor siguen pidiendo `pg_dumpall`, `pg_upgrade` o replicación lógica. Antes de subir un clúster 16, 17 o 18 a la 19, repasa esta lista:

- Haz una copia fuera del servidor primero. Si despliegas con Dokploy, deja automatizados los volcados con mi guía de [backups de Dokploy a Cloudflare R2](/es/backups-dokploy-cloudflare-r2/) antes de tocar la etiqueta del contenedor.

- Elimina io_workers de tus configs personalizados. Se retiró en la 19; cámbialo por io_min_workers e io_max_workers si ajustaste AIO en PG 18.

- Revisa tus extensiones antes de actualizar. Si dependes de pgvector (mira mi guía para [desplegar pgvector y pgAdmin en Docker](/es/desplegar-pgvector-pgadmin-docker/)), PostGIS o TimescaleDB, confirma primero que tu imagen Docker o paquete tiene compilación para PostgreSQL 19. El núcleo salió ayer; las extensiones suelen tardar unos días o semanas.

- Comprueba índices btree_gist en columnas inet/cidr. Esas clases de operadores tenían fallos y pg_upgrade rechazará el clúster si existen. Bórralos y recréalos con GiST estándar antes de migrar.

- Revisa contraseñas MD5 y RADIUS. La autenticación RADIUS se eliminó por completo. MD5 sigue funcionando de momento, pero genera avisos (md5_password_warnings = on) y desaparecerá; migra esos roles a scram-sha-256.

- Ojo con las rutas de volumen en Docker. Si saltas desde PG 17 o anterior en Docker, toca pasar de /var/lib/postgresql/data a /var/lib/postgresql además del dump/restore o pg_upgrade.

- Reindexa búsqueda de texto completo y pg_trgm en locales que no sean libc. Si usas proveedores ICU o builtin, la clasificación de caracteres cambió en la 19 y las notas recomiendan reindexar FTS/trigramas y recalcular columnas tsvector almacenadas tras pg_upgrade.

- Revisa max_locks_per_transaction y jit. Si configuraste max_locks_per_transaction a mano en versiones previas, duplícalo para conservar la misma capacidad. Si tienes cargas analíticas que dependían de JIT, pon jit = on explícitamente.

## ¿Conviene actualizar hoy?

Para desarrollo local, CI y proyectos nuevos que no dependan de extensiones externas sin paquete para la 19 todavía, sí. `postgres:19-alpine` ya está en Docker Hub y encaja sin problemas junto al resto de tu [stack de contenedores Docker en casa](/es/contenedores-docker-servidor-casa/).

En bases de datos de producción, espera a la 19.1 salvo que estés peleando ahora mismo con un problema que la 19 resuelve de raíz, como tablas infladas que no puedes bloquear con `VACUUM FULL` o un primario que no puedes reiniciar para activar replicación lógica. Toda versión `.0` de Postgres pule casos borde en su primera actualización menor, y las imágenes de extensiones como `pgvector` y PostGIS suelen ponerse al día en ese mismo margen. Aprovecha estas semanas para restaurar una copia de tu volcado de producción en `postgres:19-alpine` y comprobar tus planes con `jit = off`.

## Preguntas frecuentes

**¿REPACK (CONCURRENTLY) sustituye por completo a la extensión pg_repack?**

En la mayoría de tablas, sí. Recupera espacio muerto y puede reordenar filas según un índice sin bloquear lecturas ni escrituras, todo desde el núcleo sin compilar ni mantener una extensión externa. Ten presentes dos límites: la tabla sigue necesitando un índice de identidad (clave primaria o índice único no nulo) y necesitas espacio libre equivalente a la tabla más sus índices mientras dura la copia.

**¿Desactivar JIT por defecto hará más lenta mi base de datos?**

Para aplicaciones web, backends SaaS y herramientas autoalojadas (OLTP), apagar JIT suele mejorar la latencia de cola, no empeorarla. Muchos equipos ya forzaban `jit = off` en PG 14–18 porque el tiempo de compilación penalizaba consultas cortas y medias. Solo data warehouses y consultas analíticas pesadas suelen beneficiarse de reactivar `jit = on`.

**¿Puedo actualizar directo de PostgreSQL 16 o 17 a 19 en Docker?**

Sí, mediante `pg_dumpall` y restauración en un contenedor limpio de `postgres:19-alpine`, o usando `pg_upgrade` con una imagen multiversión. No puedes limitarte a cambiar la etiqueta en `compose.yaml` apuntando PostgreSQL 19 a un directorio de datos de la 16, 17 o 18. Recuerda que PostgreSQL 14 llegó al fin de soporte el 12 de noviembre de 2026, así que conviene priorizar la salida de la 14.

**¿Cómo activo el autovacuum paralelo en PostgreSQL 19?**

El vacuum paralelo de índices en autovacuum viene desactivado (`autovacuum_max_parallel_workers = 0`). Configura `autovacuum_max_parallel_workers` con un número mayor que cero (por ejemplo `2` o `4`, dentro de `max_parallel_workers`) en `postgresql.conf` o con `ALTER SYSTEM` y recarga. Puedes ver qué tablas prioriza autovacuum consultando `pg_stat_autovacuum_scores`.