- Categorias:
ORDER BY¶
Especifica uma ordenação das linhas da tabela de resultados a partir de uma lista SELECT.
Sintaxe¶
Classificação por colunas específicas
SELECT ...
FROM ...
ORDER BY orderItem [ , orderItem , ... ]
[ ... ]
Onde:
orderItem ::= { <column_alias> | <position> | <expr> } [ { ASC | DESC } ] [ NULLS { FIRST | LAST } ]
Classificação por todas as colunas
SELECT ...
FROM ...
ORDER BY ALL [ { ASC | DESC } ] [ NULLS { FIRST | LAST } ]
[ ... ]
Parâmetros¶
column_alias
Alias de coluna que aparece na lista SELECT do bloco de consulta.
position
Posição de uma expressão na lista SELECT.
expr
Qualquer expressão em tabelas no escopo atual.
{ ASC | DESC }
Opcionalmente, retorna os valores da chave de classificação em ordem ascendente (do mais baixo para o mais alto) ou descendente (do mais alto para o mais baixo).
Padrão: ASC
NULLS { FIRST | LAST }
Opcionalmente especifica se valores NULL são devolvidos antes/depois de valores não NULL, com base na ordem de classificação (ASC ou DESC).
Padrão: depende da ordem de classificação (ASC ou DESC); consulte as notas de uso abaixo para detalhes
ALL
Classifica os resultados por todas as colunas especificadas na lista SELECT. Os resultados são classificados pelas colunas na ordem em que aparecem.
Por exemplo, suponha que a lista SELECT contenha:
SELECT col_1, col_2, col_3 FROM my_table ORDER BY ALL;
Os resultados são ordenados primeiro por
col_1
, então porcol_2
e depois porcol_3
.Nota
Não é possível especificar ORDER BY ALL se uma coluna na lista SELECT usa uma função agregada.
Notas de uso¶
Todos os dados são ordenados de acordo com o valor do byte numérico de cada caractere na tabela ASCII. A codificação UTF-8 é suportada.
Para valores numéricos, os zeros iniciais antes do ponto decimal e os zeros finais (
0
) após o ponto decimal não têm efeito sobre a ordem de classificação.Quando NULLS FIRST ou NULLS LAST não é especificado, a ordem dos valores NULL depende da configuração do parâmetro DEFAULT_NULL_ORDERING e da ordem de classificação:
Quando a ordem de classificação é ASC (o padrão) e o parâmetro DEFAULT_NULL_ORDERING é definido como
LAST
(o padrão), os valores NULL são retornados por último. Portanto, a menos que especificado de outra forma, os valores NULL são considerados mais altos do que quaisquer valores diferentes de NULL.Quando a ordem de classificação é ASC e o parâmetro DEFAULT_NULL_ORDERING é definido como
FIRST
, os valores NULL são retornados primeiro.Quando a ordem de classificação é DESC e o parâmetro DEFAULT_NULL_ORDERING é definido como
FIRST
, os valores NULL são retornados por último.Quando a ordem de classificação é DESC e o parâmetro DEFAULT_NULL_ORDERING é definido como
LAST
, os valores NULL são retornados primeiro.
Não é garantido que a ordem de classificação seja consistente para valores de diferentes tipos de dados em dados semiestruturados, como uma matriz que contém elementos de diferentes tipos de dados.
A poda top-K pode melhorar o desempenho das consultas que incluem as cláusulas LIMIT e ORDER BY. Para obter mais informações, consulte Poda top-K para aprimoramento de desempenho da consulta.
Um ORDER BY pode ser usado em diferentes níveis em uma consulta, por exemplo, em uma subconsulta ou dentro de uma subcláusula OVER(). Um ORDER BY dentro de uma subconsulta ou subcláusula se aplica somente dentro dessa subconsulta ou subcláusula. Por exemplo, o ORDER BY nas seguintes ordens de consulta resulta somente dentro da subconsulta, não no nível mais externo da consulta:
SELECT * FROM ( SELECT branch_name FROM branch_offices ORDER BY monthly_sales DESC LIMIT 3 );
Neste exemplo, o ORDER BY é especificado na subconsulta, portanto a subconsulta retorna os nomes em ordem de vendas mensais. O ORDER BY na subconsulta não se aplica à consulta externa. Esta consulta retorna os nomes das três filiais que tiveram as vendas mensais mais altas, mas não necessariamente em ordem por vendas mensais.
A classificação pode ser cara. Se você quiser os resultados da consulta externa ordenados, use uma cláusula
ORDER BY
somente no nível superior da consulta, e evite usar cláusulasORDER BY
em subconsultas, a menos que seja necessário.
Exemplos¶
Os exemplos a seguir demonstram como utilizar ORDER BY para classificar os resultados:
Classificação por valores de strings¶
O exemplo a seguir classifica os resultados por valores de strings:
SELECT column1
FROM VALUES
('a'), ('1'), ('B'), (null), ('2'), ('01'), ('05'),
(' this'), ('this'), ('this and that'), ('&'), ('%')
ORDER BY column1;
+---------------+
| COLUMN1 |
|---------------|
| this |
| % |
| & |
| 01 |
| 05 |
| 1 |
| 2 |
| B |
| a |
| this |
| this and that |
| NULL |
+---------------+
Classificação por valores numéricos¶
O exemplo a seguir classifica os resultados por valores numéricos:
SELECT column1
FROM VALUES
(3), (4), (null), (1), (2), (6),
(5), (0005), (.05), (.5), (.5000)
ORDER BY column1;
+---------+
| COLUMN1 |
|---------|
| 0.05 |
| 0.50 |
| 0.50 |
| 1.00 |
| 2.00 |
| 3.00 |
| 4.00 |
| 5.00 |
| 5.00 |
| 6.00 |
| NULL |
+---------+
Classificação de NULLS primeiro ou por último¶
O exemplo a seguir configura todas as consultas na sessão para classificar NULLS por último definindo o parâmetro DEFAULT_NULL_ORDERING para LAST
.
ALTER SESSION SET DEFAULT_NULL_ORDERING = 'LAST';
SELECT column1
FROM VALUES (1), (null), (2), (null), (3)
ORDER BY column1;
+---------+
| COLUMN1 |
|---------|
| 1 |
| 2 |
| 3 |
| NULL |
| NULL |
+---------+
SELECT column1
FROM VALUES (1), (null), (2), (null), (3)
ORDER BY column1 DESC;
+---------+
| COLUMN1 |
|---------|
| NULL |
| NULL |
| 3 |
| 2 |
| 1 |
+---------+
O exemplo a seguir substitui o parâmetro DEFAULT_NULL_ORDERING especificando NULLS FIRST em uma consulta:
SELECT column1
FROM VALUES (1), (null), (2), (null), (3)
ORDER BY column1 NULLS FIRST;
+---------+
| COLUMN1 |
|---------|
| NULL |
| NULL |
| 1 |
| 2 |
| 3 |
+---------+
O exemplo a seguir define o parâmetro DEFAULT_NULL_ORDERING para FIRST
para classificar NULLS primeiro:
ALTER SESSION SET DEFAULT_NULL_ORDERING = 'FIRST';
SELECT column1
FROM VALUES (1), (null), (2), (null), (3)
ORDER BY column1;
+---------+
| COLUMN1 |
|---------|
| NULL |
| NULL |
| 1 |
| 2 |
| 3 |
+---------+
SELECT column1
FROM VALUES (1), (null), (2), (null), (3)
ORDER BY column1 DESC;
+---------+
| COLUMN1 |
|---------|
| 3 |
| 2 |
| 1 |
| NULL |
| NULL |
+---------+
O exemplo a seguir substitui o parâmetro DEFAULT_NULL_ORDERING especificando NULLS LAST em uma consulta:
SELECT column1
FROM VALUES (1), (null), (2), (null), (3)
ORDER BY column1 NULLS LAST;
+---------+
| COLUMN1 |
|---------|
| 1 |
| 2 |
| 3 |
| NULL |
| NULL |
+---------+
Classificação por todas as colunas na lista SELECT¶
Para executar os exemplos nesta seção, crie a seguinte tabela:
CREATE OR REPLACE TABLE my_sort_example(a NUMBER, s VARCHAR, b BOOLEAN);
INSERT INTO my_sort_example VALUES
(0, 'abc', TRUE),
(0, 'abc', FALSE),
(0, 'abc', NULL),
(0, 'xyz', FALSE),
(0, NULL, FALSE),
(1, 'xyz', TRUE),
(NULL, 'xyz', FALSE);
O exemplo a seguir classifica os resultados por todas as colunas da tabela:
SELECT * FROM my_sort_example
ORDER BY ALL;
Como mostrado abaixo, os resultados são ordenados primeiro pela coluna a
, depois pela coluna s
, e depois pela coluna b
(a ordem em que as colunas foram definidas na tabela).
+------+------+-------+
| A | S | B |
|------+------+-------|
| 0 | abc | False |
| 0 | abc | True |
| 0 | abc | NULL |
| 0 | xyz | False |
| 0 | NULL | False |
| 1 | xyz | True |
| NULL | xyz | False |
+------+------+-------+
O seguinte exemplo classifica os resultados em ordem crescente:
SELECT * FROM my_sort_example
ORDER BY ALL ASC;
+------+------+-------+
| A | S | B |
|------+------+-------|
| 0 | abc | False |
| 0 | abc | True |
| 0 | abc | NULL |
| 0 | xyz | False |
| 0 | NULL | False |
| 1 | xyz | True |
| NULL | xyz | False |
+------+------+-------+
O seguinte exemplo define o parâmetro DEFAULT_NULL_ORDERING para classificar valores NULL por último para todas as consultas executadas durante a sessão:
ALTER SESSION SET DEFAULT_NULL_ORDERING = 'LAST';
SELECT * FROM my_sort_example
ORDER BY ALL;
+------+------+-------+
| A | S | B |
|------+------+-------|
| NULL | xyz | False |
| 0 | NULL | False |
| 0 | abc | NULL |
| 0 | abc | False |
| 0 | abc | True |
| 0 | xyz | False |
| 1 | xyz | True |
+------+------+-------+
O seguinte exemplo especifica NULLS FIRST em uma consulta para substituir essa configuração:
SELECT * FROM my_sort_example
ORDER BY ALL NULLS FIRST;
+------+------+-------+
| A | S | B |
|------+------+-------|
| NULL | xyz | False |
| 0 | NULL | False |
| 0 | abc | NULL |
| 0 | abc | False |
| 0 | abc | True |
| 0 | xyz | False |
| 1 | xyz | True |
+------+------+-------+
O exemplo a seguir retorna as colunas na ordem b
, s
e a
. Os resultados são classificados primeiro por b
, então por s
, e depois por a
:
SELECT b, s, a FROM my_sort_example
ORDER BY ALL NULLS LAST;
+-------+------+------+
| B | S | A |
|-------+------+------|
| False | abc | 0 |
| False | xyz | 0 |
| False | xyz | NULL |
| False | NULL | 0 |
| True | abc | 0 |
| True | xyz | 1 |
| NULL | abc | 0 |
+-------+------+------+