Como usar expressões com variáveis para calcular os valores da cláusula LIMIT no MySQL

A possibilidade de paginar ou seccionar os resultados de suas queries ou consultas MySQL, tornam a cláusula LIMIT uma das mais requisitadas por desenvolvedores.
logo PHP mesclado ao logo MySQL
Enquanto outras cláusulas são usadas para filtrar a exibição de resultados, LIMIT é usado para inibir o envio de resultados do servidor — motivo pelo qual ele ajuda a poupar o fluxo de informações inúteis a trafegar pela rede.
Se você quiser entender melhor o uso da cláusula LIMIT e das variáveis no MySQL, sugiro usar o quadro de pesquisa, no topo desta página, para encontrar outros posts sobre estes assuntos — vale a pena!

Como criar expressões usando a cláusula LIMIT do MySQL

O MySQL só vai aceitar inteiros literais em expressões — a menos que você envie suas consultas de dentro de um script. Neste caso, você tem mais flexibilidade para elaborar suas expressões e inserir os valores resultantes nas strings das consultas.
Se vocẽ tentar incluir uma expressão matemática, direto na linha de comando do seu cliente MySQL, vai obter um erro:

SELECT * FROM ClientesCidades LIMIT 2+2;

Isto, simplesmente, não é permitido — e vai provavelmente retornar um erro como o reproduzido abaixo:

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '+2' at line 1

O uso de variáveis, também não é permitido, deste jeito:

SELECT * FROM profile LIMIT @pula_contagem, @exibir_contagem;

A expressão precisa ser criada, primeiro. Depois, seu resultado, pode ser inserido em uma query.
Mesmo de dentro do PHP, isto não é aceito:

$str = "SELECT * FROM ClientesCidades LIMIT $a + $b";

Para evitar o problema, tente elaborar a expressão primeiro:

$c = $a + $b;
$str = "SELECT * FROM ClientesCidades LIMIT $c";

Uma outra abordagem possível (também de dentro do PHP), seria esta:

$str = "SELECT * FROM ClientesCidades LIMIT ".($a + $b);

Fique atento para as aspas e para os parênteses.

Como seccionar uma lista, usando a cláusula LIMIT do MySQL

A cláusula LIMIT pode ser usada para obter informações contidas no meio de uma lista, e não apenas nas extremidades (início ou fim) da consulta.
Capa do tutorial MySQL - a cláusula LIMIT
O uso básico da cláusula LIMIT, já foi discutido no artigo Como usar LIMIT para selecionar registros do começo ou do fim de uma tabela no MySQL — sugiro-o como leitura complementar.
Neste texto, vou mostrar como obter determinadas linhas, no “miolo” de uma relação e como é possível fazer paginação, com LIMIT — ou seja, dividir uma relação em múltiplas páginas.
Para que o LIMIT possa realizar a tarefa é necessário que você diga em que posição, na lista, ele deve começar, além da quantidade de linhas que você deseja que sejam exibidas.
A cláusula LIMIT aceita 2 argumentos:

  • O primeiro determina quantas linhas devem ser “puladas” ou ignoradas.
  • O segundo determina quantas linhas da lista devem ser exibidas.

Isto significa que você pode usar a cláusula LIMIT para pular 2 linhas e mostram a próxima, por exemplo. Isto permite responder perguntas um pouco mais complexas, como “Qual o quinto maior valor num determinado campo?” ou “Qual o terceiro menor valor?” — que seria mais difíceis de responder com as funções MIN() ou MAX().
Vamos aos exemplos.

Como paginar resultados com a cláusula LIMIT, no MySQL

Distribuir em várias páginas os resultados de uma query MySQL com o LIMIT é muito fácil — ele é feito pra isso.
Veja um exemplo básico de paginação de 2 em 2 (para não ficar muito extenso):

SELECT idCli,nomeCli,emailCli FROM CadCli LIMIT 2;

Na primeira parte, peço a lista limitada aos 2 primeiros registros:

+-------+-----------------+--------------------------------+
| idCli | nomeCli         | emailCli                       |
+-------+-----------------+--------------------------------+
|     1 | Tana Mclaughlin | eget.tincidunt@magnisdis.net   |
|     2 | Jakeem Klein    | mauris.eu@Nuncmaurissapien.com |
+-------+-----------------+--------------------------------+
2 rows in set (0.00 sec)

A lista segue, pulando 2 resultados, limitada a 2 linhas:

SELECT idCli,nomeCli,emailCli FROM CadCli LIMIT 2,2;
+-------+-----------------+-------------------------------+
| idCli | nomeCli         | emailCli                      |
+-------+-----------------+-------------------------------+
|     3 | Wylie Carroll   | convallis.in.cursus@libero.ca |
|     4 | Colton Franklin | dui.lectus.rutrum@eusem.org   |
+-------+-----------------+-------------------------------+
2 rows in set (0.00 sec)

Concluo o exemplo, exibindo a próxima página, depois do quarto registro, limitado a 2 linhas:

 SELECT idCli,nomeCli,emailCli FROM CadCli LIMIT 4,2;
+-------+-----------------+------------------------------------------+
| idCli | nomeCli         | emailCli                                 |
+-------+-----------------+------------------------------------------+
|     5 | Amity Whitfield | risus.Quisque.libero@Praesenteudui.co.uk |
|     6 | Sade Carver     | Donec@Innec.com                          |
+-------+-----------------+------------------------------------------+
2 rows in set (0.00 sec)

Dentro de um script, podemos usar um loop para fazer este trabalho.


Nota: Você pode usar qualquer tabela disponível para você para praticar. Se você fizer questão de usar a mesma tabela deste artigo, é possível obtê-la aqui.

Como obter o maior ou menor valor de um campo, usando o LIMIT

Para realizar este trabalho, vou acrescentar a cláusula DESC em uma das queries.
Veja como obter o maior valor em uma coluna da tabela:

SELECT nomeCli, creditoCli FROM CadCli ORDER BY creditoCli DESC LIMIT 1;
+---------------+------------+
| nomeCli       | creditoCli |
+---------------+------------+
| Steven Stokes |      84831 |
+---------------+------------+
1 row in set (0.00 sec)

Se a pergunta fosse “Qual o email do cliente com o menor valor de crédito?”, a resposta poderia ser obtida assim:

SELECT nomeCli AS Cliente, emailCli AS "Email p/contato", creditoCli FROM CadCli ORDER BY creditoCli LIMIT 1;
+-----------------+----------------------------------+------------+
| Cliente         | Email p/contato                  | creditoCli |
+-----------------+----------------------------------+------------+
| Hanna Mccormick | molestie.tortor.nibh@indolor.org |        600 |
+-----------------+----------------------------------+------------+
1 row in set (0.00 sec)

E, se a pergunta for “Qual o nome do cliente com o segundo maior crédito?”

SELECT nomeCli AS Cliente, emailCli AS "Email p/contato", creditoCli FROM CadCli ORDER BY creditoCli DESC LIMIT 1,1;
+-------------+-----------------------+------------+
| Cliente     | Email p/contato       | creditoCli |
+-------------+-----------------------+------------+
| Yvonne Wise | habitant@odioEtiam.ca |      84531 |
+-------------+-----------------------+------------+
1 row in set (0.00 sec)

Espero que este post resolva as suas dúvidas sobre como seccionar relatórios no MySQL, como a cláusula LIMIT. Você pode usar a caixa de buscas, no topo do site, para encontrar tutoriais e receitas MySQL.

Como usar LIMIT para selecionar registros do começo ou do fim de uma tabela no MySQL

A cláusula LIMIT, usada em conjunto com a cláusula ORDER BY, permite limitar a exibição dos registros de uma tabela a um determinado número.
O recurso é muito útil para mim, que estou sempre mostrando exemplos de uso de vários outros recursos do MySQL — mas não posso encher esta página com informações inúteis para os leitores.
Capa do tutorial MySQL LIMIT
O leitor quer ver apenas como um determinado recurso funciona… não a tabela toda!
Além disto, o recurso é útil quando se deseja mostrar apenas as últimas alterações ocorridas em uma tabela de um banco de dados, como seria o caso de um sistema de logging.
Uma outra situação em que este recurso é usado: quando o desenvolvedor deseja paginar os resultados — ou seja, distribuir uma relação por várias páginas. Uma de cada vez. Um exemplo disto, são as páginas do resultado de busca do Google.

Como funciona a cláusula LIMIT no MySQL

O MySQL suporta o uso desta cláusula, que serve para informar ao servidor que ele só deve retornar uma parte do resultado pedido em uma consulta.
Os exemplos, que seguem, fazem uso da tabela CadCli, que pode ser encontrada aqui — mas você pode usar qualquer outra. Basta adequar os comandos à sua situação.
Para limitar a exibição dos resultados de uma query a 1 registro, use a cláusula LIMIT 1:

SELECT * FROM CadCli LIMIT 1;
+-------+-----------------+------------------------------+-----------+------------+----------+----------+
| idCli | nomeCli         | emailCli                     | cidadeCli | creditoCli | dtCadCli | dtNscCli |
+-------+-----------------+------------------------------+-----------+------------+----------+----------+
|     1 | Tana Mclaughlin | eget.tincidunt@magnisdis.net | Stekene   |      27768 | 07-06-14 | 11-02-09 |
+-------+-----------------+------------------------------+-----------+------------+----------+----------+
1 row in set (0.00 sec)

Aumente o valor de LIMIT, para obter mais resultados:

SELECT * FROM CadCli LIMIT 5;
+-------+-----------------+------------------------------------------+---------------+------------+----------+----------+
| idCli | nomeCli         | emailCli                                 | cidadeCli     | creditoCli | dtCadCli | dtNscCli |
+-------+-----------------+------------------------------------------+---------------+------------+----------+----------+
|     1 | Tana Mclaughlin | eget.tincidunt@magnisdis.net             | Stekene       |      27768 | 07-06-14 | 11-02-09 |
|     2 | Jakeem Klein    | mauris.eu@Nuncmaurissapien.com           | Lagos         |      17465 | 02-07-14 | 29-04-71 |
|     3 | Wylie Carroll   | convallis.in.cursus@libero.ca            | Lelystad      |      81512 | 19-09-14 | 13-08-98 |
|     4 | Colton Franklin | dui.lectus.rutrum@eusem.org              | Sesto Campano |      68180 | 13-04-15 | 27-07-77 |
|     5 | Amity Whitfield | risus.Quisque.libero@Praesenteudui.co.uk | Fauvillers    |      21975 | 10-07-14 | 01-02-82 |
+-------+-----------------+------------------------------------------+---------------+------------+----------+----------+
5 rows in set (0.00 sec)

Melhore o resultado filtrando
O valor de LIMIT não pode ser negativo.
Se você quiser, de alguma forma, inverter a ordem de exibição dos registros, use as cláusulas WHERE e ORDER BY para filtrar os seus registros:

SELECT idCli AS "Ordem",nomeCli AS "Cliente", creditoCli AS "Credito Disponível" FROM CadCli ORDER BY CreditoCli DESC LIMIT 5;

O comando, acima, pede a relação dos clientes ordenada pelo crédito disponível (creditoCli), em ordem descendente e limitado a 5 registros. O meu resultado foi o seguinte:

+-------+----------------+---------------------+
| Ordem | Cliente        | Credito Disponível  |
+-------+----------------+---------------------+
|    78 | Steven Stokes  |               84831 |
|    54 | Yvonne Wise    |               84531 |
|     8 | Ocean Greene   |               84520 |
|   100 | Kendall Morton |               83838 |
|    19 | Lydia Patton   |               83368 |
+-------+----------------+---------------------+
5 rows in set (0.00 sec)

Você deve usar sempre as cláusulas WHERE e ORDER BY, combinadas ao LIMIT, para obter resultados mais significativos para as suas necessidades.
É possível obter os mesmos resultados, acima, sem usar a cláusula LIMIT.
A vantagem de fazer uso do LIMIT é que o servidor vai retornar a informação pedida — o que estiver fora dos limites definidos em LIMIT não será enviado. Desta forma, o uso da rede e da sua largura de banda é muito mais eficiente com o uso do LIMIT.
Em um universo de um milhão de registros, se eu quisesse ver apenas quem tem o maior valor em créditos disponíveis, nesta tabela, eu posso usar o LIMIT, sem sobrecarregar a rede com tráfego desnecessário de dados:

SELECT * FROM CadCli ORDER BY CreditoCli DESC LIMIT 1;
+-------+---------------+-----------------------------+------------+------------+----------+----------+
| idCli | nomeCli       | emailCli                    | cidadeCli  | creditoCli | dtCadCli | dtNscCli |
+-------+---------------+-----------------------------+------------+------------+----------+----------+
|    78 | Steven Stokes | est.Nunc.laoreet@cursus.edu | Llandovery |      84831 | 17-12-14 | 18-07-75 |
+-------+---------------+-----------------------------+------------+------------+----------+----------+
1 row in set (0.00 sec)

Use o quadro de pesquisa, no canto superior da página para encontrar mais artigos, neste site, sobre o uso do LIMIT e/ou outras cláusulas MySQL.