- Categorias:
Funções de dados semiestruturados e estruturados (Matriz/objeto)
ARRAY_SORT¶
Retorna uma ARRAY que contém os elementos da ARRAY de entrada classificados em ordem crescente ou decrescente. Você pode especificar se os elementos NULL serão classificados antes ou depois dos elementos não NULL.
Sintaxe¶
ARRAY_SORT( <array> [ , <sort_ascending> [ , <nulls_first> ] ] )
Argumentos¶
Obrigatório
arrayA ARRAY de elementos a serem classificados.
Opcional
sort_ascendingEspecifica se os elementos devem ser classificados em ordem crescente ou decrescente:
Especifique TRUE para classificar os elementos em ordem crescente.
Especifique FALSE para classificar os elementos em ordem decrescente.
Padrão: TRUE
nulls_firstEspecifica se os elementos SQL NULL devem ser colocados no início ou no fim da ARRAY classificada:
Especifique TRUE para colocar os elementos SQL NULL primeiro na ARRAY.
Especifique FALSE para colocar os elementos SQL NULL por último na ARRAY.
Padrão: FALSE se ARRAY estiver classificada em ordem crescente; TRUE se ARRAY estiver classificada em ordem decrescente.
Este argumento afeta apenas a ordem dos elementos SQL NULL. Isso não afeta a ordem dos elementos JSON null.
Retornos¶
Esta função retorna uma ARRAY que contém os elementos de array em ordem de classificação.
Notas de uso¶
A ordem de classificação é equivalente à ordem resultante do nivelamento da ARRAY e da especificação de uma cláusula ORDER BY com os parâmetros ASC | DESC and NULLS FIRST | LAST correspondentes.
Se algum dos argumentos de entrada for NULL, a função retornará NULL.
Não há garantia de que esta função forneça uma classificação estável quando ARRAY contiver um dos seguintes itens:
Elementos de dois tipos diferentes numérico ou carimbo de data/hora.
Objetos contendo dois tipos numéricos ou de carimbo de data/hora diferentes.
Exemplos¶
O exemplo a seguir retorna uma ARRAY de números com os elementos de uma constante da ARRAY de entrada classificados em ordem crescente. Os elementos incluem um JSON NULL (PARSE_JSON(“null”)) e um SQL NULL.
Observe que na ARRAY classificada, JSON NULLs (null) e SQL NULLs (undefined) são os últimos elementos.
SELECT ARRAY_SORT([20, PARSE_JSON('null'), 0, NULL, 10]);
+---------------------------------------------------+
| ARRAY_SORT([20, PARSE_JSON('NULL'), 0, NULL, 10]) |
|---------------------------------------------------|
| [ |
| 0, |
| 10, |
| 20, |
| null, |
| undefined |
| ] |
+---------------------------------------------------+
O exemplo a seguir retorna uma ARRAY de números com os elementos classificados em ordem decrescente. Observe que na ARRAY classificada, JSON NULLs (null) e SQL NULLs (undefined) são os primeiros elementos.
SELECT ARRAY_SORT([20, PARSE_JSON('null'), 0, NULL, 10], FALSE);
+----------------------------------------------------------+
| ARRAY_SORT([20, PARSE_JSON('NULL'), 0, NULL, 10], FALSE) |
|----------------------------------------------------------|
| [ |
| undefined, |
| null, |
| 20, |
| 10, |
| 0 |
| ] |
+----------------------------------------------------------+
O exemplo a seguir classifica os elementos em ordem crescente. O exemplo define o argumento nulls_first como TRUE para colocar o SQL NULLs (undefined) primeiro na ARRAY classificada. (Por padrão, SQL NULLs são colocados no fim de uma ARRAY classificada em ordem crescente.)
Observe que nulls_first não tem efeito no posicionamento de JSON NULLs (null).
SELECT ARRAY_SORT([20, PARSE_JSON('null'), 0, NULL, 10], TRUE, TRUE);
+---------------------------------------------------------------+
| ARRAY_SORT([20, PARSE_JSON('NULL'), 0, NULL, 10], TRUE, TRUE) |
|---------------------------------------------------------------|
| [ |
| undefined, |
| 0, |
| 10, |
| 20, |
| null |
| ] |
+---------------------------------------------------------------+
O exemplo a seguir classifica os elementos em ordem decrescente. O exemplo define o argumento nulls_first como FALSE para colocar o SQL NULLs (undefined) por último na ARRAY classificada. (Por padrão, SQL NULLs são colocados no início de uma ARRAY classificada em ordem decrescente.)
Observe que nulls_first não tem efeito no posicionamento de JSON NULLs (null).
SELECT ARRAY_SORT([20, PARSE_JSON('null'), 0, NULL, 10], FALSE, FALSE);
+-----------------------------------------------------------------+
| ARRAY_SORT([20, PARSE_JSON('NULL'), 0, NULL, 10], FALSE, FALSE) |
|-----------------------------------------------------------------|
| [ |
| null, |
| 20, |
| 10, |
| 0, |
| undefined |
| ] |
+-----------------------------------------------------------------+
O exemplo a seguir usa a função ARRAY_INSERT para construir uma ARRAY pouco preenchido. (O exemplo insere os valores 1 e 2 em posições específicas na ARRAY.) O exemplo então usa a função ARRAY_SORT para classificar esta ARRAY.
SELECT ARRAY_INSERT(ARRAY_INSERT(ARRAY_CONSTRUCT(), 3, 2), 6, 1) arr, ARRAY_SORT(arr);
+--------------+-----------------+
| ARR | ARRAY_SORT(ARR) |
|--------------+-----------------|
| [ | [ |
| undefined, | 1, |
| undefined, | 2, |
| undefined, | undefined, |
| 2, | undefined, |
| undefined, | undefined, |
| undefined, | undefined, |
| 1 | undefined |
| ] | ] |
+--------------+-----------------+
O exemplo a seguir demonstra que a classificação da ARRAY com diferentes tipos numéricos resulta em uma classificação instável. O exemplo usa uma ARRAY que contém valores NUMBER e um valor REAL.
SELECT ARRAY_SORT([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1e0::REAL]) AS array_of_different_numeric_types;
+----------------------------------+
| ARRAY_OF_DIFFERENT_NUMERIC_TYPES |
|----------------------------------|
| [ |
| 1, |
| 1.000000000000000e+00, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1, |
| 1 |
| ] |
+----------------------------------+