PostgreSQL 19: o que mudou de verdade no SQL e nas operações, além do que foi revertido
Passada a polêmica das features retiradas antes do lançamento, o PostgreSQL 19 trouxe upsert sem bloat, janelas com IGNORE NULLS, leitura consistente em réplica e autovacuum paralelo. Um guia de referência do que muda no código e na operação.
O PostgreSQL 19 foi lançado em novembro de 2026, depois de uma sequência de reversões que tirou da lista recursos como consultas de grafo de propriedade, FOR PORTION OF para updates e deletes temporais, split e merge de partições, transição online de checksum e GROUP BY ALL. O desenvolvedor Zsolt Parragi, da Percona, publicou um apanhado do que sobrou depois dessas quedas, e é esse material que organiza este guia. Todo exemplo abaixo foi escrito contra a sintaxe de PostgreSQL 19.0, com o esquema mínimo para reproduzir.
O recorte aqui é prático: o que muda no SQL que você escreve e nas rotinas que você já automatiza, não a lista completa (para isso, as release notes oficiais da versão são a referência).
REPACK e REPACK (CONCURRENTLY): fim da dualidade VACUUM FULL / CLUSTER
VACUUM FULL e CLUSTER sempre compartilharam a mesma implementação interna: reescrever a tabela inteira, mudando só a organização física. O PostgreSQL 19 introduz REPACK como nome único para as duas operações, e adiciona uma terceira variante que elas nunca tiveram.
| Comando | Lock durante a operação | Reescreve a tabela | Ordena por índice | Origem |
|---|---|---|---|---|
VACUUM FULL | ACCESS EXCLUSIVE, do início ao fim | Sim | Não | Sempre existiu |
CLUSTER | ACCESS EXCLUSIVE, do início ao fim | Sim | Sim | Sempre existiu |
REPACK | ACCESS EXCLUSIVE, do início ao fim | Sim | Opcional (USING INDEX) | PostgreSQL 19 |
REPACK (CONCURRENTLY) | SHARE UPDATE EXCLUSIVE, mais um ACCESS EXCLUSIVE curto no fim | Sim | Opcional | PostgreSQL 19 |
pg_repack (extensão) | Semelhante ao concurrent, via triggers de linha | Sim | Por qualquer coluna | Extensão externa |
pg_squeeze (extensão) | Semelhante ao concurrent, via logical decoding | Sim | Não | Extensão externa |
-- esquema mínimo para reproduzir
CREATE TABLE mytable (
id serial PRIMARY KEY,
payload text
);
-- equivalente a VACUUM FULL mytable;
REPACK mytable;
-- equivalente a CLUSTER mytable USING mytable_pkey;
REPACK mytable USING INDEX mytable_pkey;
-- novo: leituras e escritas continuam liberadas durante a operação
REPACK (CONCURRENTLY) mytable USING INDEX mytable_pkey;REPACK (CONCURRENTLY) cria uma tabela nova, captura as mudanças via decodificação do WAL (funciona com wal_level = replica, sem precisar habilitar replicação lógica antes), copia os registros existentes, reaplica as mudanças capturadas e troca as tabelas com um lock exclusivo bem curto no final. Enquanto roda, ele ainda bloqueia DDL, VACUUM/autovacuum e outros REPACK na mesma tabela.
A versão concorrente exige chave primária ou um índice de replica identity, não funciona em tabelas particionadas, unlogged, materialized views ou catálogos de sistema, e não pode rodar dentro de bloco de transação. Se seu caso de uso precisa ordenar por coluna arbitrária, mover tablespace ou só reconstruir índices, o pg_repack continua sendo a ferramenta certa; REPACK (CONCURRENTLY) só vale a troca se essas limitações forem aceitáveis.
INSERT ... ON CONFLICT DO SELECT: upsert sem gravar linha extra
Antes do PostgreSQL 19, resolver um conflito de unicidade e devolver o registro existente exigia um update artificial (que grava nova versão da linha, dispara triggers de update e gera bloat) ou um CTE combinando DO NOTHING com um SELECT separado, que podia não retornar nada se outra transação inserisse a mesma chave entre os dois passos.
CREATE TABLE users (
id serial PRIMARY KEY,
email text UNIQUE NOT NULL,
name text NOT NULL
);
INSERT INTO users (email, name)
VALUES ('alice@example.com', 'Alice')
ON CONFLICT (email) DO SELECT RETURNING id;Essa consulta devolve o id tanto quando o insert é bem-sucedido quanto quando o e-mail já existe, como uma única operação atômica. RETURNING é obrigatório: DO SELECT sem ele é erro de sintaxe. A cláusula aceita FOR UPDATE e WHERE, do mesmo jeito que DO UPDATE já aceitava, útil quando a aplicação sabe que vai modificar a linha retornada em seguida. Um detalhe que não muda: mesmo com conflito, o insert ainda consome um valor de sequência.
IGNORE NULLS nas funções de janela
Funções como lag(), lead(), first_value(), last_value() e nth_value() sempre trataram NULL como valor comum. Numa série temporal com leituras faltando, isso propagava NULL para toda consulta que tentasse olhar o valor anterior.
CREATE TABLE readings (
ts time PRIMARY KEY,
temperature numeric
);
INSERT INTO readings VALUES
('10:00', 21), ('10:01', NULL), ('10:02', NULL),
('10:03', 23), ('10:04', NULL), ('10:05', 22);
SELECT
ts,
temperature,
lag(temperature) IGNORE NULLS OVER (ORDER BY ts) AS previous_known,
last_value(temperature) IGNORE NULLS OVER (ORDER BY ts) AS last_known
FROM readings;| ts | temperature | previous_known | last_known |
|---|---|---|---|
| 10:00 | 21 | NULL | 21 |
| 10:01 | NULL | 21 | 21 |
| 10:02 | NULL | 21 | 21 |
| 10:03 | 23 | 21 | 23 |
| 10:04 | NULL | 23 | 23 |
| 10:05 | 22 | 23 | 22 |
Antes do PostgreSQL 19, resolver isso sem IGNORE NULLS exigia subconsultas com COUNT cumulativo para agrupar runs de NULL, bem menos legível que a cláusula nova.
WAIT FOR LSN: leitura consistente numa réplica, sem replicação síncrona
WAIT FOR LSN resolve o problema da leitura obsoleta (stale read) em arquiteturas onde escrita vai para o primário e leitura é roteada para uma réplica, sem exigir replicação síncrona.
- A aplicação grava no primário e comita.
- Em seguida, chama
SELECT pg_current_wal_insert_lsn();para obter a posição do WAL daquela escrita. - Antes de ler na réplica, executa
WAIT FOR LSN '<lsn>' WITH (TIMEOUT '1s');. - Se a réplica já aplicou aquele WAL, a espera retorna na hora; senão, espera até aplicar ou até o timeout.
-- no primário, logo após o COMMIT
SELECT pg_current_wal_insert_lsn();
-- na réplica, antes da leitura
WAIT FOR LSN '0/306EE20' WITH (TIMEOUT '1s');
SELECT * FROM pedidos WHERE id = 42;Sem TIMEOUT, a espera é indefinida; com TIMEOUT, ela levanta erro ao expirar, a menos que NO_THROW também seja especificado.
Há um porém importante: existe um bug já reportado por Jobin Augustine em que, se o LSN retornado por pg_current_wal_insert_lsn() cai exatamente numa fronteira de página do WAL, a espera pode travar até que algum WAL não relacionado seja escrito, ou até o timeout expirar. A correção foi commitada um dia antes do lançamento, tarde demais para entrar em 19.0, e só chega na 19.1.
Eu recomendaria não usar esse recurso em produção, ou pelo menos sempre especificar um TIMEOUT.
I would recommend not using this feature in production, or at least always specifying a TIMEOUT.Zsolt Parragi, desenvolvedor de software na Percona
Debaixo do capô: planner, autovacuum e páginas visíveis
Várias melhorias de PostgreSQL 19 não mudam sintaxe nenhuma, só o plano de execução e o custo de manutenção:
- Checagem de chave estrangeira mais rápida em insert/update na tabela que referencia.
- Radix sort para algumas ordenações, no lugar da ordenação por comparação.
- Deforming de tupla mais rápido (extrair valores de coluna do formato de linha armazenado), algo que acontece em quase toda linha tocada por uma consulta.
- Agregação parcial antes de join, reduzindo o número de linhas que o join processa.
Autovacuum ganhou dois recursos operacionais relevantes: workers paralelos para indexação e um sistema de prioridade por score.
-- o padrão é 0: paralelismo em autovacuum fica desligado até você habilitar
ALTER SYSTEM SET autovacuum_max_parallel_workers = 4;
SELECT pg_reload_conf();
ALTER TABLE large_events SET (
autovacuum_parallel_workers = 2
);autovacuum_max_parallel_workers limita quantos workers paralelos um worker de autovacuum pode usar; autovacuum_max_workers continua controlando quantas operações rodam em tabelas diferentes ao mesmo tempo. Índices pequenos, abaixo de min_parallel_index_scan_size, continuam sendo processados pelo próprio worker.
Antes do PostgreSQL 19, tabelas elegíveis para vacuum eram processadas na ordem em que apareciam em pg_class, então uma tabela perto do wraparound podia esperar atrás de várias tabelas pequenas com poucas linhas mortas. A nova consulta expõe o score usado para decidir a ordem:
SELECT relname, score, xid_score, vacuum_score, do_vacuum, for_wraparound
FROM pg_stat_autovacuum_scores
ORDER BY score DESC
LIMIT 10;Os pesos (autovacuum_freeze_score_weight, autovacuum_vacuum_score_weight e os demais, todos com padrão 1.0) são configuráveis por servidor.
Uma terceira mudança, menos badalada: SELECT comuns agora podem marcar páginas como all-visible, tarefa que antes era exclusiva de VACUUM e COPY ... FREEZE. Em tabelas append-heavy, isso acelera index-only scans que antes dependiam de esperar o próximo vacuum para evitar visitar a tabela. A marcação é só de all-visible, não de all-frozen: congelar linhas continua sendo trabalho do vacuum.
pg_plan_advice e pg_stash_advice: hints de execução no core
São dois módulos novos em contrib, desabilitados por padrão. pg_plan_advice deixa o usuário controlar decisões do planner, e pg_stash_advice guarda essa orientação por query ID para aplicar automaticamente depois.
LOAD 'pg_plan_advice';
EXPLAIN (COSTS OFF, PLAN_ADVICE)
SELECT * FROM a JOIN b ON a.id = b.a_id WHERE a.x < 100;O EXPLAIN mostra, além do plano, a orientação equivalente (algo como JOIN_ORDER(b a), HASH_JOIN(a), SEQ_SCAN(b a)), que pode ser reaplicada manualmente:
SET pg_plan_advice.advice = 'HASH_JOIN(b) SEQ_SCAN(b)';A extensão pg_hint_plan já cobria terreno parecido fora do core; a diferença é que agora a orientação pode ser gerada diretamente a partir de um plano existente, e pg_stash_advice permite fixar um plano instável sem reescrever a consulta toda vez.
Replicação lógica: menos restart, sequências incluídas
Até a versão anterior, habilitar replicação lógica exigia trocar wal_level de replica para logical, o que pedia reinício do servidor. No PostgreSQL 19, o servidor alterna automaticamente para logical quando um slot de replicação lógica é criado, e volta para replica quando o último slot é removido; o valor realmente em uso fica visível em effective_wal_level.
Replicação lógica de sequências também chegou, mas não é contínua como a de tabelas: a publicação precisa incluí-las com CREATE PUBLICATION ... FOR ALL SEQUENCES, e o assinante só copia os valores atuais na criação da subscription ou quando pedido explicitamente, com ALTER SUBSCRIPTION ... REFRESH SEQUENCES. Isso ajuda em switchover, rodando o refresh logo antes da troca, mas não resolve upgrade de versão major: como exige publicador em PostgreSQL 19 ou mais novo, só vale a partir do próximo salto, de 19 para 20.
Próximo passo
Para o inventário completo, as release notes oficiais do PostgreSQL 19 listam cada item, inclusive os que não couberam aqui. Antes de usar WAIT FOR LSN em produção, vale esperar a 19.1 ou pelo menos manter TIMEOUT sempre especificado. E, para quem já usa pg_repack ou pg_hint_plan, comparar os limites documentados de REPACK (CONCURRENTLY) e pg_plan_advice antes de migrar é o que evita susto em produção.
Fonte: Planet PostgreSQL
Este artigo foi escrito por Patrícia Guimarães. Conteúdo produzido por agente de IA da redação Linha de Código. Saiba como produzimos no expediente.
Editora virtual de Banco de dados do Linha de Código. Cobre SQL de verdade — consulta, índice, transação, plano de execução — em PostgreSQL, MySQL, SQL Server, MongoDB e Redis, e a modelagem que evita o problema antes dele existir. Escreve para o desenvolvedor que também é o DBA da empresa.