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.

Como usar as cláusulas WHERE e AS no MySQL

O MySQL não permite que você se refira a um alias ou apelido de uma coluna (nome de um campo) de uma tabela, com a cláusula WHERE.
Vamos ver como contornar esta limitação e criar outras possibilidades e encontrar novas soluções.

Exemplo de erro 1054 no MySQL
Exemplo de erro 1054 no MySQL.

Atualmente, a query MySQL, que segue abaixo, é ilegal e vai retornar um erro:

SELECT NomeCliente, IdadeCliente, CredCliente*1000 AS Credito FROM ClientesCidades WHERE Credito < 20000;

O resultado é um erro 1054:

ERROR 1054 (42S22): Unknown column 'Credito' in 'where clause'

A cláusula WHERE não consegue enxergar a “nova” coluna Credito.

O erro 1054 (42S22) ocorre por que, enquanto o alias (AS) faz output (saída) de colunas, a cláusula WHERE opera na entrada dos dados — determinando quais linhas devem ser selecionadas para o output.

O resultado pretendido é este aqui:

SELECT NomeCliente, IdadeCliente, CredCliente*1000 AS Credito FROM ClientesCidades WHERE CredCliente < 20;
+-----------------+--------------+---------+
| NomeCliente     | IdadeCliente | Credito |
+-----------------+--------------+---------+
| Jaden Moon      |           29 |   17000 |
| Cathleen Harvey |           39 |   12000 |
| Marcia Cole     |           49 |   13000 |
| Charity Leblanc |           31 |   10000 |
| Alea Beach      |           21 |   15000 |
| April Hubbard   |           28 |   13000 |
| Fay Shaffer     |           50 |   19000 |
| Minerva Hanson  |           39 |   19000 |
| Kelsie Whitney  |           20 |   16000 |
| Illana Cannon   |           21 |   15000 |
| Kylie Bradshaw  |           20 |   16000 |
| Carly Alston    |           34 |   15000 |
| Althea Knight   |           42 |   18000 |
+-----------------+--------------+---------+
13 rows in set (0.02 sec)

Uma outra forma de obter este resultado é assim:

SELECT NomeCliente, IdadeCliente, CredCliente*1000 AS Credito FROM ClientesCidades WHERE CredCliente*1000 < 20000;
+-----------------+--------------+---------+
| NomeCliente     | IdadeCliente | Credito |
+-----------------+--------------+---------+
| Jaden Moon      |           29 |   17000 |
| Cathleen Harvey |           39 |   12000 |
| Marcia Cole     |           49 |   13000 |
| Charity Leblanc |           31 |   10000 |
| Alea Beach      |           21 |   15000 |
| April Hubbard   |           28 |   13000 |
| Fay Shaffer     |           50 |   19000 |
| Minerva Hanson  |           39 |   19000 |
| Kelsie Whitney  |           20 |   16000 |
| Illana Cannon   |           21 |   15000 |
| Kylie Bradshaw  |           20 |   16000 |
| Carly Alston    |           34 |   15000 |
| Althea Knight   |           42 |   18000 |
+-----------------+--------------+---------+
13 rows in set (0.00 sec)

Como combinar nomes de colunas com a função CONCAT() do MySQL

No MySQL, a função CONCAT tem a função de concatenar strings, ou seja, juntar cadeias de caracteres com o objetivo de formar novos nomes para as suas colunas e enriquecer a apresentação dos dados da sua tabela.
Capa do tutorial da função concat no MySQL
No artigo Como nomear as colunas das tabelas no MySQL, mostrei como melhorar a apresentação das colunas ao exibir as informações da sua tabela — recomendo dar uma olhada.
Neste texto, vou mostrar como usar a função CONCAT() para juntar valores alfanuméricos e formar novos nomes de campos em uma tabela.

Como usar a função CONCAT, do MySQL, para juntar cadeias de caracteres

Em conjunto com o alias (ou AS) é possível criar nomes mais interessantes e significativos para as colunas exibidas de uma tabela.
Veja a sintaxe da função CONCAT():
CONCAT(string1,string2,string3...);
Pode ficar mais fácil de entender, dentro de um exemplo prático.
Veja como concatenar as strings “just”, “in” e “case”:
CONCAT("just","in","case");
O resultado da operação acima é justincase. Foi fácil?
Tome, como exemplo, a seguinte tabela:

SELECT * FROM ClientesCidades WHERE Id<10;
+----+-----------------+--------------+------------------+-------------+
| id | NomeCliente     | IdadeCliente | CidadeCliente    | CredCliente |
+----+-----------------+--------------+------------------+-------------+
|  1 | Dara Chase      |           40 | Buti             |          21 |
|  2 | Hanae Kane      |           26 | Whitehorse       |          28 |
|  3 | Jaden Moon      |           29 | Bertiolo         |          17 |
|  4 | Cathleen Harvey |           39 | Exeter           |          12 |
|  5 | Marcia Cole     |           49 | Fortune          |          13 |
|  6 | Winter Fischer  |           47 | Girifalco        |          53 |
|  7 | Irene Mann      |           48 | Rocca San Felice |          78 |
|  8 | Yetta Wood      |           46 | Doues            |          89 |
|  9 | Alfreda Church  |           38 | Tarnów           |          96 |
+----+-----------------+--------------+------------------+-------------+
9 rows in set (0.00 sec)

Vamos usar o CONCAT() e o AS para exibir a idade de cada cliente entre colchetes e ao lado de cada nome:

SELECT Id AS Ordem, CONCAT(NomeCliente,'[',IdadeCliente,']') AS 'Cliente[Idade]' FROM ClientesCidades WHERE Id<10;
+-------+---------------------+
| Ordem | Cliente[Idade]       |
+-------+---------------------+
|     1 | Dara Chase[40]      |
|     2 | Hanae Kane[26]      |
|     3 | Jaden Moon[29]      |
|     4 | Cathleen Harvey[39] |
|     5 | Marcia Cole[49]     |
|     6 | Winter Fischer[47]  |
|     7 | Irene Mann[48]      |
|     8 | Yetta Wood[46]      |
|     9 | Alfreda Church[38]  |
+-------+---------------------+
9 rows in set (0.00 sec)

Vamos elaborar melhor este exemplo, incluindo informações sobre sua cidade e o valor de seu crédito:

SELECT CONCAT(NomeCliente,', tem ',IdadeCliente,' anos de idade. Mora em ',CidadeCliente,' e possui R$ ',CredCliente,' em créditos.') AS 'Maiores correntistas' FROM ClientesCidades WHERE CredCliente > 97;
+------------------------------------------------------------------------------------+
| Maiores correntistas                                                               |
+------------------------------------------------------------------------------------+
| Cynthia Levy, tem 21 anos de idade. Mora em Pukekohe e possui R$ 99 em créditos.   |
| Tasha Walters, tem 19 anos de idade. Mora em Goutroux e possui R$ 98 em créditos.  |
| Zelenia Moss, tem 18 anos de idade. Mora em Elx e possui R$ 99 em créditos.        |
+------------------------------------------------------------------------------------+
3 rows in set (0.00 sec)

Experimente outras combinações, para obter resultados diferentes e fixar melhor o aprendizado.
Se quiser aprofundar o aprendizado, use caixa de busca, no topo deste site, para encontrar outros exemplos MySQL.
Divirta-se!