Eu quero entender o seguinte.
Suponha que eu tenha uma consulta complicada com, digamos, uma junção de 5 tabelas por grupo por somatórios e por ordem.
Deixando de lado quaisquer otimizações para a própria consulta, por exemplo, índices etc.
Existe algum benefício significativo de desempenho usando LIMIT? Suponho que toda a consulta (e resultados) deve ser processada antes da aplicação de LIMIT; portanto, usando um LIMIT para recuperar um subconjunto dos resultados, isso oferece alguma melhoria significativa / perceptível?

Se você deseja aproveitar LIMITpara melhorar o desempenho, precisa

• entender os dados que você está recuperando
• indexação adequada da sequência correta de colunas
• assumir a responsabilidade de refatorar a consulta
• usando LIMITantesJOIN

Esses princípios podem percorrer um longo caminho se você puder orquestrá-los.

Aprendi esses conceitos assistindo a este vídeo do YouTube (ouça com atenção o sotaque francês)

Usei esses conceitos para responder a uma pergunta muito difícil do StackOverflow sobre como obter os 40 principais artigos de algumas tabelas: 12 de maio de 2011: Buscando uma única linha da tabela de junção .

Na minha resposta a essa pergunta (16 de maio de 2011) , escrevi a seguinte consulta e a testei completamente:

SELECT
  AAA.author_id,
  AAA.date_created,
  IFNULL(BBB.title,'<NO_TITLE>') title,
  IFNULL(CCC.filename,'<NO-IMAGE>') filename,
  IFNULL(CCC.date_added,'<NO-IMAGE-DATE>') image_date
FROM
(
  SELECT
    AA.id,
    AA.date_added,
    BB.author_id,
    BB.date_created
  FROM
  (
    SELECT
      A.id,IFNULL(MAX(B.date_added),'1900-01-01 00:00:00') date_added
      FROM (SELECT id FROM articles ORDER BY date_created DESC LIMIT 40) A
      LEFT JOIN article_images B ON A.id = B.article_id
      GROUP BY A.id
  ) AA
  INNER JOIN articles BB USING (id)
) AAA
LEFT JOIN article_contents BBB ON AAA.id=BBB.article_id
LEFT JOIN article_images CCC
ON (AAA.id=CCC.article_id AND AAA.date_added=CCC.date_added)
ORDER BY AAA.date_created DESC;

Observe a linha na consulta com o LIMIT

      FROM (SELECT id FROM articles ORDER BY date_created DESC LIMIT 40) A

Esta subconsulta está enterrada a três níveis de profundidade. Isso me permitiu obter os últimos 40 artigos usando LIMIT. Depois, executei os JOINs necessários depois.

LIÇÕES APRENDIDAS

• Fazer LIMITsubconsultas internas nem sempre pode ser a resposta devido à cardinalidade dos índices, ao conteúdo dos dados e ao tamanho do conjunto de resultados do LIMIT. Se você tiver todos os seus "patos consecutivos" (tenha os quatro princípios em mente para sua consulta), poderá obter resultados surpreendentemente bons.
• Faça suas consultas o mais simplista possível ao LIMITcoletar apenas as chaves.

Quando uma consulta é executada, ela é traduzida primeiro em um plano composto por vários operadores. Existem dois tipos básicos de operadores: bloqueio e não bloqueio. Um Operador sem bloqueio recupera uma linha (ou algumas linhas) de seu filho ou filhos para cada linha solicitada a ele. Um Operador de Bloqueio, por outro lado, precisa ler e processar todo o conjunto de linhas de todos os seus filhos antes de poder produzir qualquer saída.

A classificação é um operador de bloqueio típico. Portanto, um select com order by não se beneficia muito de um limite. No entanto, existem RDBMSs que podem utilizar um algoritmo de classificação que precisa de menos memória e é mais rápido quando uma cláusula de limite é fornecida. Nesse caso, basta armazenar as primeiras n linhas atualmente e removê-las da memória à medida que as linhas anteriores aparecem. Isso pode ser um ganho significativo de desempenho. No entanto, não tenho 100% de certeza de que o MySQL tenha essa capacidade.

De qualquer forma, mesmo uma classificação de limite ainda precisa processar toda a linha de entrada definida antes de poder produzir a primeira linha de saída. Embora esse algoritmo, se implementado, possa acelerar a classificação, se o restante da consulta for a parte mais cara, o tempo total de execução não melhorará significativamente devido a um limite fornecido.

No meu caso, posso dizer sim , mesmo que eu (ainda) não entenda o porquê.

SELECT g0_.id AS id_0, COUNT(a1_.id_tarifs) AS sclr_1
FROM groupe_jardinerie g0_
INNER JOIN articles_tarifs a1_
  ON (a1_.groupe_jardinerie_id = g0_.id)
WHERE g0_.centrale_id = 511
  AND a1_.date_fin_tarif >= '2018-01-29 10:46:35'
GROUP BY g0_.id;

(result set)

8 rows in set (**18.14 sec**)

Observe o tempo: 18 segundos. Mesmo pedido com um grande LIMIT:

SELECT g0_.id AS id_0, COUNT(a1_.id_tarifs) AS sclr_1 
FROM groupe_jardinerie g0_
INNER JOIN articles_tarifs a1_
  ON (a1_.groupe_jardinerie_id = g0_.id)
WHERE g0_.centrale_id = 511 
  AND a1_.date_fin_tarif >= '2018-01-29 10:46:35'
GROUP BY g0_.id
LIMIT 100000000000;

(exact same result set)

8 rows in set (**1.32 sec**)

Mais de dez vezes mais rápido !!!

EXPLAIN fornece o mesmo resultado para os dois pedidos.

+----+-------------+-------+------------+--------+---------------------------------------------------+---------+---------+------------------------------+--------+----------+----------------------------------------------+
| id | select_type | table | partitions | type   | possible_keys                                     | key     | key_len | ref                          | rows   | filtered | Extra                                        |
+----+-------------+-------+------------+--------+---------------------------------------------------+---------+---------+------------------------------+--------+----------+----------------------------------------------+
|  1 | SIMPLE      | a1_   | NULL       | ALL    | IDX_438010BBC10784EF                              | NULL    | NULL    | NULL                         | 795135 |    33.33 | Using where; Using temporary; Using filesort |
|  1 | SIMPLE      | g0_   | NULL       | eq_ref | PRIMARY,IDX_9CA5CF6758A1D71F,IDX_9CA5CF67670C757F | PRIMARY | 4       | phs.a1_.groupe_jardinerie_id |      1 |    50.00 | Using where                                  |
+----+-------------+-------+------------+--------+---------------------------------------------------+---------+---------+------------------------------+--------+----------+----------------------------------------------+

LIMIT deve interferir apenas para limitar o conjunto de resultados (ou seja, se eu fizer um LIMIT 4, obtive apenas as 4 primeiras linhas do conjunto de resultados acima).