Dev & EngARTIGO

Plano de execução barato no laptop pode ficar caro no seu maior tenant

Um estudo de caso com PostgreSQL mostra como o cache de prepared statements pode planejar a consulta do tenant gigante a partir do comportamento dos tenants pequenos, e o que fazer quando isso acontece.

Plano de execução barato no laptop pode ficar caro no seu maior tenant
Imagem gerada por IA
Artigo · Dev & Eng
Leitura
8 min
Tabelas
1
Código
2
Fontes
1

Um estudo de caso com PostgreSQL↳PostgreSQL11 conteúdosPostgreSQL via SSL com GolangData · abr 20195 itens legais sobre data types do PostgreSQLData · mar 20195 serviços gratuitos na cloud para bancos de dados PostgresData · fev 2025Ver tudo em Data → mostra como o cache de prepared statements pode planejar a consulta do tenant gigante a partir do comportamento dos tenants pequenos, e o que fazer quando isso acontece.

O sintoma: custo baixo no EXPLAIN, lentidão real em produção

O autor do blog boringSQL descreve um caso que qualquer DBA de aplicação multi-tenant já viveu sem entender direito. Um endpoint paginado tinha um plano de execução com custo de poucas centenas e estimativa de uma linha retornada. Na prática, o pg_stat_statements mostrava a mesma consulta lendo milhares de buffers por chamada para devolver cerca de oito linhas. O plano não enxergava o próprio problema.

O autor reconstruiu o caso num esquema sintético de leituras de sensores, com 2.000 sites (os tenants). A maioria tem cerca de 15 sensores e 1.000 leituras em dois anos; um único site, o site 1, tem 500 sensores e 200.000 leituras, duzentas vezes mais que a média. É o tipo de assimetria que aparece em praticamente toda tabela multi-tenant que cresce de verdade: sempre existe um cliente muito maior que os outros.

Dois ingredientes banais que juntos quebram o plano

A consulta é um tile de dashboard clássico: as 50 maiores leituras de um site numa janela de tempo, com joins para sensor, modelo, fabricante e unidade, ordenadas por valor e limitadas a 50 linhas. Nenhum índice devolve as leituras já ordenadas por valor, então qualquer plano precisa ler toda a janela de tempo e ordenar depois. A diferença entre os planos está em quanto trabalho eles fazem com as linhas que acabam descartadas.

O segundo ingrediente é o PREPARE. É assim que a consulta chega ao servidor na maioria das stacks reais: o driver pgx prepara por padrão, o adaptador do Rails também, e pgJDBC e psycopg 3 migram para prepared statements no lado do servidor depois de algumas execuções. Isso importa porque o PostgreSQL trata uma consulta preparada de forma diferente de uma consulta com valores literais.

Como o planejador escolhe entre plano customizado e genérico

As cinco primeiras execuções de um PREPARE recebem cada uma um plano customizado, construído com os valores reais daquela chamada. A partir da sexta execução, o PostgreSQL constrói também um plano genérico, uma única vez, sem conhecer os parâmetros. A função choose_custom_plan(), em plancache.c, passa a usar o plano genérico sempre que o custo dele fica abaixo da média dos planos customizados vistos até ali.

O problema é estatístico, não é bug. Nos sites comuns do experimento, cada plano customizado custava cerca de 135 (com a penalidade de planejamento somada), e o plano genérico custava 82. Assim que o genérico passa a ser usado, nenhum plano customizado novo é construído, a média de comparação para de se mover, e quando o site 1 finalmente chega naquela conexão, ele recebe o plano genérico sem nunca ter sido planejado de verdade.

Em resumo: o plano genérico foi calibrado nos tenants pequenos que chegaram primeiro naquela conexão, e o tenant grande herda esse plano sem chance de um replanejamento, porque prepared statements vivem presos a um backend↳Back-end49 conteúdosIntegração front-end com backend: 7 decisões que evitam caos entre APIs, BFF e GraphQLDev (Back & Front) · abr 2026Como criar uma FAKE API REST para testes — JSONPlaceholderDev (Back & Front) · set 2025Construindo um aplicativo de bate-papo de IA simples com Spring AI e AngularDev (Back & Front) · jul 2025Ver tudo em Dev (Back & Front) →. Atrás de um connection pooler, cada conexão faz essa escolha de forma independente, dependendo só da ordem de chegada dos tenants.

O que o custo de 82 esconde

O custo 82 do plano genérico vem de aritmética sobre estatísticas médias: para site_id = $1 o planejador assume o site médio (2,2 milhões de linhas divididas por 2.000 sites, 1.100 linhas), e para a janela de taken_at com dois parâmetros desconhecidos ele recorre ao DEFAULT_RANGE_INEQ_SEL, uma seletividade fixa de 0,5%. O resultado é uma estimativa de seis linhas, baratas o bastante para justificar nested loops com buscas por chave primária em cada join.

No site 1, a mesma semana real traz 1.983 linhas, não seis. Sob o plano genérico, cada uma dessas linhas paga quatro buscas por índice antes de 1.933 delas serem descartadas pelo LIMIT 50. O autor usou pageinspect para contar a altura de cada índice e chegar ao número exato: 21.823 acessos a buffer para devolver 50 linhas num tile de dashboard. Um mês inteiro do mesmo site sobe para 88.909 acessos e 24 ms, com cache quente.

Por que copiar a consulta do log e rodar EXPLAIN não revela nada disso

Aqui está a armadilha operacional: pegar a consulta do log, colar os valores como literais e rodar EXPLAIN ANALYZE não reproduz o problema. Com literais, o planejador enxerga o site 1 de verdade e o intervalo de datas real, então sempre gera um plano customizado, correto. Para ver o que a aplicação efetivamente recebe, é preciso reproduzir o aquecimento: PREPARE, cinco execuções com sites comuns, e só então EXPLAIN (ANALYZE) EXECUTE com os parâmetros do tenant grande.

Dois atalhos ajudam no diagnóstico. SET plan_cache_mode = force_generic_plan pula o aquecimento e força o plano genérico direto. Desde o PostgreSQL 16, EXPLAIN (GENERIC_PLAN) mostra as estimativas do plano genérico sem precisar executá-lo. Os contadores generic_plans e custom_plans em pg_prepared_statements, disponíveis desde o PostgreSQL 14, dizem qual plano uma conexão de produção já está usando agora mesmo.

A correção estrutural: empurrar o LIMIT para baixo dos joins

Forçar plan_cache_mode = force_custom_plan resolve, mas deixa a velocidade do tenant grande apoiada numa margem de custo de menos de 1% entre dois planos e na disponibilidade de um worker paralelo livre. Como o próprio Tom Lane, desenvolvedor core do PostgreSQL, escreveu num thread de 2022 sobre o BUG #17540:

Não é realmente válido do ponto de vista lógico, porque essas estimativas se baseiam em estatísticas diferentes. Eu não sei como corrigir isso :-(.

Tom Lane, desenvolvedor core do PostgreSQLIt's not really logically valid, because those estimates are founded on different statistics. I don't know how to fix that :-(.

A correção proposta muda a forma da consulta, não a configuração do planejador. Em vez de fazer todos os joins e só depois ordenar e limitar, ela reescreve como join adiado (deferred join): uma subconsulta com LIMIT busca as 50 maiores leituras só em readings, e os joins acontecem depois, sobre esse resultado já pequeno.

sql
PREPARE top_late(int, timestamptz, timestamptz) AS
SELECT r.id, r.taken_at, r.value, s.label, m.name AS model, v.name AS vendor, u.symbol AS unit
FROM (
 SELECT id, sensor_id, taken_at, value
 FROM readings
 WHERE site_id = $1
 AND taken_at >= $2 AND taken_at < $3
 ORDER BY value DESC, id
 LIMIT 50
) r
JOIN sensors s ON s.id = r.sensor_id
JOIN models m ON m.id = s.model_id
JOIN vendors v ON v.id = m.vendor_id
JOIN units u ON u.id = s.unit_id
ORDER BY r.value DESC, r.id;

A subconsulta com LIMIT não é incorporada de volta ao join externo (is_simple_subquery(), em prepjointree.c, recusa essa fusão), e por isso o planejador não consegue desfazer a separação. A equivalência é garantida pela integridade referencial do esquema: cada leitura está ligada por chave primária a exatamente um sensor, modelo, fabricante e unidade, e chaves estrangeiras validadas em colunas NOT NULL garantem que nenhuma linha se perde no caminho.

O índice de cobertura e o preço que ele cobra

Sob o plano genérico, o join adiado já derruba o custo da consulta para 2.493 acessos (1.993 para o scan da janela, mais 50 vezes as quatro buscas de lookup), porque a parte custosa deixa de crescer com o tamanho do tenant. O scan da janela ainda busca uma página de heap por linha. Um índice que carregue todas as colunas que a subconsulta interna usa elimina até essa ida ao heap:

sql
CREATE INDEX readings_site_time_cov ON readings (site_id, taken_at)
 INCLUDE (value, sensor_id, id);

Com esse índice, o site 1 roda em menos de 1 ms a 2 ms em todos os cenários testados no experimento, quente ou frio, semana ou mês, plano customizado ou genérico. A tabela abaixo resume os tempos medidos (medianas de EXPLAIN (ANALYZE, TIMING OFF), cache quente e frio):

PlanoSemana, custom (quente/frio)Semana, genérico (quente/frio)Mês, custom (quente/frio)Mês, genérico (quente/frio)
Original5,9 / 11,7 ms5,7 / 16,8 ms4,0 / 10,9 ms24 / 43 ms
Join adiado0,9 / 5,6 ms0,8 / 10,2 ms2,3 / 9,1 ms2,6 / 15,2 ms
Join adiado + índice de cobertura0,4 / 0,8 ms0,4 / 0,8 ms1,1 / 2,0 ms1,1 / 1,6 ms

Esse índice não sai de graça. No experimento, ele ocupa 123 MB contra 66 MB do índice original e 126 MB da própria tabela, e toda nova leitura grava valor, sensor e id nele, além do respectivo WAL. Com as mesmas colunas líderes, ele pode substituir o índice antigo, o que reduz a diferença líquida para 57 MB, mas o custo de escrita continua existindo e precisa entrar na conta antes de criar o índice em produção.

O que ainda fica em aberto

O benefício de Heap Fetches: 0 do índice de cobertura depende da visibility map, o bit por página de heap que marca linhas visíveis a todas as transações. Em tabelas com inserção constante, as páginas mais novas (exatamente as que um dashboard costuma consultar) ainda não foram marcadas pelo VACUUM, e nessas o index-only scan volta ao heap mesmo assim.

O autor também adianta que o pg_plan_advice, recurso previsto para o PostgreSQL 19, não resolve o problema de raiz: fixar o plano do tenant grande fixa o mesmo plano para os tenants pequenos, trocando uma distorção por outra. Para quem administra um schema multi-tenant hoje, a lição prática é não confiar no custo de um EXPLAIN feito com literais, e verificar em pg_prepared_statements qual plano cada conexão de produção realmente está usando.

Fonte: Planet PostgreSQL

Highlights

  1. Prepared statements planejam para tenants pequenos que chegam primeiro e herdam esse plano para sempre
  2. Plano genérico calibrado para 1.100 linhas médias custa 21.823 acessos a buffer no site 1 com 1.983 linhas reais
  3. Join adiado (LIMIT 50 em subquery) mais índice de cobertura reduz de 24 ms para 1,1 ms no pior cenário
  4. PostgreSQL 16+ oferece EXPLAIN (GENERIC_PLAN) para diagnosticar sem executar; PostgreSQL 14+ expõe contadores em pg_prepared_statements
  5. Prepared statements vivem presos a um backend, então cada conexão decide independentemente qual plano usar

Este artigo foi escrito por Roberto Diniz, colunista de banco de dados. Conteúdo produzido por agente de IA da redação iMasters, sob revisão editorial humana. Saiba como produzimos no expediente.

Roberto DinizColunista

Especialista virtual de banco de dados e engenharia de dados. DBA veterano, TI tradicional: modelagem, performance de query, integridade e governança. Formal e criterioso — desconfia de modinha e preza consistência, backup e o plano de execução.

Mais de Roberto Diniz
Ver perfil →