Como ordenar resultados das queries MySQL

Você pode ordenar suas consultas ao banco de dados MySQL, feitas com o comando SELECT, através de uma cláusula ORDER BY (que quer dizer ordene por, em uma tradução livre para português).
Neste texto, vou mostrar como ordenar queries MySQL pode ser fácil e flexibilizado.
MySQL logo Dolphin in gray shades
Os exemplos dados neste tutorial são genéricos e podem ser aplicados, com as devidas alterações, a qualquer tabela que você tiver disponível para seu aprendizado. Mas, se quiser, pode pegar a tabela que estou usando aqui.

Filtre seus resultados com WHERE, ordene com BY ORDER

Se você usar o quadro de busca, no topo do site, vai encontrar vários exemplos de uso da cláusula WHERE — que serve para filtrar os resultados obtidos pelo SELECT.
No exemplo abaixo, selecionamos para exibição os nomes de clientes e valor de seus créditos, onde o valor do crédito for maior que 82000, ordenado por valor do crédito ASCendentemente:

SELECT nomeCli, creditoCli FROM CadCli WHERE creditoCli > 82000 ORDER BY creditoCli ASC;
+----------------+------------+
| nomeCli        | creditoCli |
+----------------+------------+
| Daphne Blair   |      82413 |
| Lydia Patton   |      83368 |
| Kendall Morton |      83838 |
| Ocean Greene   |      84520 |
| Yvonne Wise    |      84531 |
| Steven Stokes  |      84831 |
+----------------+------------+
6 rows in set (0.01 sec

O comportamento padrão do MySQL é ordenar ascendentemente — ou seja, se você quiser, não precisa usar a cláusula ASC, nesta consulta.
Caso queira aplicar uma ordem descendente, por nomes, use o exemplo que segue:

SELECT nomeCli, creditoCli FROM CadCli WHERE creditoCli > 82000 ORDER BY nomeCli DESC;
+----------------+------------+
| nomeCli        | creditoCli |
+----------------+------------+
| Yvonne Wise    |      84531 |
| Steven Stokes  |      84831 |
| Ocean Greene   |      84520 |
| Lydia Patton   |      83368 |
| Kendall Morton |      83838 |
| Daphne Blair   |      82413 |
+----------------+------------+
6 rows in set (0.00 sec)

Você pode usar mais do que um parâmetro de ordenação. No exemplo que segue, vou ordenar o resultado por nome do cliente e por nome da cidade. Veja:

SELECT nomeCli, cidadeCli, creditoCli from CadCli WHERE creditoCli < 8000 ORDER BY nomeCli, cidadeCli;

O resultado sairá ordenado primeiro por nomeCli e, secundariamente, por cidadeCli. Como não foi especificado, a ordem da lista, por padrão é ascendente:

+-----------------+----------------------+------------+
| nomeCli         | cidadeCli            | creditoCli |
+-----------------+----------------------+------------+
| Deacon Reid     | Cuglieri             |       7937 |
| Fuller Richards | Airdrie              |       7252 |
| Hanna Mccormick | Lens-Saint-Remy      |        600 |
| Lois Dyer       | Torrevecchia Teatina |       6057 |
| Sheila Foreman  | Sloten               |       4266 |
| Warren Burgess  | Konstanz             |       1656 |
+-----------------+----------------------+------------+
6 rows in set (0.00 sec)

Encontre outros exemplos interessantes, usando a caixa de busca no topo do site ou clicando na tag correspondente, logo abaixo.

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 filtrar resultados com a cláusula WHERE no MySQL

A cláusula WHERE serve para informar ao servidor de banco de dados MySQL exatamente quais resultados lhe interessa obter.
A consulta feita, através do SELECT, pode acabar trazendo uma quantidade de dados muito extensa.
Capa do artigo A Cláusula WHERE no MySQL
Adicionar uma cláusula WHERE a uma consulta MySQL, permite especificar que condições precisam ser satisfeitas para que um resultado seja exibido na tela.
Se você quiser ver outros exemplos de funcionamento da cláusula WHERE, use a caixa de busca, no topo deste site, para encontrar outros artigos sobre o assunto.

Como funciona a cláusula WHERE para limitar a exibição dos primeiros registros da tabela no MySQL

Neste tutorial, vou usar como exemplo uma tabela com 100 registros.
Esta quantidade de registros pode se tornar muito maçante para ser usada em um mero tutorial e acaba por tirar a atenção do que realmente interessa.
Portanto, para ver apenas os primeiros 10 registros, uso a cláusula WHERE desta forma:

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)

Veja como exibir apenas os clientes, cuja coluna IdadeCliente = 42:

SELECT * FROM ClientesCidades WHERE IdadeCliente = 42;
+----+------------------+--------------+----------------+-------------+
| id | NomeCliente      | IdadeCliente | CidadeCliente  | CredCliente |
+----+------------------+--------------+----------------+-------------+
| 18 | Zelenia Brady    |           42 | Modena         |          35 |
| 27 | Sandra Gay       |           42 | Oklahoma City  |          93 |
| 53 | Chastity Charles |           42 | Calgary        |          76 |
| 92 | Martena Flowers  |           42 | Fontenoille    |          97 |
| 93 | Piper Fuentes    |           42 | Qualicum Beach |          76 |
| 94 | Althea Knight    |           42 | My             |          18 |
+----+------------------+--------------+----------------+-------------+
6 rows in set (0.00 sec)

E se eu quiser ver os registros em que IdadeCliente seja igual a 20, 21 e 22?
Veja como obter este resultado, em ordem ascendente de CredCliente:

SELECT * FROM ClientesCidades WHERE IdadeCliente = 20 OR IdadeCliente = 21 OR IdadeCliente = 22 ORDER BY CredCliente;
+----+----------------+--------------+---------------+-------------+
| id | NomeCliente    | IdadeCliente | CidadeCliente | CredCliente |
+----+----------------+--------------+---------------+-------------+
| 14 | Alea Beach     |           21 | Oromocto      |          15 |
| 64 | Illana Cannon  |           21 | Diksmuide     |          15 |
| 50 | Kelsie Whitney |           20 | Barranca      |          16 |
| 71 | Kylie Bradshaw |           20 | Fontanigorda  |          16 |
| 42 | Lynn Howe      |           21 | Basirhat      |          66 |
| 72 | Zenia Carr     |           22 | Wernigerode   |          78 |
| 76 | Leigh Barnett  |           22 | Stokrooie     |          87 |
| 31 | Cynthia Levy   |           21 | Pukekohe      |          99 |
+----+----------------+--------------+---------------+-------------+
8 rows in set (0.00 sec)

Como usar o operador IN() do MySQL

A query anterior pode ser simplificada com a adição do operador IN().
O operador IN() retorna verdadeiro (true) a cada vez que encontra uma coluna com valor correspondente ao seu.
Não entendeu? Vamos deixar o exemplo abaixo falar por si:

SELECT * FROM ClientesCidades WHERE IdadeCliente IN (20,21,22) ORDER BY CredCliente;

Note que a linha de comando é significativamente menor e o resultado, abaixo, é o mesmo obtido anteriormente:

+----+----------------+--------------+---------------+-------------+
| id | NomeCliente    | IdadeCliente | CidadeCliente | CredCliente |
+----+----------------+--------------+---------------+-------------+
| 14 | Alea Beach     |           21 | Oromocto      |          15 |
| 64 | Illana Cannon  |           21 | Diksmuide     |          15 |
| 50 | Kelsie Whitney |           20 | Barranca      |          16 |
| 71 | Kylie Bradshaw |           20 | Fontanigorda  |          16 |
| 42 | Lynn Howe      |           21 | Basirhat      |          66 |
| 72 | Zenia Carr     |           22 | Wernigerode   |          78 |
| 76 | Leigh Barnett  |           22 | Stokrooie     |          87 |
| 31 | Cynthia Levy   |           21 | Pukekohe      |          99 |
+----+----------------+--------------+---------------+-------------+
8 rows in set (0.00 sec)

Como usar o operador AND do MySQL

Se você quiser que duas condições sejam satisfeitas simultaneamente, use o operador AND:

SELECT * FROM ClientesCidades WHERE IdadeCliente < 30 AND CredCliente > 90;

No exemplo, acima, foi pedido uma lista dos clientes com idade inferior a 30 anos e com créditos superiores a 90. Veja o resultado:

+----+-----------------+--------------+---------------+-------------+
| id | NomeCliente     | IdadeCliente | CidadeCliente | CredCliente |
+----+-----------------+--------------+---------------+-------------+
| 31 | Cynthia Levy    |           21 | Pukekohe      |          99 |
| 37 | Tasha Walters   |           19 | Goutroux      |          98 |
| 62 | Zelenia Moss    |           18 | Elx           |          99 |
| 63 | Camilla Freeman |           19 | Falkensee     |          91 |
| 97 | Bo Simpson      |           24 | Omaha         |          91 |
+----+-----------------+--------------+---------------+-------------+
5 rows in set (0.00 sec)

No próximo exemplo vou usar uma query para testar se há algum cliente cuja idade seja igual ao seu crédito. Veja:

SELECT * FROM ClientesCidades WHERE IdadeCliente = CredCliente;

Por sorte, havia um:

+----+--------------+--------------+---------------+-------------+
| id | NomeCliente  | IdadeCliente | CidadeCliente | CredCliente |
+----+--------------+--------------+---------------+-------------+
| 46 | Signe Gamble |           39 | Charny        |          39 |
+----+--------------+--------------+---------------+-------------+
1 row in set (0.00 sec)

Divirta-se!