SQL Avanzado: 200 Comandos de Nivel Senior/DBA

Aquí el SQL se encuentra con la infraestructura. Estos 200 elementos son lo que se usa cuando la base ya está en producción, con volumen, concurrencia y alguien al teléfono preguntando por qué el informe está lento.

Plan de ejecución, índices avanzados, aislamiento, particionado, replicación, backup, seguridad y diagnóstico — con la sintaxis de cada base donde diverge.

Aviso: varios comandos de aquí alteran el comportamiento del servidor. Pruébalos antes en preproducción, y entiende qué hace cada uno antes de ejecutarlo en producción.

Índice

• 1–18 · Funciones de ventana avanzadas
• 19–30 · Consultas analíticas y recursión
• 31–54 · Plan de ejecución y optimización
• 55–74 · Índices avanzados
• 75–90 · Concurrencia, locks y MVCC
• 91–105 · Particionado
• 106–119 · Replicación y alta disponibilidad
• 120–133 · Backup y recuperación
• 134–146 · Mantenimiento, vacuum y estadísticas
• 147–159 · Seguridad avanzada
• 160–170 · Extensiones y funciones modernas
• 171–190 · Diagnóstico en producción
• 191–200 · Buenas prácticas de producción

Funciones de ventana avanzadas

Frames, distribución y el patrón gaps-and-islands — análisis serio sin salir del SQL.

1. Frame ROWS

Define la ventana por un número de filas físicas antes/después de la actual.

SELECT dia, valor,
  AVG(valor) OVER (ORDER BY dia ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS media_7d
FROM metricas;

2. Frame RANGE

Define la ventana por valor, no por posición: los empates entran juntos.

SELECT valor, SUM(valor) OVER (ORDER BY valor RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM vendas;

3. Frame GROUPS

Cuenta los grupos de valores iguales como una unidad (PostgreSQL 11+).

SELECT dia, SUM(valor) OVER (ORDER BY dia GROUPS BETWEEN 1 PRECEDING AND CURRENT ROW)
FROM metricas;

4. EXCLUDE en el frame

Quita la fila actual (o su grupo) del cálculo — la media de los demás, no la propia.

SELECT id, AVG(nota) OVER (PARTITION BY turma ORDER BY id
  ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING EXCLUDE CURRENT ROW) AS media_dos_outros
FROM provas;

5. PERCENT_RANK

La posición relativa de 0 a 1 dentro de la partición.

SELECT nome, total, ROUND(PERCENT_RANK() OVER (ORDER BY total)::numeric, 3) AS percentil
FROM vendedores;

6. CUME_DIST

La distribución acumulada: la proporción de filas con un valor menor o igual.

SELECT nome, CUME_DIST() OVER (ORDER BY salario) AS acumulada FROM funcionarios;

7. PERCENTILE_CONT

Un percentil interpolado — la mediana verdadera, insensible a los valores atípicos.

SELECT PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY total) AS mediana FROM pedidos;

8. PERCENTILE_DISC

Un percentil discreto: devuelve un valor que existe de hecho en el conjunto.

SELECT PERCENTILE_DISC(0.9) WITHIN GROUP (ORDER BY duracao_ms) AS p90 FROM requisicoes;

9. MODE

El valor más frecuente del grupo.

SELECT MODE() WITHIN GROUP (ORDER BY categoria) AS mais_vendida FROM pedidos;

10. NTH_VALUE

Coge el enésimo valor de la ventana.

SELECT cliente_id, NTH_VALUE(total, 2) OVER (PARTITION BY cliente_id ORDER BY criado_em) AS segundo_pedido
FROM pedidos;

11. Gaps and islands

Detecta secuencias continuas: la diferencia entre la fecha y el ROW_NUMBER es constante dentro de una isla.

SELECT usuario_id, MIN(dia) AS inicio, MAX(dia) AS fim, COUNT(*) AS dias_seguidos
FROM (
  SELECT usuario_id, dia,
         dia - (ROW_NUMBER() OVER (PARTITION BY usuario_id ORDER BY dia))::int AS grupo
  FROM acessos
) ace_num
GROUP BY usuario_id, grupo;

12. Sesionización

Agrupa eventos en sesiones cuando el intervalo entre ellos supera un umbral.

SELECT *, SUM(nova_sessao) OVER (PARTITION BY usuario_id ORDER BY quando) AS sessao
FROM (
  SELECT *, CASE WHEN quando - LAG(quando) OVER (PARTITION BY usuario_id ORDER BY quando)
                 > INTERVAL '30 minutes' THEN 1 ELSE 0 END AS nova_sessao
  FROM eventos
) eve_marcado;

13. Retención mes a mes

Compara el conjunto de usuarios entre periodos con una window + join.

WITH usu_mes AS (
  SELECT DISTINCT usuario_id, DATE_TRUNC('month', quando) AS mes
  FROM eventos
)
SELECT atual.mes,
       COUNT(*) FILTER (WHERE seg.usuario_id IS NOT NULL) AS retidos
FROM usu_mes atual
LEFT JOIN usu_mes seg
ON seg.usuario_id = atual.usuario_id
AND seg.mes = atual.mes + INTERVAL '1 month'
GROUP BY atual.mes
ORDER BY atual.mes;

14. Top N por grupo con empates

RANK en lugar de ROW_NUMBER cuando los empates deben entrar juntos.

SELECT *
FROM (
  SELECT prod.*,
         RANK() OVER (PARTITION BY prod.categoria ORDER BY prod.vendas DESC) AS posicao
  FROM produtos prod
) prod_rank
WHERE posicao <= 3;

15. Distancia al líder del grupo

Compara cada fila con el mejor de su partición.

SELECT nome, categoria, vendas,
  MAX(vendas) OVER (PARTITION BY categoria) - vendas AS distancia_do_topo
FROM produtos;

16. Total móvil por tiempo

RANGE con INTERVAL crea ventanas por tiempo real, no por número de filas.

SELECT quando, valor,
  SUM(valor) OVER (ORDER BY quando RANGE BETWEEN INTERVAL '7 days' PRECEDING AND CURRENT ROW) AS ultimos_7d
FROM transacoes;

17. Rellenar un valor ausente

Repite el último valor conocido (last value carried forward).

SELECT dia, cotacao,
  COALESCE(cotacao, (array_agg(cotacao) FILTER (WHERE cotacao IS NOT NULL)
    OVER (ORDER BY dia ROWS UNBOUNDED PRECEDING))[COUNT(cotacao) OVER (ORDER BY dia ROWS UNBOUNDED PRECEDING)]) AS preenchida
FROM cotacoes;

18. El coste de la ventana

Cada ventana distinta puede generar un sort. Reaprovecha la misma cláusula OVER siempre que puedas.

-- Un solo sort: la misma ventana con nombre
SELECT SUM(v) OVER w, AVG(v) OVER w, COUNT(*) OVER w
FROM t WINDOW w AS (PARTITION BY g ORDER BY d);

Consultas analíticas y recursión

Agregaciones multidimensionales y recorrido de grafos directamente en la base.

19. GROUPING SETS

Varios GROUP BY en una sola consulta, sin UNION ALL.

SELECT regiao, produto, SUM(valor)
FROM vendas
GROUP BY GROUPING SETS ((regiao, produto), (regiao), ());

20. ROLLUP

Subtotales jerárquicos + total general.

SELECT ano, mes, SUM(valor) FROM vendas GROUP BY ROLLUP (ano, mes);

21. CUBE

Todas las combinaciones posibles de subtotales.

SELECT regiao, canal, SUM(valor) FROM vendas GROUP BY CUBE (regiao, canal);

22. GROUPING()

Dice si la fila es un subtotal — evita confundirlo con un NULL del dato.

SELECT regiao, GROUPING(regiao) AS eh_total, SUM(valor)
FROM vendas GROUP BY ROLLUP (regiao);

23. PIVOT

Las filas se convierten en columnas. Nativo en SQL Server y Oracle; en PostgreSQL usa CASE o crosstab.

SELECT *
FROM vendas ven
PIVOT (SUM(ven.valor) FOR ven.mes IN ([1],[2],[3])) AS ven_pivot;   -- SQL Server

24. UNPIVOT

Las columnas se convierten en filas — normaliza una hoja de cálculo importada.

SELECT produto, mes, valor
FROM vendas_larga ven_larga
UNPIVOT (valor FOR mes IN (jan, fev, mar)) AS ven_normalizada;   -- SQL Server / Oracle

25. crosstab (PostgreSQL)

Un pivote dinámico vía la extensión tablefunc.

CREATE EXTENSION IF NOT EXISTS tablefunc;
SELECT * FROM crosstab('SELECT produto, mes, valor FROM vendas ORDER BY 1,2')
  AS t(produto TEXT, jan NUMERIC, fev NUMERIC);

26. Recorrido de un grafo

Una CTE recursiva recorre relaciones a una profundidad arbitraria.

WITH RECURSIVE caminho AS (
  SELECT origem, destino, 1 AS saltos FROM rotas WHERE origem = 'GRU'
  UNION ALL
  SELECT cam.origem, rot.destino, cam.saltos + 1
  FROM caminho cam
  INNER JOIN rotas rot
  ON rot.origem = cam.destino
  WHERE cam.saltos < 4
)
SELECT DISTINCT destino,
                MIN(saltos)
FROM caminho
GROUP BY destino;

27. Detectar un ciclo en la recursión

Lleva el camino recorrido y párate cuando se repita un nodo.

WITH RECURSIVE arvore AS (
  SELECT id, pai_id, ARRAY[id] AS caminho
  FROM nos
  WHERE pai_id IS NULL
  UNION ALL
  SELECT nos.id, nos.pai_id, arv.caminho || nos.id
  FROM nos
  INNER JOIN arvore arv
  ON nos.pai_id = arv.id
  WHERE NOT nos.id = ANY(arv.caminho)
)
SELECT *
FROM arvore;

28. CYCLE — detección nativa

PostgreSQL 14+ marca los ciclos sin que montes el array a mano.

WITH RECURSIVE arvore AS (
  SELECT id, pai_id
  FROM nos
  WHERE pai_id IS NULL
  UNION ALL
  SELECT nos.id, nos.pai_id
  FROM nos
  INNER JOIN arvore arv
  ON nos.pai_id = arv.id
) CYCLE id SET tem_ciclo USING caminho
SELECT *
FROM arvore;

29. SEARCH — el orden del recorrido

Controla si la recursión es en anchura o en profundidad.

WITH RECURSIVE t AS (...) SEARCH DEPTH FIRST BY id SET ordem
SELECT * FROM t ORDER BY ordem;

30. Explosión de la estructura (BOM)

Lista de materiales: componentes de componentes, con la cantidad acumulada.

WITH RECURSIVE bom AS (
  SELECT peca_id, componente_id, qtd FROM estrutura WHERE peca_id = 100
  UNION ALL
  SELECT bom.peca_id, estr.componente_id, bom.qtd * estr.qtd
  FROM bom
  INNER JOIN estrutura estr
  ON estr.peca_id = bom.componente_id
)
SELECT componente_id,
       SUM(qtd)
FROM bom
GROUP BY componente_id;

Plan de ejecución y optimización

Dejar de adivinar. El plan dice exactamente por dónde se va el tiempo.

31. EXPLAIN

Muestra el plan que el optimizador pretende usar, sin ejecutarlo.

EXPLAIN SELECT * FROM pedidos WHERE cliente_id = 42;

32. EXPLAIN ANALYZE

Lo ejecuta de verdad y compara la estimación con la realidad. Es el comando que resuelve la mayoría de los casos.

EXPLAIN ANALYZE SELECT * FROM pedidos WHERE cliente_id = 42;

33. EXPLAIN con buffers

Muestra la lectura de caché y de disco — separa un problema de E/S de uno de CPU.

EXPLAIN (ANALYZE, BUFFERS, VERBOSE) SELECT * FROM pedidos WHERE total > 1000;

34. El plan en formato JSON

El formato ideal para las herramientas de visualización de planes.

EXPLAIN (ANALYZE, FORMAT JSON) SELECT * FROM pedidos;

35. Seq Scan

Un recorrido completo. Malo para pocas filas; excelente cuando lees casi todo de todas formas.

-- Si aparece un Seq Scan en un filtro selectivo, falta un índice (o la estadística está vieja).

36. Index Scan vs Index Only Scan

Un Index Only Scan ni siquiera toca la tabla: todas las columnas vinieron del índice.

CREATE INDEX idx_cob ON pedidos (cliente_id) INCLUDE (total);
EXPLAIN SELECT cliente_id, total FROM pedidos WHERE cliente_id = 1;

37. Bitmap Scan

Combina varios índices o lee muchas filas dispersas en orden de página.

EXPLAIN SELECT * FROM pedidos WHERE status = 'pago' AND cliente_id < 500;

38. Nested Loop

Bueno cuando un lado es pequeño y el otro tiene índice. Pésimo cuando los dos son grandes.

-- Un Nested Loop con millones de filas en ambos lados = una consulta atascada

39. Hash Join

Monta una tabla hash del lado menor. Rápido para volúmenes grandes, consume memoria.

SET work_mem = '128MB';  -- un hash que cabe en memoria evita ir al disco

40. Merge Join

Une dos conjuntos ya ordenados. Excelente cuando los índices ya entregan el orden.

EXPLAIN
SELECT *
FROM pedidos ped
INNER JOIN itens ite
ON ite.pedido_id = ped.id;   -- busca Merge Join en el plan

41. Estimación vs realidad

Un rows=1000 estimado frente a actual rows=2000000 es el síntoma clásico de una estadística desactualizada.

ANALYZE pedidos;   -- y ejecuta el EXPLAIN ANALYZE de nuevo

42. El coste del plan

El coste es una unidad relativa del optimizador, no segundos. Sirve para comparar planes entre sí.

EXPLAIN SELECT * FROM pedidos;  -- cost=0.00..1234.56

43. Sort y volcado a disco

external merge Disk en el plan significa que faltó work_mem.

SET work_mem = '64MB';
EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM pedidos ORDER BY total;

44. SARGable

Un filtro que preserva el índice. Una función aplicada a la columna lo rompe.

-- No usa el índice
WHERE UPPER(nome) = 'ANA'
-- Sí lo usa (con un índice por expresión)
CREATE INDEX ON clientes (UPPER(nome));

45. Evita el SELECT *

Las columnas de más impiden el Index Only Scan y mueven datos inútiles.

SELECT id, total FROM pedidos WHERE cliente_id = 1;   -- y no SELECT *

46. El OR que mata el índice

Un OR entre columnas distintas suele convertirse en un Seq Scan. UNION ALL lo resuelve.

SELECT * FROM t WHERE a = 1
UNION ALL
SELECT * FROM t WHERE b = 2 AND a <> 1;

47. Paginación con un OFFSET grande

OFFSET 100000 lee y descarta 100 mil filas. Pagina por clave (keyset pagination).

-- Lento
SELECT * FROM pedidos ORDER BY id LIMIT 20 OFFSET 100000;

-- Rápido
SELECT * FROM pedidos WHERE id > 100000 ORDER BY id LIMIT 20;

48. EXISTS en lugar de COUNT

Para saber si algo existe, párate en la primera fila.

-- Mal
SELECT COUNT(*) FROM pedidos WHERE cliente_id = 1;
-- Bien
SELECT EXISTS (SELECT 1 FROM pedidos WHERE cliente_id = 1);

49. El problema N+1

Mil consultas de una fila cuestan mucho más que una consulta de mil filas.

SELECT * FROM pedidos WHERE cliente_id = ANY($1);   -- un solo round-trip

50. Materializar un resultado intermedio

Un cálculo pesado reutilizado varias veces merece una tabla temporal o una vista materializada.

CREATE TEMP TABLE base AS SELECT ... ;
ANALYZE base;

51. Forzar o desactivar un operador

Para diagnosticar: desactiva un método y mira si el plan alternativo es mejor.

SET enable_seqscan = off;
EXPLAIN ANALYZE SELECT ...;
RESET enable_seqscan;

52. Hints (Oracle y MySQL)

Algunas bases permiten instruir al optimizador directamente. Último recurso.

SELECT /*+ INDEX(p idx_pedidos_cliente) */ * FROM pedidos ped WHERE cliente_id = 1;

53. Timeout de consulta

Impide que una consulta mala monopolice el servidor.

SET statement_timeout = '30s';

54. Plan en producción vs preproducción

Volúmenes y estadísticas distintos generan planes distintos. Valida siempre con datos realistas.

-- Compara el EXPLAIN de los dos entornos antes de concluir que 'aquí va rápido'.

Índices avanzados

Más allá del B-tree: la estructura correcta para cada tipo de búsqueda.

55. B-tree

El estándar: igualdad, intervalo y ordenación. Resuelve el 90% de los casos.

CREATE INDEX idx_padrao ON pedidos (criado_em);

56. Hash

Solo igualdad, sin ordenación. Un nicho estrecho en el PostgreSQL moderno.

CREATE INDEX idx_hash ON sessoes USING HASH (token);

57. GIN

Para valores compuestos: arrays, JSONB y búsqueda textual.

CREATE INDEX idx_gin ON eventos USING GIN (payload);

58. GiST

Estructuras geométricas, intervalos y vecindad.

CREATE INDEX idx_gist ON reservas USING GIST (periodo);

59. BRIN

Minúsculo, para tablas gigantes con datos naturalmente ordenados (series temporales).

CREATE INDEX idx_brin ON logs USING BRIN (criado_em);

60. SP-GiST

Estructuras particionadas: datos no balanceados, prefijos, quadtrees.

CREATE INDEX idx_spgist ON pontos USING SPGIST (coord);

61. Índice de texto completo

Búsqueda por palabras con ranking, no con LIKE.

CREATE INDEX idx_busca ON artigos USING GIN (to_tsvector('portuguese', titulo || ' ' || corpo));
SELECT * FROM artigos WHERE to_tsvector('portuguese', corpo) @@ plainto_tsquery('portuguese', 'banco de dados');

62. Trigramas

Acelera el LIKE '%medio%' y la búsqueda por similitud.

CREATE EXTENSION IF NOT EXISTS pg_trgm;
CREATE INDEX idx_trgm ON clientes USING GIN (nome gin_trgm_ops);
SELECT * FROM clientes WHERE nome ILIKE '%silva%';

63. Índice de similitud

Ordena por proximidad textual — una búsqueda tolerante a las erratas.

SELECT cli.nome,
       similarity(cli.nome, 'jonatan') AS similaridade
FROM clientes cli
ORDER BY similaridade DESC
LIMIT 10;

64. Índice clusterizado

En SQL Server y MySQL/InnoDB, la tabla está físicamente ordenada por la clave primaria.

CREATE CLUSTERED INDEX ix_pedidos ON pedidos (criado_em);   -- SQL Server

65. CLUSTER (PostgreSQL)

Reordena físicamente la tabla según un índice. Mejora la lectura por rango; hay que rehacerlo periódicamente.

CLUSTER pedidos USING idx_pedidos_data;

66. Factor de relleno

Deja espacio libre en la página para las actualizaciones, reduciendo la fragmentación.

CREATE INDEX idx_x ON t (col) WITH (fillfactor = 80);

67. Un índice en una columna con poca variedad

Una columna con 2 valores rara vez compensa — salvo como índice parcial sobre el valor raro.

CREATE INDEX idx_erro ON logs (criado_em) WHERE nivel = 'ERROR';

68. Detectar índices no usados

Cero recorridos en producción = candidato a eliminación.

SELECT relname, indexrelname, idx_scan
FROM pg_stat_user_indexes WHERE idx_scan = 0 ORDER BY relname;

69. Detectar índices duplicados

La misma columna inicial en varios índices suele indicar redundancia.

SELECT indrelid::regclass, array_agg(indexrelid::regclass)
FROM pg_index GROUP BY indrelid, indkey HAVING COUNT(*) > 1;

70. Hinchazón del índice

Un índice muy actualizado se hincha y pierde eficiencia. REINDEX CONCURRENTLY lo resuelve sin downtime.

REINDEX INDEX CONCURRENTLY idx_pedidos_cliente;

71. Un índice para ORDER BY + LIMIT

Si el índice ya entrega el orden, la base lee solo las primeras filas.

CREATE INDEX idx_top ON pedidos (criado_em DESC);
SELECT * FROM pedidos ORDER BY criado_em DESC LIMIT 10;

72. Índice compuesto en el orden correcto

Primero la igualdad, después el intervalo. (status, criado_em) sirve para status = X AND criado_em > Y.

CREATE INDEX idx_ordem ON pedidos (status, criado_em);

73. Un índice en una columna nula

Si filtras por IS NULL con frecuencia, un índice parcial queda mucho más pequeño.

CREATE INDEX idx_sem_processar ON pedidos (id) WHERE processado_em IS NULL;

74. Coste de mantenimiento

Mide el impacto en la escritura: un índice que acelera un informe y retrasa 10 mil INSERT por minuto puede no compensar.

SELECT indexrelname, pg_size_pretty(pg_relation_size(indexrelid))
FROM pg_stat_user_indexes ORDER BY pg_relation_size(indexrelid) DESC;

Concurrencia, locks y MVCC

Lo que ocurre cuando mil sesiones quieren la misma fila.

75. MVCC

Cada transacción ve una foto consistente de la base; leer no bloquea escribir.

-- PostgreSQL y Oracle usan MVCC por defecto:
-- los lectores no bloquean a los escritores y viceversa.

76. Anomalía: lectura no repetible

La misma consulta devuelve valores distintos dentro de la transacción. Desaparece en REPEATABLE READ.

SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;

77. Anomalía: lectura fantasma

Aparecen filas nuevas en medio de la transacción. Desaparece en SERIALIZABLE.

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

78. Write skew

Dos transacciones leen, validan y graban — cada una correcta por sí sola, juntas violan la regla. Solo SERIALIZABLE lo evita.

-- Dos médicos de guardia saliendo a la vez: cada transacción ve al otro de guardia.

79. Lock de fila

FOR UPDATE bloquea las filas hasta el final de la transacción.

SELECT * FROM contas WHERE id = 1 FOR UPDATE;

80. FOR NO KEY UPDATE

Un lock más débil: permite otras operaciones que no alteran la clave.

SELECT * FROM pedidos WHERE id = 1 FOR NO KEY UPDATE;

81. FOR SHARE

Impide la modificación, pero permite otras lecturas bloqueadas.

SELECT * FROM produtos WHERE id = 1 FOR SHARE;

82. LOCK TABLE

Bloquea la tabla entera. Úsalo con mucha parsimonia y con una transacción cortísima.

BEGIN;
LOCK TABLE inventario IN EXCLUSIVE MODE;
-- operación crítica
COMMIT;

83. Advisory lock

Un lock con nombre puesto por la aplicación, sin tabla de por medio. Garantiza que solo una instancia ejecuta la rutina.

SELECT pg_try_advisory_lock(12345);
-- rutina exclusiva
SELECT pg_advisory_unlock(12345);

84. Ver los locks activos

Diagnóstico de bloqueos: quién retiene qué.

SELECT loc.pid,
       loc.mode,
       loc.granted,
       cla.relname
FROM pg_locks loc
LEFT JOIN pg_class cla
ON cla.oid = loc.relation
WHERE NOT loc.granted;

85. Descubrir quién bloquea a quién

Muestra la cadena de bloqueo directo.

SELECT pid, pg_blocking_pids(pid) AS bloqueado_por, query
FROM pg_stat_activity WHERE cardinality(pg_blocking_pids(pid)) > 0;

86. lock_timeout

Desiste de esperar el lock en lugar de acumular cola.

SET lock_timeout = '5s';

87. idle_in_transaction_timeout

Mata una transacción abierta y olvidada — la mayor causa de locks y de hinchazón.

SET idle_in_transaction_session_timeout = '60s';

88. Cola de trabajo concurrente

SKIP LOCKED deja que varios workers consuman la misma tabla sin colisionar.

UPDATE fila SET status = 'processando'
WHERE id = (SELECT id FROM fila WHERE status = 'pendente'
            ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1)
RETURNING *;

89. Reintento ante un fallo de serialización

En SERIALIZABLE, la aplicación necesita repetir la transacción abortada. No es un bug, es el contrato.

-- Código de la aplicación: captura el SQLSTATE 40001 e inténtalo de nuevo (con backoff).

90. Un orden de acceso consistente

Un deadlock casi siempre viene de órdenes distintos. Estandariza el orden de las tablas y de las claves.

-- Siempre: contas (el id menor primero) -> lancamentos

Particionado

Cuando la tabla se vuelve demasiado grande para tratarla como una sola cosa.

91. Particionar por rango

El caso más común: una partición por mes de datos temporales.

CREATE TABLE eventos (id BIGSERIAL, criado_em DATE NOT NULL, dados JSONB)
PARTITION BY RANGE (criado_em);

92. Crear la partición

Cada rango se convierte en una tabla física propia.

CREATE TABLE eventos_2026_01 PARTITION OF eventos
FOR VALUES FROM ('2026-01-01') TO ('2026-02-01');

93. Particionar por lista

Una partición por valor discreto: región, país, tenant.

CREATE TABLE clientes (id BIGINT, regiao TEXT) PARTITION BY LIST (regiao);
CREATE TABLE clientes_sul PARTITION OF clientes FOR VALUES IN ('PR','SC','RS');

94. Particionar por hash

Distribuye uniformemente cuando no hay un criterio natural.

CREATE TABLE sessoes (id BIGINT) PARTITION BY HASH (id);
CREATE TABLE sessoes_0 PARTITION OF sessoes FOR VALUES WITH (MODULUS 4, REMAINDER 0);

95. Partición por defecto

Recibe lo que no encaja con ningún rango — evita el error de inserción.

CREATE TABLE eventos_outros PARTITION OF eventos DEFAULT;

96. Partition pruning

La ganancia real: la base lee solo las particiones que el filtro alcanza. Confírmalo en el EXPLAIN.

EXPLAIN SELECT * FROM eventos WHERE criado_em >= DATE '2026-01-01';

97. Un índice en una tabla particionada

Creado en el padre, se propaga a todas las particiones.

CREATE INDEX idx_eventos_data ON eventos (criado_em);

98. DETACH — archivar

Desvincula la partición antigua sin borrarla: se convierte en una tabla normal para exportar.

ALTER TABLE eventos DETACH PARTITION eventos_2025_01;

99. ATTACH — vincular

Trae una tabla existente dentro del conjunto particionado (valida el rango).

ALTER TABLE eventos ATTACH PARTITION eventos_2026_02
FOR VALUES FROM ('2026-02-01') TO ('2026-03-01');

100. DROP de una partición

Borrar datos antiguos se convierte en una operación instantánea, sin un DELETE de millones de filas.

DROP TABLE eventos_2024_01;

101. Crear particiones automáticamente

Programa la creación con antelación: una partición que falta tumba la inserción.

-- Una rutina mensual que crea los 3 meses siguientes.
-- O usa pg_partman.

102. La clave de partición en la PK

La clave de partición tiene que formar parte de la clave primaria y de las restricciones únicas.

CREATE TABLE eventos (id BIGINT, criado_em DATE, PRIMARY KEY (id, criado_em))
PARTITION BY RANGE (criado_em);

103. Cuándo no particionar

Por debajo de decenas de millones de filas, un buen índice suele resolverlo mejor y sin complejidad.

-- Particiona por una necesidad de mantenimiento (purga, archivado), no por moda.

104. Sharding

Particionado entre servidores distintos. Gana escala de escritura, pierde los JOIN y la transacción global.

-- Elige la clave de shard con mucho cuidado: cambiarla después es reescribir el sistema.

105. Tabla externa

Con postgres_fdw, una partición puede vivir en otro servidor (sharding declarativo).

CREATE EXTENSION postgres_fdw;
CREATE SERVER shard2 FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host 'db2', dbname 'loja');

Replicación y alta disponibilidad

Cómo sobrevive la base a una máquina que muere — y cómo distribuir la lectura.

106. WAL — el log de transacciones

Toda modificación se convierte en un registro del WAL antes de ir a la tabla. Es la base de la durabilidad, la replicación y el PITR.

SHOW wal_level;   -- 'replica' o 'logical' para replicar

107. Replicación física

La réplica aplica el WAL byte a byte: una copia idéntica del clúster entero.

-- En la réplica
pg_basebackup -h primario -U replicador -D /var/lib/postgresql/data -R -P

108. Replicación lógica

Replica por tabla, entre versiones distintas y con transformación. La base de una migración sin downtime.

-- Origen
CREATE PUBLICATION pub_vendas FOR TABLE pedidos, itens;

-- Destino
CREATE SUBSCRIPTION sub_vendas
  CONNECTION 'host=origem dbname=loja user=repl'
  PUBLICATION pub_vendas;

109. Replicación síncrona

El COMMIT solo vuelve después de que la réplica haya confirmado. Cero pérdida, más latencia.

ALTER SYSTEM SET synchronous_standby_names = 'replica1';
SELECT pg_reload_conf();

110. Replicación asíncrona

Commit rápido, con riesgo de perder las últimas transacciones en un failover.

ALTER SYSTEM SET synchronous_commit = 'off';   -- valora el riesgo antes

111. Medir el retraso de la réplica

Un lag alto significa lecturas desactualizadas y un failover más arriesgado.

SELECT now() - pg_last_xact_replay_timestamp() AS atraso;

112. Réplica de lectura

Dirige los informes a la réplica y alivia el primario.

-- La aplicación usa dos conexiones: escritura en el primario, lectura en la réplica.
SELECT pg_is_in_recovery();   -- true = es una réplica

113. Promover una réplica

Failover: la réplica se convierte en primario.

SELECT pg_promote();

114. Slot de replicación

Garantiza que el primario no descarte WAL que la réplica aún no ha consumido — y llena el disco si la réplica desaparece.

SELECT * FROM pg_replication_slots;
SELECT pg_drop_replication_slot('slot_orfao');

115. Failover automático

Herramientas como Patroni, repmgr y pg_auto_failover se ocupan de la elección y del redireccionamiento.

-- Sin orquestador, el failover es manual: alguien tiene que promover y reapuntar la aplicación.

116. Split-brain

Dos primarios aceptando escritura a la vez. El fencing y el quórum existen para evitarlo.

-- Nunca promuevas manualmente sin garantizar que el antiguo primario está aislado.

117. AlwaysOn y Data Guard

Los equivalentes en SQL Server (Availability Groups) y Oracle (Data Guard).

-- SQL Server
ALTER AVAILABILITY GROUP ag1 FAILOVER;

118. Replicación en MySQL

Basada en el binlog, con GTID para un posicionamiento fiable.

CHANGE REPLICATION SOURCE TO SOURCE_HOST='primario', SOURCE_AUTO_POSITION=1;
START REPLICA;
SHOW REPLICA STATUS\G

119. Connection pooling

A una base no le gustan miles de conexiones. PgBouncer ahorra memoria y estabiliza la latencia.

-- pgbouncer.ini
-- pool_mode = transaction
-- max_client_conn = 1000
-- default_pool_size = 20

Backup y recuperación

Un backup que nunca se ha restaurado no es un backup — es una esperanza.

120. Dump lógico

Exporta la base como sentencias SQL. Portátil entre versiones y arquitecturas.

pg_dump -h localhost -U app -Fc loja > loja.dump

121. Restaurar un dump

Restaura el archivo generado, con paralelismo cuando el formato lo permite.

pg_restore -h localhost -U app -d loja -j 4 loja.dump

122. Dump de todo el clúster

Incluye usuarios, roles y permisos — lo que el pg_dump de una sola base no trae.

pg_dumpall -h localhost -U postgres > cluster.sql

123. Dump solo del esquema

Útil para comparar estructuras entre entornos.

pg_dump --schema-only -U app loja > schema.sql

124. Backup físico

Una copia de los archivos del clúster; mucho más rápido para restaurar bases grandes.

pg_basebackup -h localhost -U replicador -D /backup/base -Fp -Xs -P

125. Archivado del WAL

Guardar los segmentos del WAL es lo que permite recuperar en cualquier punto en el tiempo.

ALTER SYSTEM SET archive_mode = on;
ALTER SYSTEM SET archive_command = 'cp %p /backup/wal/%f';

126. PITR — recuperar a un instante

Restaura el backup base y reaplica el WAL hasta el segundo anterior al incidente.

-- postgresql.conf de la restauración
restore_command = 'cp /backup/wal/%f %p'
recovery_target_time = '2026-08-10 14:29:00'

127. Backup en MySQL

mysqldump para el lógico; Percona XtraBackup para el físico en caliente.

mysqldump --single-transaction --routines --triggers loja > loja.sql

128. Backup en SQL Server

Full, diferencial y de log forman la cadena de recuperación.

BACKUP DATABASE loja TO DISK = 'D:\bkp\loja.bak' WITH COMPRESSION;
BACKUP LOG loja TO DISK = 'D:\bkp\loja_log.trn';

129. Backup en Oracle

RMAN gestiona el backup, el catálogo y la recuperación.

RMAN> BACKUP DATABASE PLUS ARCHIVELOG;

130. Backup en Firebird

gbak hace el backup lógico; nbackup hace el incremental físico.

gbak -b -user SYSDBA -password senha /dados/loja.fdb /backup/loja.fbk

131. Probar la restauración

Programa una restauración periódica en una máquina aparte. Es la única prueba que cuenta.

# cron mensual: restaura el último backup y ejecuta una consulta de sanidad
pg_restore -d loja_teste ultimo.dump && psql -d loja_teste -c 'SELECT COUNT(*) FROM pedidos;'

132. Retención 3-2-1

Tres copias, en dos tipos de medio, una fuera del sitio. Vale también para las bases de datos.

-- Diario local (7 días) + semanal en object storage (8 semanas) + mensual offsite (12 meses)

133. Backup antes de una migración

Toda migración estructural empieza con un backup verificado y un plan de rollback escrito.

pg_dump -Fc loja > pre-migracao-$(date +%F).dump

Mantenimiento, vacuum y estadísticas

La base necesita limpieza. Ignorarlo es acumular deuda hasta la parada.

134. VACUUM

Marca como reutilizable el espacio de las versiones antiguas de fila (MVCC).

VACUUM pedidos;

135. VACUUM FULL

Reescribe la tabla y devuelve el espacio al sistema — con un lock exclusivo. Solo en ventana de mantenimiento.

VACUUM FULL pedidos;

136. Autovacuum

Se ejecuta solo. El error común es dejarlo demasiado conservador en tablas de mucha escritura.

ALTER TABLE eventos SET (autovacuum_vacuum_scale_factor = 0.02);

137. Table bloat

Espacio muerto acumulado. El síntoma: la tabla crece y la consulta se ralentiza sin aumento de dato útil.

SELECT relname, n_dead_tup, n_live_tup
FROM pg_stat_user_tables ORDER BY n_dead_tup DESC LIMIT 10;

138. Transaction ID wraparound

Un riesgo real de PostgreSQL: sin vacuum, el contador de transacciones se desborda y la base entra en modo protegido.

SELECT datname, age(datfrozenxid) FROM pg_database ORDER BY 2 DESC;

139. ANALYZE

Recalcula las estadísticas de distribución que usa el optimizador.

ANALYZE VERBOSE pedidos;

140. Estadísticas extendidas

Le enseña al optimizador que dos columnas están correlacionadas (ciudad y provincia, por ejemplo).

CREATE STATISTICS st_cidade_estado (dependencies) ON cidade, estado FROM clientes;
ANALYZE clientes;

141. Aumentar el muestreo

Una columna con una distribución irregular merece un histograma más detallado.

ALTER TABLE pedidos ALTER COLUMN status SET STATISTICS 1000;
ANALYZE pedidos;

142. REINDEX CONCURRENTLY

Reconstruye los índices hinchados sin bloquear la escritura.

REINDEX TABLE CONCURRENTLY pedidos;

143. Mantenimiento en MySQL

OPTIMIZE TABLE reorganiza; ANALYZE actualiza las estadísticas.

OPTIMIZE TABLE pedidos;
ANALYZE TABLE pedidos;

144. Mantenimiento en SQL Server

Rebuild/reorganize de índices y actualización de estadísticas.

ALTER INDEX ALL ON pedidos REBUILD;
UPDATE STATISTICS pedidos;

145. Mantenimiento en Firebird

El sweep quita las versiones antiguas; el backup/restore compacta el archivo.

gfix -sweep -user SYSDBA -password senha /dados/loja.fdb

146. Ventana de mantenimiento

Prográmala para el valle de uso, vigila el tiempo de ejecución y ten un plan de aborto.

SET statement_timeout = '2h';   -- un límite explícito para la rutina pesada

Seguridad avanzada

Un dato sensible exige más que un usuario y una contraseña.

147. Row Level Security

Filtra las filas por política, dentro de la propia base.

ALTER TABLE pedidos ENABLE ROW LEVEL SECURITY;
CREATE POLICY p_tenant ON pedidos USING (tenant_id = current_setting('app.tenant')::int);

148. Una política por operación

Reglas distintas para la lectura y la escritura.

CREATE POLICY p_insert ON pedidos FOR INSERT
WITH CHECK (tenant_id = current_setting('app.tenant')::int);

149. FORCE ROW LEVEL SECURITY

Aplica la política incluso al dueño de la tabla.

ALTER TABLE pedidos FORCE ROW LEVEL SECURITY;

150. Cifrado en reposo

TDE en SQL Server/Oracle, LUKS/dm-crypt en el disco, o cifrado por campo en la aplicación.

-- SQL Server
ALTER DATABASE loja SET ENCRYPTION ON;

151. Cifrado por campo

Solo quien tiene la clave lee el dato — protege incluso de un dump filtrado.

CREATE EXTENSION IF NOT EXISTS pgcrypto;
INSERT INTO clientes (cpf_cifrado) VALUES (pgp_sym_encrypt('123.456.789-00', 'chave'));
SELECT pgp_sym_decrypt(cpf_cifrado, 'chave') FROM clientes;

152. Hash de contraseña

Una contraseña nunca es cifrado reversible: es un hash con sal y un coste alto (bcrypt, argon2).

SELECT crypt('senha-do-usuario', gen_salt('bf', 12));

153. Conexión TLS obligatoria

Sin TLS, las credenciales y los datos viajan legibles por la red.

-- pg_hba.conf
hostssl  all  all  0.0.0.0/0  scram-sha-256

154. SCRAM en lugar de MD5

El método de autenticación moderno de PostgreSQL.

ALTER SYSTEM SET password_encryption = 'scram-sha-256';

155. Auditoría

Registrar quién leyó y modificó un dato sensible — una exigencia legal en muchos escenarios.

-- pgaudit
ALTER SYSTEM SET pgaudit.log = 'write, ddl';

156. Enmascaramiento de datos

Un entorno de pruebas no debe tener PII real. Enmascárala en la copia.

UPDATE clientes SET email = 'user' || id || '@exemplo.com', cpf = NULL;

157. SQL injection

La defensa es la consulta parametrizada. Concatenar una cadena con la entrada del usuario es el origen de casi toda filtración.

-- Vulnerable
-- 'SELECT * FROM users WHERE email = ''' + entrada + ''''

-- Seguro
SELECT * FROM users WHERE email = $1;

158. SQL injection en el código de la base

Una función con SQL dinámico también es vulnerable. Usa quote_ident y quote_literal.

EXECUTE format('SELECT * FROM %I WHERE nome = %L', tabela, valor);

159. Principio del menor privilegio

La aplicación no crea tablas, no borra nada y no lee lo que no necesita.

REVOKE ALL ON SCHEMA public FROM PUBLIC;
GRANT USAGE ON SCHEMA public TO app_web;

Extensiones y funciones modernas

Lo que la base ha ganado en los últimos años y mucha gente todavía no usa.

160. pg_stat_statements

La extensión más valiosa para el rendimiento: agrega el tiempo por consulta normalizada.

CREATE EXTENSION pg_stat_statements;
SELECT query, calls, total_exec_time FROM pg_stat_statements ORDER BY total_exec_time DESC LIMIT 20;

161. PostGIS

Datos geográficos con índice espacial y cálculo de distancia real.

CREATE EXTENSION postgis;
SELECT nome FROM lojas
ORDER BY geom <-> ST_MakePoint(-47.06, -22.90)::geography LIMIT 5;

162. TimescaleDB

Series temporales a escala: hipertablas, compresión y agregación continua.

SELECT create_hypertable('metricas', 'coletado_em');

163. pgvector

Búsqueda por similitud vectorial — la base del RAG y de la recomendación.

CREATE EXTENSION vector;
CREATE TABLE docs (id BIGSERIAL, embedding vector(1536));
SELECT * FROM docs ORDER BY embedding <-> $1 LIMIT 5;

164. Foreign Data Wrapper

Consulta otra base (o un CSV, o una API) como si fuera una tabla local.

CREATE EXTENSION postgres_fdw;
IMPORT FOREIGN SCHEMA public FROM SERVER outro INTO externo;

165. Columnas generadas

Una columna calculada y almacenada por la base, siempre coherente.

ALTER TABLE itens ADD COLUMN total NUMERIC GENERATED ALWAYS AS (qtd * preco) STORED;

166. IDENTITY estándar

El sustituto moderno del SERIAL, conforme al estándar SQL.

CREATE TABLE t (id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY);

167. MERGE

El comando estándar para insertar/actualizar/borrar en una pasada (PostgreSQL 15+, Oracle, SQL Server).

MERGE INTO estoque est
USING recebimento rec ON est.produto_id = rec.produto_id
WHEN MATCHED THEN UPDATE SET qtd = est.qtd + rec.qtd
WHEN NOT MATCHED THEN INSERT (produto_id, qtd) VALUES (rec.produto_id, rec.qtd);

168. JSON_TABLE

Convierte JSON en una tabla relacional dentro de la consulta (SQL:2016).

SELECT * FROM JSON_TABLE(
  '[{"id":1,"nome":"Ana"}]', '$[*]'
  COLUMNS (id INT PATH '$.id', nome TEXT PATH '$.nome')
) AS cli_json;

169. Índice paralelo y consulta paralela

La base usa varios núcleos en una sola consulta — ajusta los límites según la máquina.

SET max_parallel_workers_per_gather = 4;
EXPLAIN ANALYZE SELECT COUNT(*) FROM eventos;

170. Compresión de columna

TOAST comprime los valores grandes; LZ4 es más rápido que el valor por defecto en muchos casos.

ALTER TABLE documentos ALTER COLUMN corpo SET COMPRESSION lz4;

Diagnóstico en producción

La base está lenta. Estos son los comandos que responden 'por qué' en minutos.

171. Qué se está ejecutando ahora

El primer comando de cualquier incidente.

SELECT pid, now() - query_start AS duracao, state, query
FROM pg_stat_activity WHERE state <> 'idle' ORDER BY duracao DESC;

172. Consultas de más de 1 minuto

Aísla a los sospechosos inmediatos.

SELECT pid, now() - query_start AS duracao, query FROM pg_stat_activity
WHERE state = 'active' AND now() - query_start > INTERVAL '1 minute';

173. Transacciones abiertas y ociosas

El 'idle in transaction' retiene locks e impide el vacuum. Una gran causante de incidentes.

SELECT pid, now() - state_change AS parado, query FROM pg_stat_activity
WHERE state = 'idle in transaction' ORDER BY parado DESC;

174. Cancelar y matar

Cancel intenta terminar la consulta; terminate tira la conexión.

SELECT pg_cancel_backend(pid) FROM pg_stat_activity WHERE pid = 12345;
SELECT pg_terminate_backend(12345);

175. La cadena de bloqueo

Muestra quién está bloqueando a quién, con la consulta de cada lado.

SELECT bloqueada.pid AS vitima,
       bloqueadora.pid AS culpada,
       bloqueadora.query
FROM pg_stat_activity bloqueada
INNER JOIN pg_stat_activity bloqueadora
ON bloqueadora.pid = ANY(pg_blocking_pids(bloqueada.pid));

176. Top de consultas por tiempo total

Optimizar la consulta de 5 ms llamada un millón de veces rinde más que la de 2 s llamada tres veces.

SELECT query, calls, round(total_exec_time::numeric, 0) AS ms_total
FROM pg_stat_statements ORDER BY total_exec_time DESC LIMIT 20;

177. Tasa de acierto de la caché

Por debajo de ~99% en OLTP suele indicar memoria insuficiente.

SELECT round(100.0 * sum(blks_hit) / nullif(sum(blks_hit + blks_read), 0), 2) AS cache_pct
FROM pg_stat_database;

178. Las tablas más leídas del disco

Señala dónde la memoria no está dando abasto.

SELECT relname, heap_blks_read, heap_blks_hit
FROM pg_statio_user_tables ORDER BY heap_blks_read DESC LIMIT 10;

179. Sequential scans frecuentes

Una tabla grande con muchos seq scans está pidiendo un índice a gritos.

SELECT relname, seq_scan, seq_tup_read, idx_scan
FROM pg_stat_user_tables WHERE seq_scan > 0 ORDER BY seq_tup_read DESC LIMIT 10;

180. Conexiones por estado

Descubre si el problema es un exceso de conexiones en lugar de una consulta lenta.

SELECT state, COUNT(*) FROM pg_stat_activity GROUP BY state;

181. El tamaño de la base y de las tablas

Un crecimiento inesperado suele ser bloat, un índice nuevo o un log olvidado.

SELECT pg_size_pretty(pg_database_size(current_database()));
SELECT relname, pg_size_pretty(pg_total_relation_size(relid))
FROM pg_stat_user_tables ORDER BY pg_total_relation_size(relid) DESC LIMIT 10;

182. Espacio de WAL

WAL acumulado significa que el archivado está fallando o que hay un slot de replicación huérfano — y un disco lleno por delante.

SELECT COUNT(*) * 16 AS mb_wal FROM pg_ls_waldir();

183. Deadlocks registrados

Un contador creciente indica un patrón de acceso conflictivo en la aplicación.

SELECT datname, deadlocks, conflicts FROM pg_stat_database;

184. Temp files

Un volumen alto de archivos temporales significa que el work_mem es bajo para las consultas actuales.

SELECT datname, temp_files, pg_size_pretty(temp_bytes) FROM pg_stat_database ORDER BY temp_bytes DESC;

185. Registrar las consultas lentas

La recolección continua vale más que una investigación puntual.

ALTER SYSTEM SET log_min_duration_statement = '1000';   -- 1 s
SELECT pg_reload_conf();

186. Auto explain

Registra el plan de las consultas lentas automáticamente, sin reproducirlas a mano.

LOAD 'auto_explain';
SET auto_explain.log_min_duration = '3s';
SET auto_explain.log_analyze = on;

187. Ver y cambiar parámetros

Comprueba el valor efectivo antes de teorizar sobre la causa.

SHOW work_mem;
SELECT name, setting, unit FROM pg_settings WHERE name LIKE '%mem%';

188. Recargar la configuración

Muchos parámetros se aplican sin reiniciar el servidor.

ALTER SYSTEM SET work_mem = '32MB';
SELECT pg_reload_conf();

189. Diagnóstico en MySQL

Los equivalentes: la lista de procesos y el performance schema.

SHOW FULL PROCESSLIST;
SELECT * FROM sys.statement_analysis ORDER BY total_latency DESC LIMIT 10;

190. Diagnóstico en SQL Server

Las DMV entregan las consultas más caras y las esperas dominantes.

SELECT TOP 10 total_worker_time/execution_count AS media_cpu,
       text
FROM sys.dm_exec_query_stats
CROSS APPLY sys.dm_exec_sql_text(sql_handle)
ORDER BY media_cpu DESC;

Buenas prácticas de producción

Lo que evita el incidente antes de que exista.

191. Migración versionada

La estructura cambia mediante un script versionado en el repositorio, nunca con una modificación manual en el servidor.

-- migrations/0042_add_index_pedidos.sql
CREATE INDEX CONCURRENTLY idx_pedidos_status ON pedidos (status);

192. Migración reversible

Todo script tiene su camino de vuelta escrito antes de subir.

-- up
ALTER TABLE pedidos ADD COLUMN canal VARCHAR(20);
-- down
ALTER TABLE pedidos DROP COLUMN canal;

193. Despliegue sin downtime

Añade una columna nullable, puéblala por lotes y solo entonces hazla obligatoria.

ALTER TABLE pedidos ADD COLUMN canal VARCHAR(20);           -- 1
UPDATE pedidos SET canal = 'web' WHERE canal IS NULL;       -- 2 (por lotes)
ALTER TABLE pedidos ALTER COLUMN canal SET NOT NULL;        -- 3

194. Cuidado con el lock en un ALTER

En una tabla grande, un ALTER descuidado bloquea la aplicación entera. Comprueba el comportamiento de tu versión.

SET lock_timeout = '3s';   -- falla rápido en lugar de encolar la producción
ALTER TABLE pedidos ADD COLUMN x INT;

195. Nunca pruebes en producción

Un UPDATE y un DELETE empiezan siendo un SELECT, y se ejecutan primero en preproducción con un volumen parecido.

BEGIN;
UPDATE pedidos SET status = 'x' WHERE ...;
-- comprueba el número de filas afectadas
ROLLBACK;   -- o COMMIT

196. Monitorización continua

Vigila las conexiones, el cache hit, la replicación, el tamaño y las consultas lentas — con alertas, no con un panel que nadie mira.

-- Alertas mínimas: lag de réplica, disco > 80%, conexiones > 80% del límite,
-- transacción abierta > 5 min, fallo de backup.

197. Límite de conexiones

Dimensiona el pool: más conexiones que núcleos suele empeorar, no mejorar.

SHOW max_connections;
SELECT COUNT(*) FROM pg_stat_activity;

198. Timeouts en todas las capas

La consulta, la transacción y la conexión necesitan un límite. Sin eso, una consulta mala lo tumba todo.

SET statement_timeout = '30s';
SET idle_in_transaction_session_timeout = '60s';
SET lock_timeout = '5s';

199. Documentar el modelo

COMMENT vive junto al esquema y aparece en las herramientas — mejor que un wiki desactualizado.

COMMENT ON TABLE pedidos IS 'Pedidos de venta; una fila por checkout completado.';
COMMENT ON COLUMN pedidos.total IS 'Importe final en BRL, con el descuento ya aplicado.';

200. Revisar antes de aplicar

Un script de base pasa por revisión como cualquier otro código — con el EXPLAIN de lo que cambia y un plan de rollback.

-- Checklist: ¿backup ok? ¿rollback escrito? ¿lock estimado? ¿ventana definida? ¿monitorización activa?