Categorias:: Sintaxe de consulta

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 por col_2 e depois por col_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.
Uma cláusula ORDER BY pode ser usada em diferentes níveis em uma consulta, como em uma subconsulta ou dentro de uma cláusula OVER() para uma função de janela. Uma cláusula ORDER BY dentro de uma subconsulta ou uma cláusula OVER() se aplica somente nesse contexto. Por exemplo, a cláusula 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, a cláusula ORDER BY foi especificada na subconsulta, portanto a subconsulta retorna os nomes na ordem das vendas mensais. A cláusula 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 mais externa ordenados, use uma cláusula ORDER BY somente no nível superior da consulta, e evite usar cláusulas ORDER BY em subconsultas, a menos que seja necessário.

Da mesma forma, quando as cláusulas ORDER BY e LIMIT (ou FETCH) estão em diferentes níveis de aninhamento, os resultados podem ser imprevisíveis. Para obter detalhes e exemplos, consulte as notas de uso de LIMIT/FETCH.

Exemplos¶

Os exemplos a seguir demonstram como utilizar ORDER BY para classificar os resultados:

Classificação por valores de strings
Classificação por valores numéricos
Classificação de NULLS primeiro ou por último

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    |
+-------+------+------+