Resumo : neste tutorial, você aprenderá como classificar as linhas em um conjunto de resultados usando a ORDER BY
cláusula MySQL.
Introdução à cláusula ORDER BY do MySQL
Quando você usa a SELECT
instrução para consultar dados de uma tabela, a ordem das linhas no conjunto de resultados não é especificada.
Para classificar as linhas no conjunto de resultados, adicione a ORDER BY
cláusula à SELECT
instrução.
O seguinte ilustra a sintaxe da ORDER BY
cláusula:
SELECT
select_list
FROM
table_name
ORDER BY
column1 [ASC|DESC],
column2 [ASC|DESC],
...;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Nesta sintaxe, você especifica uma ou mais colunas que deseja classificar após a ORDER BY
cláusula.
O ASC
significa ascendente e o DESC
significa descendente. Você usa ASC
para classificar o conjunto de resultados em ordem crescente e DESC
para classificar o conjunto de resultados em ordem decrescente.
Esta ORDER BY
cláusula classifica o resultado definido pelos valores em column1
ordem crescente:
ORDER BY column1 ASC;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
E esta ORDER BY
cláusula classifica o resultado definido pelos valores em column1
ordem decrescente:
ORDER BY column1 DESC;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Por padrão, a ORDER BY
cláusula é usada ASC
se você não especificar explicitamente nenhuma opção. Portanto, as seguintes ORDER BY
cláusulas são equivalentes:
ORDER BY column1 ASC;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
e
ORDER BY column1;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Se quiser classificar o conjunto de resultados por múltiplas colunas, especifique uma lista de colunas separadas por vírgula na ORDER BY
cláusula:
ORDER BY
column1,
column2;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Nesse caso, a ORDER BY
cláusula classifica column1
primeiro o conjunto de resultados em ordem crescente e classifica o conjunto de resultados classificado em column2
ordem crescente.
É possível ordenar o conjunto de resultados por uma coluna em ordem crescente e depois por outra coluna em ordem decrescente:
ORDER BY
column1 ASC,
column2 DESC;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Neste caso, a ORDER BY
cláusula:
- Primeiro, classifique o resultado definido pelos valores em
column1
ordem crescente. - Em seguida, classifique o resultado classificado definido pelos valores em
column2
ordem decrescente. Observe que a ordem dos valores nocolumn1
não será alterada nesta etapa, apenas a ordem dos valores nascolumn2
alterações.
Ao executar a SELECT
instrução com uma ORDER BY
cláusula, o MySQL sempre avalia a ORDER BY
cláusula após as cláusulas FROM
e :SELECT
Exemplos de ORDER BY do MySQL
Usaremos a customers
tabela do banco de dados de exemplo para a demonstração:
1) Usando a cláusula ORDER BY para classificar o conjunto de resultados por exemplo de uma coluna
A consulta a seguir usa a ORDER BY
cláusula para classificar os clientes pelos sobrenomes em ordem crescente.
SELECT
contactLastname,
contactFirstname
FROM
customers
ORDER BY
contactLastname;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Saída:
+-----------------+------------------+
| contactLastname | contactFirstname |
+-----------------+------------------+
| Accorti | Paolo |
| Altagar,G M | Raanan |
| Andersen | Mel |
| Anton | Carmen |
| Ashworth | Rachel |
| Barajas | Miguel |
...
Linguagem de código: texto simples ( texto simples )
Se quiser classificar os clientes pelo sobrenome em ordem decrescente, use o DESC
após a contactLastname
coluna na ORDER BY
cláusula, conforme mostrado na consulta a seguir:
SELECT
contactLastname,
contactFirstname
FROM
customers
ORDER BY
contactLastname DESC;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Saída:
+-----------------+------------------+
| contactLastname | contactFirstname |
+-----------------+------------------+
| Young | Jeff |
| Young | Julie |
| Young | Mary |
| Young | Dorothy |
| Yoshido | Juri |
| Walker | Brydey |
| Victorino | Wendy |
| Urs | Braun |
| Tseng | Jerry |
....
Linguagem de código: texto simples ( texto simples )
2) Usando a cláusula ORDER BY para classificar o conjunto de resultados por exemplo de múltiplas colunas
Se você quiser classificar os clientes pelo sobrenome em ordem decrescente e depois pelo nome em ordem crescente, especifique ambos DESC
e ASC
nessas respectivas colunas da seguinte maneira:
SELECT
contactLastname,
contactFirstname
FROM
customers
ORDER BY
contactLastname DESC,
contactFirstname ASC;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Saída:
+-----------------+------------------+
| contactLastname | contactFirstname |
+-----------------+------------------+
| Young | Dorothy |
| Young | Jeff |
| Young | Julie |
| Young | Mary |
| Yoshido | Juri |
| Walker | Brydey |
| Victorino | Wendy |
| Urs | Braun |
| Tseng | Jerry |
| Tonini | Daniel |
...
Linguagem de código: texto simples ( texto simples )
Neste exemplo, a ORDER BY
cláusula classifica primeiro o conjunto de resultados pelo sobrenome em ordem decrescente e, em seguida, classifica o conjunto de resultados classificado pelo primeiro nome em ordem crescente para formar o conjunto de resultados final.
3) Usando a cláusula ORDER BY para classificar um conjunto de resultados por um exemplo de expressão
Consulte a orderdetails
tabela a seguir do banco de dados de exemplo :
A consulta a seguir seleciona os itens de linha do pedido na orderdetails
tabela. Ele calcula o subtotal de cada item de linha e classifica o conjunto de resultados com base no subtotal.
SELECT
orderNumber,
orderlinenumber,
quantityOrdered * priceEach
FROM
orderdetails
ORDER BY
quantityOrdered * priceEach DESC;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
+-------------+-----------------+-----------------------------+
| orderNumber | orderlinenumber | quantityOrdered * priceEach |
+-------------+-----------------+-----------------------------+
| 10403 | 9 | 11503.14 |
| 10405 | 5 | 11170.52 |
| 10407 | 2 | 10723.60 |
| 10404 | 3 | 10460.16 |
| 10312 | 3 | 10286.40 |
...
Linguagem de código: texto simples ( texto simples )
Para tornar a consulta mais legível, você pode atribuir um alias de coluna à expressão na SELECT
cláusula e usar o alias de coluna na ORDER BY
cláusula, conforme mostrado na consulta a seguir:
SELECT
orderNumber,
orderLineNumber,
quantityOrdered * priceEach AS subtotal
FROM
orderdetails
ORDER BY
subtotal DESC;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
+-------------+-----------------+----------+
| orderNumber | orderLineNumber | subtotal |
+-------------+-----------------+----------+
| 10403 | 9 | 11503.14 |
| 10405 | 5 | 11170.52 |
| 10407 | 2 | 10723.60 |
| 10404 | 3 | 10460.16 |
| 10312 | 3 | 10286.40 |
| 10424 | 6 | 10072.00 |
| 10348 | 8 | 9974.40 |
| 10405 | 3 | 9712.04 |
| 10196 | 5 | 9571.08 |
| 10206 | 6 | 9568.73 |
...
Linguagem de código: texto simples ( texto simples )
Neste exemplo, usamos subtotal
como alias de coluna para a expressão quantityOrdered * priceEach
e classificamos o resultado definido pelo subtotal
alias.
Como o MySQL avalia a SELECT
cláusula antes da ORDER BY
cláusula, você pode usar o alias da coluna especificado na SELECT
cláusula ORDER BY
.
Usando a cláusula MySQL ORDER BY para classificar dados usando uma lista personalizada
A FIELD()
função retorna o índice (posição) de um valor dentro de uma lista de valores.
Aqui está a sintaxe da FIELD()
função:
FIELD(value, value1, value2, ...)
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Nesta sintaxe:
value
: O valor para o qual você deseja encontrar a posição.value1, value2, ...
: uma lista de valores com os quais você deseja comparar o valor especificado.
A FIELD()
função retorna a posição de na value
lista de valores valor1, valor2 e assim por diante.
Se o value
não for encontrado na lista, a FIELD()
função retornará 0.
Por exemplo, a consulta a seguir retorna 1 porque a posição da string 'A'
é a primeira posição na lista 'A'
, 'B'
e 'C'
:
SELECT FIELD('A', 'A', 'B','C');
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Saída:
+--------------------------+
| FIELD('A', 'A', 'B','C') |
+--------------------------+
| 1 |
+--------------------------+
1 row in set (0.00 sec)
Linguagem de código: texto simples ( texto simples )
E o exemplo a seguir retorna 2 porque 'B'
possui a segunda posição na lista:
SELECT FIELD('B', 'A','B','C');
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Saída:
+-------------------------+
| FIELD('B', 'A','B','C') |
+-------------------------+
| 2 |
+-------------------------+
1 row in set (0.00 sec)
Linguagem de código: texto simples ( texto simples )
Vejamos um exemplo mais prático.
Consulte a orders
tabela a seguir do banco de dados de amostra:
Suponha que você queira classificar os pedidos de vendas com base em seus status na seguinte ordem:
- Em processo
- Em espera
- Cancelado
- Resolvido
- Disputado
- Enviado
Para fazer isso, você pode usar a FIELD()
função para mapear cada status de pedido para um número e classificar o resultado pelo resultado da FIELD()
função:
SELECT
orderNumber,
status
FROM
orders
ORDER BY
FIELD(
status,
'In Process',
'On Hold',
'Cancelled',
'Resolved',
'Disputed',
'Shipped'
);
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
+-------------+------------+
| orderNumber | status |
+-------------+------------+
| 10425 | In Process |
| 10421 | In Process |
| 10422 | In Process |
| 10420 | In Process |
| 10424 | In Process |
| 10423 | In Process |
| 10414 | On Hold |
| 10401 | On Hold |
| 10334 | On Hold |
| 10407 | On Hold |
...
Linguagem de código: texto simples ( texto simples )
MySQL ORDER BY e NULL
No MySQL, NULL
vem antes de valores não NULL. Portanto, quando você coloca a ORDER BY
cláusula com a ASC
opção, NULLs
aparece primeiro no conjunto de resultados.
Por exemplo, a consulta a seguir usa a ORDER BY
cláusula para classificar funcionários por valores na reportsTo
coluna:
SELECT
firstName,
lastName,
reportsTo
FROM
employees
ORDER BY
reportsTo;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Saída:
+-----------+-----------+-----------+
| firstName | lastName | reportsTo |
+-----------+-----------+-----------+
| Diane | Murphy | NULL |
| Mary | Patterson | 1002 |
| Jeff | Firrelli | 1002 |
| William | Patterson | 1056 |
| Gerard | Bondur | 1056 |
...
Linguagem de código: texto simples ( texto simples )
No entanto, se você usar a opção ORDER BY
com DESC
, NULLs
aparecerá por último no conjunto de resultados. Por exemplo:
SELECT
firstName,
lastName,
reportsTo
FROM
employees
ORDER BY
reportsTo DESC;
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Saída:
+-----------+-----------+-----------+
| firstName | lastName | reportsTo |
+-----------+-----------+-----------+
| Yoshimi | Kato | 1621 |
| Leslie | Jennings | 1143 |
| Leslie | Thompson | 1143 |
| Julie | Firrelli | 1143 |
| ....
| Mami | Nishi | 1056 |
| Mary | Patterson | 1002 |
| Jeff | Firrelli | 1002 |
| Diane | Murphy | NULL |
+-----------+-----------+-----------+
23 rows in set (0.00 sec)
Linguagem de código: texto simples ( texto simples )
Resumo
- Use a
ORDER BY
cláusula para classificar o conjunto de resultados por uma ou mais colunas. - Use a
ASC
opção para classificar o conjunto de resultados em ordem crescente e aDESC
opção para classificar o conjunto de resultados em ordem decrescente. - A
ORDER BY
cláusula é avaliada após as cláusulasFROM
eSELECT
. - No MySQL,
NULL
é menor que valores não NULL