- Catégories :
Fonctions de données semi-structurées et structurées (tableau/objet)
ARRAY_SORT¶
Renvoie un ARRAY contenant les éléments du ARRAY d’entrée triés par ordre croissant ou décroissant. Vous pouvez spécifier si les éléments NULL sont triés avant ou après les éléments non NULL.
Syntaxe¶
ARRAY_SORT( <array> [ , <sort_ascending> [ , <nulls_first> ] ] )
Arguments¶
Nécessaire
arrayLe ARRAY des éléments à trier.
Facultatif
sort_ascendingIndique si les éléments doivent être triés par ordre croissant ou décroissant :
Indiquez TRUE pour trier les éléments par ordre croissant.
Indiquez FALSE pour trier les éléments par ordre décroissant.
Par défaut : TRUE
nulls_firstSpécifie si les éléments SQL NULL doivent être placés au début ou à la fin du ARRAY trié :
Spécifiez TRUE pour placer les éléments SQL NULL en premier dans le ARRAY.
Spécifiez FALSE pour placer les éléments SQL NULL en dernier dans le ARRAY.
Valeur par défaut : FALSE si le ARRAY est trié par ordre croissant ; TRUE si ARRAY est trié par ordre décroissant.
Cet argument n’affecte que l’ordre des éléments de SQL NULL. Cela n’affecte pas l’ordre des éléments JSON null.
Renvoie¶
Cette fonction renvoie un ARRAY qui contient les éléments de array dans l’ordre.
Notes sur l’utilisation¶
L’ordre de tri est équivalent à l’ordre résultant de l’aplatissement du ARRAY et de la spécification d’une clause ORDER BY avec les paramètres ASC | DESC and NULLS FIRST | LAST correspondants.
Si l’un des arguments d’entrée est NULL, la fonction renvoie NULL.
Il n’est pas garanti que cette fonction fournisse un tri stable lorsque le ARRAY contient l’un des éléments suivants :
Éléments de deux types numérique ou horodatage différents.
Objets contenant deux types numériques ou horodatage différents.
Exemples¶
L’exemple suivant renvoie un ARRAY de nombres dont les éléments sont issus d’un ARRAY d’entrée constant trié par ordre croissant. Les éléments comprennent un JSON NULL (PARSE_JSON(“null”)) et un SQL NULL.
Notez que dans le ARRAY trié, les JSON NULLs (null) et les SQL NULLs (undefined) sont les derniers éléments.
SELECT ARRAY_SORT([20, PARSE_JSON('null'), 0, NULL, 10]);
+---------------------------------------------------+
| ARRAY_SORT([20, PARSE_JSON('NULL'), 0, NULL, 10]) |
|---------------------------------------------------|
| [ |
| 0, |
| 10, |
| 20, |
| null, |
| undefined |
| ] |
+---------------------------------------------------+
L’exemple suivant renvoie un ARRAY de nombres dont les éléments sont triés par ordre décroissant. Notez que dans le ARRAY trié, les JSON NULLs (null) et les SQL NULLs (undefined) sont les premiers éléments.
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 |
| ] |
+----------------------------------------------------------+
L’exemple suivant trie les éléments par ordre croissant. L’exemple définit l’argument nulls_first sur TRUE pour placer les SQL NULLs (undefined) en premier dans le ARRAY trié. (Par défaut, les SQL NULLs sont placés à la fin d’un ARRAY trié par ordre croissant)
Notez que nulls_first n’a aucun effet sur l’emplacement des 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 |
| ] |
+---------------------------------------------------------------+
L’exemple suivant trie les éléments par ordre décroissant. L’exemple définit l’argument nulls_first sur FALSE pour placer les SQL NULLs (undefined) en dernier dans le ARRAY trié. (Par défaut, les SQL NULLs sont placés au début d’un ARRAY trié par ordre décroissant)
Notez que nulls_first n’a aucun effet sur l’emplacement des 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 |
| ] |
+-----------------------------------------------------------------+
L’exemple suivant utilise la fonction ARRAY_INSERT pour construire un ARRAY peu rempli. (L’exemple insère les valeurs 1 et 2 à des positions spécifiques dans le ARRAY.) L’exemple utilise ensuite la fonction ARRAY_SORT pour trier ce 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 |
| ] | ] |
+--------------+-----------------+
L’exemple suivant montre que le tri d’un ARRAY avec différents types numériques entraîne un tri instable. L’exemple utilise un ARRAY qui contient des valeurs NUMBER et une valeur 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 |
| ] |
+----------------------------------+