# Slow query log do MySQL: ativar e achar a consulta lenta

O critério numérico que separa índice faltando de falta de recurso, nos três cenários de permissão: my.cnf com root, SET GLOBAL sem reiniciar e performance_schema em conta sem SUPER.

> ative o slow query log com long_query_time = 0.5 e classifique cada digest pela razão Rows_examined/Rows_sent: acima de ~100 linhas lidas por linha devolvida com Lock_time perto de zero é índice faltando; razão perto de 1 com Query_time alto é IO, volume ou contenção.

João Rizzon · 2026-09-29 · Servidores

---

Ativar o `slow_query_log` é a parte fácil. O que costuma faltar é o critério para ler o arquivo: com trinta digests no relatório, qual deles justifica criar índice, qual justifica reescrever a consulta e qual é sintoma de concorrência ou IO, não de SQL ruim. A razão entre linhas examinadas e linhas devolvidas resolve a maior parte dessa triagem em segundos, antes de qualquer `EXPLAIN`.

Este artigo é documental. Não há medição da Napoleon aqui: os trechos de log e os números dentro deles são exemplos rotulados como exemplos, e o procedimento de ativação em servidor cPanel segue a [documentação oficial do cPanel](https://docs.cpanel.net/knowledge-base/sql/how-to-enable-the-slow-query-log-in-mysql-or-mariadb/).

## Rows_examined dividido por Rows_sent é o critério de triagem

Cada entrada do slow log traz `Rows_sent` (linhas entregues ao cliente) e `Rows_examined` (linhas que o servidor teve que ler, no storage engine, para produzir aquelas linhas). A divisão entre os dois é um estimador direto de seletividade de acesso.

Se uma consulta devolve 12 linhas e examinou 418.922, o servidor fez varredura e descartou quase tudo em memória. Nenhum ajuste de `innodb_buffer_pool_size` conserta isso de forma estrutural: o trabalho existe porque o caminho de acesso é errado, e ele cresce junto com a tabela.

Se a consulta devolve 250.000 linhas e examinou 251.100, o caminho de acesso está correto. O tempo alto vem de outro lugar: volume legítimo de dados (falta de `LIMIT`, export, relatório), IO frio, CPU disputada ou espera por lock. Aí a leitura muda de "falta índice" para "falta recurso ou falta paginação".

| Sinal na entrada do log | Rows_examined / Rows_sent | Lock_time | Leitura provável | Primeira ação |
|---|---|---|---|---||
| Poucas linhas devolvidas, muitas lidas | acima de ~100 | próximo de 0 | índice ausente ou não usado no filtro | `EXPLAIN` e índice composto no `WHERE` + `ORDER BY` |
| Linhas lidas proporcionais ao resultado, `Query_time` alto | próximo de 1 | próximo de 0 | volume de dados, IO ou CPU | paginar, reduzir colunas, cachear, revisar recurso |
| `Lock_time` responde por boa parte do `Query_time` | qualquer | dominante | espera por lock de tabela ou metadata lock: DDL em andamento, `LOCK TABLES`, backup | `performance_schema.metadata_locks` e `sys.schema_table_lock_waits` |
| Muitas linhas lidas e muitas devolvidas | acima de 10 e `Rows_sent` na casa dos milhares | baixo | consulta sem `LIMIT` servindo tela paginada | corrigir a aplicação, não o banco |
| `Rows_sent: 0` repetido, `Rows_examined` alto | infinito na prática | baixo | checagem de existência varrendo tabela | índice no predicado, `EXISTS` em vez de `COUNT(*)` |

O limite de ~100 é heurística de triagem, não constante do MySQL. Serve para ordenar a fila de trabalho: os digests com razão de três dígitos quase sempre são resolvidos por índice, e resolvidos sem trocar de plano.

## O que cada linha de uma entrada do slow log diz

O exemplo abaixo é fictício, escrito para este artigo:

```
# Time: 2026-09-17T03:14:22.118371Z
# User@Host: siteuser[siteuser] @ localhost []  Id: 41288
# Query_time: 2.417533  Lock_time: 0.000112  Rows_sent: 12  Rows_examined: 418922
use siteuser_wp;
SET timestamp=1789614862;
SELECT p.ID, p.post_title FROM wp_posts p
  JOIN wp_postmeta m ON m.post_id = p.ID
 WHERE m.meta_key = 'evento_data' AND m.meta_value >= '2026-09-01'
 ORDER BY m.meta_value ASC LIMIT 12;
```

Razão: 418922 / 12, ou seja, cerca de 34.900 linhas lidas por linha entregue. `Lock_time` é 0,0001 s, então ninguém está esperando lock. `Query_time` de 2,41 s é trabalho próprio da consulta. Isso é o primeiro caso da tabela, e o alvo é o predicado em `meta_value` mais a ordenação pelo mesmo campo.

Contraste, também fictício:

```
# Query_time: 3.882104  Lock_time: 3.410992  Rows_sent: 1  Rows_examined: 1
SELECT option_value FROM wp_options WHERE option_name = 'siteurl' LIMIT 1;
```

Uma linha lida para uma devolvida, plano perfeito, e 3,41 s dos 3,88 s gastos esperando. A consulta é vítima.

Vale precisar o que `Lock_time` mede, porque isso muda a tabela onde você vai procurar o culpado: no slow log, `Lock_time` é espera por lock de tabela e por metadata lock (MDL), adquiridos pela camada SQL antes da execução. Espera por row lock do InnoDB **não** aparece em `Lock_time`: ela fica embutida no `Query_time`. Então um `Lock_time` de 3,41 s aponta para `ALTER TABLE` ou outro DDL segurando MDL exclusivo, `LOCK TABLES`, `FLUSH TABLES WITH READ LOCK` de backup, ou `mysqldump` sem `--single-transaction` em tabelas MyISAM.

Onde olhar em cada caso:

```sql
-- espera por MDL / lock de tabela: quem detém e quem espera
-- (MySQL 8 instrumenta wait/lock/metadata/sql/mdl por padrão;
--  em 5.7 confira setup_instruments antes de confiar na tabela vazia)
SELECT OBJECT_TYPE, OBJECT_SCHEMA, OBJECT_NAME,
       LOCK_TYPE, LOCK_STATUS, OWNER_THREAD_ID
  FROM performance_schema.metadata_locks
 WHERE OBJECT_TYPE IN ('TABLE','SCHEMA','GLOBAL');

SELECT * FROM sys.schema_table_lock_waits;
```

```sql
-- espera por row lock: não aparece em Lock_time, aparece dentro de Query_time
SELECT trx_id, trx_started, trx_state, trx_rows_locked, trx_query
  FROM information_schema.INNODB_TRX
 ORDER BY trx_started;

SELECT * FROM performance_schema.data_lock_waits;
```

Regra de bolso: `Lock_time` alto manda você para `metadata_locks` e para quem está fazendo DDL ou backup. `Lock_time` perto de zero com `Query_time` alto e razão perto de 1 pode ser row lock, e aí a fonte é `INNODB_TRX` e `data_lock_waits`. `SHOW FULL PROCESSLIST` serve para os dois, procurando estados como `Waiting for table metadata lock`.

## Três formas de ativar, conforme o seu nível de acesso

### Com root no servidor, editando o my.cnf

É o caminho persistente. A documentação do cPanel descreve editar `/etc/my.cnf`, na seção `[mysqld]`, e reiniciar o serviço do MySQL ou MariaDB para que o log passe a ser gravado; o arquivo de destino precisa existir e pertencer ao usuário do banco, caso contrário o serviço não consegue escrever nele. Consulte o procedimento e os caminhos exatos na [página oficial](https://docs.cpanel.net/knowledge-base/sql/how-to-enable-the-slow-query-log-in-mysql-or-mariadb/) antes de mexer, porque o layout de diretórios varia com a versão do servidor.

```ini
[mysqld]
slow_query_log = 1
slow_query_log_file = /var/log/slowquery.log
long_query_time = 0.5
min_examined_row_limit = 0
log_queries_not_using_indexes = 0
log_output = FILE
```

`min_examined_row_limit = 0` é deliberado, e é o padrão do servidor. Esse piso descarta do slow log qualquer entrada abaixo do valor, incluindo a do segundo exemplo acima (`Rows_examined: 1` com 3,41 s de espera por lock). Se você subir para 1000 de saída, some exatamente a linha de contenção da tabela de triagem. Suba só na janela em que `log_queries_not_using_indexes` estiver ligado, como explicado adiante.

Depois do restart, confirme o que o servidor realmente carregou, em vez de confiar no arquivo:

```sql
SHOW GLOBAL VARIABLES WHERE Variable_name IN
 ('slow_query_log','slow_query_log_file','long_query_time',
  'min_examined_row_limit','log_queries_not_using_indexes','log_output');
```

Risco a considerar: reiniciar o serviço derruba conexões abertas. Se o site está em pico, prefira o caminho 2 agora e deixe o `my.cnf` para a próxima janela.

### Sem reiniciar o serviço, com SET GLOBAL

`slow_query_log`, `long_query_time`, `min_examined_row_limit` e `log_queries_not_using_indexes` são variáveis dinâmicas. Com privilégio administrativo (`SYSTEM_VARIABLES_ADMIN` no MySQL 8, `SUPER` no MariaDB), dá para ligar o log em produção sem downtime:

```sql
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 0.5;
SET GLOBAL min_examined_row_limit = 0;   -- mantém entradas de Lock_time alto
```

Dois detalhes que costumam custar meia hora de confusão:

- `long_query_time` tem escopo de sessão além do global. Cada conexão copia o valor global no momento em que se conecta. Pools persistentes (PHP-FPM com `mysqli.allow_persistent`, aplicações Java) continuam usando o valor antigo até reconectar. Para testar na hora, use `SET SESSION long_query_time = 0.5;` na sua própria conexão. O mesmo valia para `min_examined_row_limit`, que também tem escopo de sessão.
- `SET GLOBAL` se perde no restart. No MySQL 8 existe `SET PERSIST`, que grava em `mysqld-auto.cnf`; no MariaDB não existe equivalente, e a persistência é o `my.cnf`.

### Sem privilégio SUPER, lendo o performance_schema

Em conta compartilhada você não liga o slow log, mas o servidor pode já estar agregando tudo que você precisa. Se `performance_schema` estiver ativo e o consumidor `statements_digest` habilitado, a tabela `events_statements_summary_by_digest` traz exatamente as duas colunas do critério, somadas por digest:

```sql
SELECT SCHEMA_NAME,
       LEFT(DIGEST_TEXT, 100)                            AS consulta,
       COUNT_STAR                                        AS execs,
       ROUND(SUM_TIMER_WAIT/1e12, 2)                     AS total_s,
       ROUND(AVG_TIMER_WAIT/1e9, 2)                      AS media_ms,
       SUM_ROWS_SENT                                     AS enviadas,
       SUM_ROWS_EXAMINED                                 AS examinadas,
       ROUND(SUM_ROWS_EXAMINED/GREATEST(SUM_ROWS_SENT,1), 1) AS razao,
       ROUND(SUM_LOCK_TIME/1e12, 2)                      AS lock_s,
       SUM_NO_INDEX_USED                                 AS sem_indice,
       SUM_CREATED_TMP_DISK_TABLES                       AS tmp_disco
  FROM performance_schema.events_statements_summary_by_digest
 ORDER BY SUM_TIMER_WAIT DESC
 LIMIT 15;
```

Os timers do performance_schema são picossegundos, daí `/1e12` para segundos e `/1e9` para milissegundos. `SUM_LOCK_TIME` tem a mesma semântica do `Lock_time` do slow log: espera por lock de tabela e metadata, não row lock. `SUM_NO_INDEX_USED` é o contador equivalente ao que `log_queries_not_using_indexes` registraria, sem precisar escrever nada em disco. `SUM_CREATED_TMP_DISK_TABLES` acima de zero em digest com `ORDER BY` ou `GROUP BY` indica materialização em disco, que é outra causa clássica de `Query_time` alto com razão baixa.

Se o MySQL tem o schema `sys` disponível, a view `sys.statement_analysis` já entrega `rows_examined_avg` e `rows_sent_avg` prontas e ordenadas, e é o atalho preferível.

Duas limitações honestas deste caminho: `performance_schema` só pode ser ligado na inicialização do servidor (não é dinâmico), e nem toda hospedagem concede `SELECT` nele para usuário de conta. Se os dois bloqueios se aplicam, o diagnóstico sai do banco e vai para a aplicação: log de consultas do próprio framework, `SAVEQUERIES` no WordPress com Query Monitor, APM. Nada disso exige upgrade de plano, e é bom checar antes de contratar mais CPU.

## Configurar o log para ele não encher de ruído

O valor padrão de `long_query_time` é 10 segundos. Em site que responde em 400 ms de TTFB, esse limiar registra quase nada. Fracionário resolve: `0.5` já captura o que realmente pesa em uma página, e a resolução de microssegundos vale quando o log vai para arquivo.

`log_queries_not_using_indexes` é a variável que mais gera arquivo inútil. Ligada sozinha, ela registra qualquer consulta que não usou índice, inclusive `SELECT` em tabela de 8 linhas onde a varredura é a escolha certa do otimizador. O amortecedor usual é `min_examined_row_limit`, e é aqui que mora a pegadinha.

`min_examined_row_limit` não é um filtro específico de `log_queries_not_using_indexes`. Ele é um piso global do slow log: **qualquer** consulta que examinou menos linhas que o valor fica fora do arquivo, inclusive as que passaram do `long_query_time` com folga. Com `min_examined_row_limit = 1000`, a entrada de `Rows_examined: 1` e `Lock_time: 3.41` do exemplo acima nunca é gravada, e a linha de contenção da tabela de triagem deixa de existir na prática. Conclusão operacional:

- suspeita de lock, contenção, DDL, backup ou lentidão intermitente sem padrão: deixe `min_examined_row_limit = 0`;
- caça a varredura de tabela com `log_queries_not_using_indexes = ON`: suba para `1000` durante a janela e volte a `0` quando desligar a captura.

| Variável | Sugestão inicial | Efeito |
|---|---|---||
| `long_query_time` | `0.5` | limiar em segundos, aceita fração |
| `min_examined_row_limit` | `0` no geral, `1000` só com `log_queries_not_using_indexes` ligado | piso global: descarta toda entrada que examinou menos linhas que o valor, inclusive as de `Lock_time` alto |
| `log_queries_not_using_indexes` | ligar só por janelas curtas | captura varredura abaixo do limiar de tempo |
| `log_output` | `FILE` | `TABLE` grava em `mysql.slow_log` e custa escrita no próprio banco |
| `log_slow_admin_statements` | ligar durante manutenção | inclui `ALTER`, `OPTIMIZE`, `ANALYZE`, úteis justamente quando a suspeita é MDL |

Algumas versões oferecem limitadores de taxa para não inundar o arquivo (throttle de consultas sem índice no MySQL, amostragem no MariaDB). Os nomes e o comportamento variam entre implementação e versão, então confirme na documentação da sua build antes de colocar no `my.cnf`.

## Agregar por digest antes de ler o arquivo

Ler o arquivo bruto com `tail` serve para confirmar que o log está escrevendo. Para decidir, agregue por digest, porque a consulta que aparece 4.000 vezes a 0,6 s dói mais que a que aparece uma vez a 9 s.

`mysqldumpslow` vem com o servidor e não precisa de instalação:

```bash
# top 10 por tempo total acumulado
mysqldumpslow -s t -t 10 /var/log/slowquery.log

# top 10 por tempo médio, útil para achar o pior plano
mysqldumpslow -s at -t 10 /var/log/slowquery.log

# filtrar por tabela suspeita
mysqldumpslow -s t -g 'wp_postmeta' /var/log/slowquery.log
```

`pt-query-digest`, do Percona Toolkit, dá o relatório que responde direto ao critério deste artigo, porque imprime distribuição de `Rows examine` e `Rows sent` por digest, além de percentis de tempo e de `Lock time`:

```bash
pt-query-digest --limit 5 /var/log/slowquery.log > /root/digest.txt
```

No relatório, compare a coluna de linhas examinadas com a de linhas enviadas em cada bloco de query. Razão de três dígitos, com `Lock time` perto de zero, é fila de índice. Razão perto de 1 com `Query_time` alto é fila de recurso ou de paginação. `Lock time` com percentil 95 alto é fila de DDL e backup, não de SQL.

O arquivo do slow log preserva comentários SQL, e `pt-query-digest` também. O `DIGEST_TEXT` do performance_schema normaliza o texto. Quando o objetivo é atribuição de origem, o arquivo é a fonte melhor.

## Confirmar o plano com EXPLAIN antes de criar índice

Razão alta é indício, não diagnóstico. Rode `EXPLAIN` na consulta exatamente como ela aparece no log, com os mesmos valores literais, porque o otimizador escolhe plano em função da cardinalidade estimada dos parâmetros:

```sql
EXPLAIN FORMAT=JSON
SELECT p.ID, p.post_title FROM wp_posts p
  JOIN wp_postmeta m ON m.post_id = p.ID
 WHERE m.meta_key = 'evento_data' AND m.meta_value >= '2026-09-01'
 ORDER BY m.meta_value ASC LIMIT 12;
```

O que procurar no JSON: `access_type` igual a `ALL` na tabela grande, `rows_examined_per_scan` na casa das centenas de milhares, `using_filesort` verdadeiro, `using_temporary_table` verdadeiro, e `possible_keys` vazio.

Para medir de fato em vez de estimar, existe execução instrumentada: `EXPLAIN ANALYZE SELECT ...` no MySQL 8.0.18 ou superior, e `ANALYZE FORMAT=JSON SELECT ...` no MariaDB. As duas formas executam a consulta. Consequência prática: não use em `UPDATE` ou `DELETE` fora de transação que você vai reverter, e prefira réplica ou janela de baixo movimento quando a consulta for a que está derrubando o site.

Depois de criar o índice candidato, repita `EXPLAIN` e volte ao slow log. O sinal de sucesso é o mesmo digest reaparecendo com `Rows_examined` perto de `Rows_sent`, ou desaparecendo do log porque caiu abaixo do limiar.

## Do digest de volta ao código que disparou a consulta

A consulta lenta raramente tem autor óbvio, sobretudo em CMS com dezenas de plugins. Três formas de fechar a atribuição:

### Comentário de rota carimbado na própria consulta

O caminho mais confiável é instrumentar a aplicação para carimbar a origem. O comentário viaja até o slow log:

```php
$sql = "/* rota:/relatorio-mensal origem:acme-reports */ "
     . "SELECT ... FROM pedidos WHERE ...";
```

Depois, `grep 'origem:acme-reports' /var/log/slowquery.log` fecha o caso. Em framework com ORM, isso normalmente é um hook único no builder de query.

### Pegar a consulta em flagrante no processlist

Enquanto o problema acontece, `SHOW FULL PROCESSLIST` mostra usuário, banco, tempo, estado e a consulta completa. Correlacione o `Id` da conexão com o `Id:` que aparece no cabeçalho `# User@Host` da entrada do slow log. Estado `Waiting for table metadata lock` confirma o cenário de `Lock_time` alto sem precisar de mais nada. Em servidor com vários sites por instância, o `use nome_do_banco;` gravado logo antes da consulta já identifica a conta.

### No WordPress, comece pelo autoload de wp_options

Quando o digest lento é em `wp_options`, `wp_postmeta` ou `wp_posts`, verifique o volume carregado em toda requisição:

```sql
SELECT option_name, autoload, LENGTH(option_value) AS bytes
  FROM wp_options
 ORDER BY bytes DESC
 LIMIT 20;
```

Opções grandes marcadas para carregar sempre (transients órfãos, cache de plugin, logs guardados em option) fazem cada pageview pagar por elas. Versões recentes do WordPress mudaram os valores aceitos na coluna `autoload`, então confira quais valores aparecem na sua instalação antes de filtrar por igualdade.

Para amarrar consulta a plugin no nível do PHP, `define('SAVEQUERIES', true);` no `wp-config.php` mais o plugin Query Monitor mostram a pilha de chamada de cada query. Isso custa memória e grava tudo em cada request: ligue em staging, ou em produção por minutos, e desligue.

## Quanto custa deixar ligado e como reverter

Cada entrada do slow log são quatro a seis linhas de texto, escritas de forma síncrona no arquivo. Com limiar de 0,5 s e `log_queries_not_using_indexes` desligado, o volume é pequeno mesmo com `min_examined_row_limit = 0`. Com `log_queries_not_using_indexes` ligado e sem piso de linhas, o arquivo cresce rápido, e partição cheia é incidente pior do que a consulta lenta original: o servidor pode falhar em escrever log, e a partição do sistema afeta todo o resto.

Três precauções:

- monitore o tamanho (`du -h /var/log/slowquery.log`) nas primeiras horas;
- rotacione com `mv` seguido de `FLUSH SLOW LOGS` para o servidor reabrir o arquivo, em vez de truncar arquivo aberto;
- prefira `log_output = FILE`. Com `TABLE`, cada consulta lenta gera escrita dentro do próprio banco que você está tentando aliviar.

Janela típica de coleta: um período que contenha o pico do site e as rotinas agendadas (cron, backup, importação). As rotinas agendadas são justamente onde aparecem os `Lock_time` altos, então não corte a janela antes delas. Depois disso, desligue.

```sql
-- reversão dinâmica, sem restart
SET GLOBAL slow_query_log = 'OFF';
SET GLOBAL log_queries_not_using_indexes = 'OFF';
SET GLOBAL long_query_time = 10;
SET GLOBAL min_examined_row_limit = 0;
```

```bash
# reversão persistente: remover as linhas do [mysqld] e reiniciar o serviço
# depois, guardar o arquivo fora do servidor e liberar o espaço
gzip /var/log/slowquery.log && mv /var/log/slowquery.log.gz /root/
```

Se você usou `SET PERSIST` no MySQL 8, a reversão completa exige `RESET PERSIST slow_query_log;` (e as demais variáveis), senão o valor volta no próximo restart a partir do `mysqld-auto.cnf`.

Guarde o relatório do `pt-query-digest` da janela antes da correção. Ele é a linha de base contra a qual você compara o log depois do índice, e é o que permite afirmar que a mudança funcionou em vez de supor.

