A partir do PostgreSQL 15, o banco registra em pg_database.datcollversion a versão da glibc usada quando a collation padrão foi definida, e compara com a versão atual a cada conexão. Collations explícitas têm o mesmo controle em pg_collation.collversion. Essa comparação é a primeira verificação a fazer depois de qualquer troca de servidor, imagem ou sistema operacional, e deveria fazer parte do checklist da migração.
-- PostgreSQL 15+: versão registrada no banco contra a versão que o SO entrega agora.
SELECT datname,
datcollate,
datcollversion AS versao_registrada,
pg_database_collation_actual_version(oid) AS versao_do_so
FROM pg_database
WHERE datname = current_database();
datname | datcollate | versao_registrada | versao_do_so
---------+-------------+-------------------+--------------
loja | pt_BR.UTF-8 | 2.17 | 2.34
-- Collations explícitas (libc e ICU): mesma comparação, por collation.
SELECT collname, collprovider, collversion,
pg_collation_actual_version(oid) AS versao_do_so
FROM pg_collation
WHERE collversion IS DISTINCT FROM pg_collation_actual_version(oid);
-- O aviso que fica no log a cada conexão enquanto nada for corrigido.
WARNING: database "loja" has a collation version mismatch
DETAIL: The database was created using collation version 2.17, but the operating system provides version 2.34.
HINT: Rebuild all objects in this database that use the default collation and run ALTER DATABASE loja REFRESH COLLATION VERSION, or build PostgreSQL with the right library version.
A versão diz que há risco, não onde há dano. Para isso existe a extensão amcheck: bt_index_check percorre o índice e verifica se as chaves estão na ordem que o comparador atual espera, e com heapallindexed = true também confere se cada linha da tabela está no índice. O script abaixo lista os índices B-tree que dependem de collation da libc, roda o amcheck em cada um e, com --reindex, reconstrói todos sem bloquear escrita.
// auditar-collation.js
// node auditar-collation.js -> relatorio
// node auditar-collation.js --reindex -> relatorio + REINDEX CONCURRENTLY
import pg from 'pg';
const client = new pg.Client({ connectionString: process.env.DATABASE_URL });
const reindexar = process.argv.includes('--reindex');
// Índices B-tree com pelo menos uma coluna ou expressão em collation da libc diferente de C.
const SQL_INDICES_AFETADOS = `
SELECT DISTINCT
i.indrelid::regclass::text AS tabela,
i.indexrelid::regclass::text AS indice,
i.indisunique AS unico
FROM pg_index i
JOIN pg_class c ON c.oid = i.indexrelid
JOIN pg_am am ON am.oid = c.relam
CROSS JOIN LATERAL unnest(i.indcollation::oid[]) AS col(oid)
JOIN pg_collation co ON co.oid = col.oid
JOIN pg_database d ON d.datname = current_database()
WHERE am.amname = 'btree'
AND c.relnamespace <> 'pg_catalog'::regnamespace
AND (
(co.collprovider = 'c' AND co.collname NOT IN ('C', 'POSIX'))
OR (co.collprovider = 'd' AND d.datlocprovider = 'c'
AND d.datcollate NOT IN ('C', 'POSIX'))
)
ORDER BY 1, 2`;
async function main() {
await client.connect();
try {
// amcheck lê o índice e o heap; precisa de superusuário ou de GRANT nas funções.
await client.query('CREATE EXTENSION IF NOT EXISTS amcheck');
const { rows: indices } = await client.query(SQL_INDICES_AFETADOS);
const relatorio = [];
for (const { tabela, indice, unico } of indices) {
let amcheck = 'ok';
try {
// heapallindexed = true confere também se toda linha do heap está no índice.
await client.query('SELECT bt_index_check($1::regclass, true)', [indice]);
} catch (erro) {
amcheck = erro.message;
}
relatorio.push({ tabela, indice, unico, amcheck });
}
console.table(relatorio);
if (!reindexar) return;
for (const { indice } of relatorio) {
try {
// REINDEX CONCURRENTLY não roda dentro de transação: cada índice em um comando.
// O nome vem de ::regclass::text, já com aspas e schema quando necessário.
await client.query(`REINDEX INDEX CONCURRENTLY ${indice}`);
console.log(`ok: ${indice}`);
} catch (erro) {
// Falhou: sobra um índice inválido com sufixo _ccnew, que precisa de DROP INDEX CONCURRENTLY.
console.error(`erro: ${indice}: ${erro.message}`);
process.exitCode = 1;
}
}
// Depois de reconstruir tudo: ALTER DATABASE ... REFRESH COLLATION VERSION.
} finally {
await client.end();
}
}
main().catch((erro) => {
console.error(erro);
process.exit(1);
});
Dois cuidados. bt_index_check com heapallindexed lê o índice e a tabela inteira, então rode fora do pico ou numa réplica com a mesma glibc do servidor novo. E o amcheck pode não acusar um índice cuja ordem mudou só em pontos que a verificação não alcança: use o resultado para medir o dano e priorizar, mas reconstrua todos os índices da lista, não só os que falharam.