Qual é o mais rápido? SELECT SQL_CALC_FOUND_ROWS FROM `table` ou SELECT COUNT (*)

Quando você limita o número de linhas a serem retornadas por uma consulta SQL, geralmente usada em paginação, existem dois métodos para determinar o número total de registros:

Método 1

Inclua a SQL_CALC_FOUND_ROWSopção no original SELECTe obtenha o número total de linhas executando SELECT FOUND_ROWS():

SELECT SQL_CALC_FOUND_ROWS * FROM table WHERE id > 100 LIMIT 10;
SELECT FOUND_ROWS();  

Método 2

Execute a consulta normalmente e obtenha o número total de linhas executando SELECT COUNT(*)

SELECT * FROM table WHERE id > 100 LIMIT 10;
SELECT COUNT(*) FROM table WHERE id > 100;  

Qual método é o melhor / mais rápido?

Depende. Veja a publicação do MySQL Performance Blog sobre este assunto: http://www.mysqlperformanceblog.com/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/

Apenas um resumo rápido: Peter diz que depende de seus índices e de outros fatores. Muitos dos comentários à postagem parecem dizer que SQL_CALC_FOUND_ROWS é quase sempre mais lento - às vezes até 10 vezes mais lento - do que executar duas consultas.

Ao escolher a "melhor" abordagem, uma consideração mais importante que a velocidade pode ser a manutenção e a correção do seu código. Nesse caso, é preferível SQL_CALC_FOUND_ROWS porque você precisa manter apenas uma única consulta. O uso de uma única consulta impede completamente a possibilidade de uma diferença sutil entre as consultas principal e a contagem, o que pode levar a uma COUNT imprecisa.

O MySQL começou a descontinuar a SQL_CALC_FOUND_ROWSfuncionalidade com a versão 8.0.17 em diante.

Portanto, é sempre preferível considerar a execução de sua consulta com LIMITe, em seguida, uma segunda consulta com COUNT(*)e sem LIMITpara determinar se há linhas adicionais.

Dos documentos :

O modificador de consulta SQL_CALC_FOUND_ROWS e a função FOUND_ROWS () acompanhante estão obsoletos no MySQL 8.0.17 e serão removidos em uma versão futura do MySQL.

COUNT (*) está sujeito a determinadas otimizações. SQL_CALC_FOUND_ROWS faz com que algumas otimizações sejam desativadas.

Use estas consultas:

SELECT * FROM tbl_name WHERE id > 100 LIMIT 10;
SELECT COUNT(*) WHERE id > 100;

Além disso, SQL_CALC_FOUND_ROWSfoi observado que há mais problemas em geral, conforme explicado no MySQL WL # 12615 :

SQL_CALC_FOUND_ROWS tem vários problemas. Primeiro de tudo, é lento. Freqüentemente, seria mais barato executar a consulta com LIMIT e, em seguida, um SELECT COUNT ( ) separado para a mesma consulta, pois COUNT ( ) pode fazer uso de otimizações que não podem ser feitas na pesquisa de todo o conjunto de resultados (por exemplo, filesort pode ser ignorado por COUNT (*), enquanto que com CALC_FOUND_ROWS, é necessário desativar algumas otimizações de classificadores de arquivos para garantir o resultado certo)

Mais importante, ele tem semântica muito clara em várias situações. Em particular, quando uma consulta possui vários blocos de consulta (por exemplo, com UNION), simplesmente não há como calcular o número de linhas "possíveis" ao mesmo tempo em que produz uma consulta válida. Como o executor do iterador está progredindo em direção a esse tipo de consulta, é realmente difícil tentar manter a mesma semântica. Além disso, se houver vários LIMITs na consulta (por exemplo, para tabelas derivadas), não está necessariamente claro a qual deles SQL_CALC_FOUND_ROWS deve se referir. Portanto, essas consultas não triviais necessariamente terão semânticas diferentes no executor do iterador em comparação com as que tinham antes.

Finalmente, a maioria dos casos de uso em que SQL_CALC_FOUND_ROWS parece útil deve ser resolvida por outros mecanismos que não sejam LIMIT / OFFSET. Por exemplo, uma lista telefônica deve ser paginada por letra (tanto em termos de UX quanto em termos de uso do índice), não por número de registro. As discussões são cada vez mais infinitas, com rolagem ordenada por data (permitindo novamente o uso do índice), não por paginação pelo número da postagem. E assim por diante.

De acordo com o seguinte artigo: https://www.percona.com/blog/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/

Se você tiver um INDEX na sua cláusula where (se o id estiver indexado no seu caso), é melhor não usar SQL_CALC_FOUND_ROWS e, em vez disso, use 2 consultas, mas se você não tiver um índice sobre o que você coloca na cláusula where (id no seu caso), usar SQL_CALC_FOUND_ROWS é mais eficiente.

IMHO, a razão pela qual 2 consultas

SELECT * FROM count_test WHERE b = 666 ORDER BY c LIMIT 5;
SELECT count(*) FROM count_test WHERE b = 666;

são mais rápidos do que usar SQL_CALC_FOUND_ROWS

SELECT SQL_CALC_FOUND_ROWS * FROM count_test WHERE b = 555 ORDER BY c LIMIT 5;

tem que ser visto como um caso particular.

De fato, depende da seletividade da cláusula WHERE comparada à seletividade da implícita equivalente à ORDER + LIMIT.

Como Arvids disse no comentário ( http://www.mysqlperformanceblog.com/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/#comment-1174394 ), o fato de o EXPLAIN usar ou não, tabela temporária, deve ser uma boa base para saber se o SCFR será mais rápido ou não.

Mas, como eu adicionei ( http://www.mysqlperformanceblog.com/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/#comment-8166482 ), o resultado realmente depende do caso. Para um paginador específico, você pode concluir que “nas 3 primeiras páginas, use 2 consultas; para as páginas seguintes, use um SCFR ”!

Remover alguns SQL desnecessários e depois COUNT(*)será mais rápido que SQL_CALC_FOUND_ROWS. Exemplo:

SELECT Person.Id, Person.Name, Job.Description, Card.Number
FROM Person
JOIN Job ON Job.Id = Person.Job_Id
LEFT JOIN Card ON Card.Person_Id = Person.Id
WHERE Job.Name = 'WEB Developer'
ORDER BY Person.Name

Depois conte sem parte desnecessária:

SELECT COUNT(*)
FROM Person
JOIN Job ON Job.Id = Person.Job_Id
WHERE Job.Name = 'WEB Developer'

Existem outras opções para você comparar:

1.) Uma função de janela retornará o tamanho real diretamente (testado no MariaDB):

SELECT 
  `mytable`.*,
  COUNT(*) OVER() AS `total_count`
FROM `mytable`
ORDER BY `mycol`
LIMIT 10, 20

2.) Pensando fora da caixa, na maioria das vezes os usuários não precisam saber o tamanho EXATO da tabela, uma aproximação geralmente é boa o suficiente.

SELECT `TABLE_ROWS` AS `rows_approx`
FROM `INFORMATION_SCHEMA`.`TABLES`
WHERE `TABLE_SCHEMA` = DATABASE()
  AND `TABLE_TYPE` = "BASE TABLE"
  AND `TABLE_NAME` = ?