MySQL: maneira mais rápida de contar o número de linhas

Qual forma de contar várias linhas deve ser mais rápida no MySQL?

Este:

SELECT COUNT(*) FROM ... WHERE ...

Ou a alternativa:

SELECT 1 FROM ... WHERE ...

// and then count the results with a built-in function, e.g. in PHP mysql_num_rows()

Alguém poderia pensar que o primeiro método deveria ser mais rápido, já que este é claramente o território do banco de dados e o mecanismo de banco de dados deveria ser mais rápido do que qualquer outra pessoa ao determinar coisas como essa internamente.

Quando você COUNT(*)leva em índices de coluna de contagem, então será o melhor resultado. Mysql com mecanismo MyISAM realmente armazena contagem de linhas, ele não conta todas as linhas cada vez que você tenta contar todas as linhas. (com base na coluna da chave primária)

Usar o PHP para contar linhas não é muito inteligente, porque você tem que enviar dados do mysql para o php. Por que fazer isso quando você pode conseguir o mesmo no lado do mysql?

Se o COUNT(*)for lento, você deve executar EXPLAINa consulta e verificar se os índices são realmente usados ​​e onde devem ser adicionados.

O seguinte não é o caminho mais rápido , mas há um caso em COUNT(*)que realmente não se encaixa - quando você começa a agrupar os resultados, pode ter problemas, ondeCOUNT realmente não conta todas as linhas.

A solução é SQL_CALC_FOUND_ROWS. Isso geralmente é usado quando você está selecionando linhas, mas ainda precisa saber a contagem total de linhas (por exemplo, para paginação). Ao selecionar linhas de dados, basta anexar a SQL_CALC_FOUND_ROWSpalavra - chave após SELECT:

SELECT SQL_CALC_FOUND_ROWS [needed fields or *] FROM table LIMIT 20 OFFSET 0;

Depois de selecionar as linhas necessárias, você pode obter a contagem com esta única consulta:

SELECT FOUND_ROWS();

FOUND_ROWS() deve ser chamado imediatamente após a consulta de seleção de dados.

Em conclusão, tudo se resume a quantas entradas você tem e o que está na instrução WHERE. Você realmente deve prestar atenção em como os índices estão sendo usados, quando há muitas linhas (dezenas de milhares, milhões e mais).

Depois de falar com meus companheiros de equipe, Ricardo nos disse que a maneira mais rápida é:

show table status like '<TABLE NAME>' \G

Mas é preciso lembrar que o resultado pode não ser exato.

Você também pode usá-lo na linha de comando:

$ mysqlshow --status <DATABASE> <TABLE NAME>

Mais informações: http://dev.mysql.com/doc/refman/5.7/en/show-table-status.html

E você pode encontrar uma discussão completa em mysqlperformanceblog

Ótima pergunta, ótimas respostas. Esta é uma maneira rápida de repetir os resultados se alguém estiver lendo esta página e perder aquela parte:

$counter = mysql_query("SELECT COUNT(*) AS id FROM table");
$num = mysql_fetch_array($counter);
$count = $num["id"];
echo("$count");

Esta consulta (que é semelhante ao que bayuah postou ) mostra um bom resumo de todas as contagens de tabelas dentro de um banco de dados: (versão simplificada do procedimento armazenado por Ivan Cachicatari que eu recomendo fortemente).

SELECT TABLE_NAME AS 'Table Name', TABLE_ROWS AS 'Rows' FROM information_schema.TABLES WHERE TABLES.TABLE_SCHEMA = '`YOURDBNAME`' AND TABLES.TABLE_TYPE = 'BASE TABLE'; 

Exemplo:

+-----------------+---------+
| Table Name      | Rows    |
+-----------------+---------+
| some_table      |   10278 |
| other_table     |     995 |

Sempre entendi que o que segue me dará os tempos de resposta mais rápidos.

SELECT COUNT(1) FROM ... WHERE ...

Se você precisar obter a contagem de todo o conjunto de resultados, poderá seguir a seguinte abordagem:

SELECT SQL_CALC_FOUND_ROWS * FROM table_name LIMIT 5;
SELECT FOUND_ROWS();

Normalmente, isso não é mais rápido do que usar, COUNTembora se possa pensar o contrário, porque está fazendo o cálculo internamente e não envia os dados de volta ao usuário, portanto, suspeita-se de uma melhoria de desempenho.

Fazer essas duas consultas é bom para paginação para obter totais, mas não particularmente para usar WHEREcláusulas.

Fiz alguns benchmarks para comparar o tempo de execução de COUNT(*)vs COUNT(id)(id é a chave primária da tabela - indexada).

Número de testes: 10 * 1000 consultas

Resultados: COUNT(*) é mais rápido 7%

VER GRÁFICO: benchmarkgraph

Meu conselho é usar: SELECT COUNT(*) FROM table

Experimente isto:

SELECT
    table_rows "Rows Count"
FROM
    information_schema.tables
WHERE
    table_name="Table_Name"
AND
    table_schema="Database_Name";

Talvez você queira considerar fazer a SELECT max(Id) - min(Id) + 1. Isso só funcionará se seus IDs forem sequenciais e as linhas não forem excluídas. No entanto, é muito rápido.

EXPLAIN SELECT id FROM ....fez o truque para mim. e pude ver o número de linhas sob a rowscoluna do resultado.

Lidei com tabelas para o governo alemão com às vezes 60 milhões de registros.

E precisávamos saber muitas vezes o total de linhas.

Assim, nós, programadores de banco de dados, decidimos que em cada tabela o registro um é sempre o registro no qual o número total de registros está armazenado. Atualizamos esse número, dependendo das linhas INSERT ou DELETE.

Tentamos de todas as outras maneiras. Esta é de longe a maneira mais rápida.

Uma instrução count (*) com uma condição where na chave primária retornou a contagem de linhas muito mais rápido para mim, evitando a varredura completa da tabela.

SELECT COUNT(*) FROM ... WHERE <PRIMARY_KEY> IS NOT NULL;

Isso foi muito mais rápido para mim do que

SELECT COUNT(*) FROM ...