Catégories :

Fonctions de données semi-structurées (tableau/objet)

ARRAY_DISTINCT

Renvoie un nouveau ARRAY qui ne contient que les éléments distincts du ARRAY en entrée. La fonction exclut tous les éléments en double qui sont présents dans l’ARRAY en entrée.

Il n’est pas garanti que la fonction renvoie les éléments de l’ARRAY dans un ordre spécifique.

La fonction est protégée contre les valeurs NULL, ce qui signifie qu’elle traite les valeurs NULLs comme des valeurs connues lors de l’identification des éléments en double.

Syntaxe

ARRAY_DISTINCT( <array> )

Arguments

array

Un tableau qui peut contenir des éléments en double à supprimer.

Renvoie

Cette fonction renvoie un ARRAY contenant les éléments des tableaux d’entrée sans éléments en double. Par exemple, si la valeur 'x' apparaît plusieurs fois dans l’ARRAY en entrée, un seul élément a la valeur 'x' dans l’ARRAY renvoyé.

Si l’argument en entrée est NULL, la fonction renvoie NULL.

L’ordre des valeurs dans le tableau renvoyé n’est pas spécifié.

Notes sur l’utilisation

  • Pour les éléments de type OBJECT, les objets doivent être identiques pour être considérés comme des doublons. Pour plus de détails, voir Exemples (dans ce chapitre).

  • Lors de l’identification des éléments en double, la fonction considère NULL comme une valeur connue (c’est-à-dire que NULL n’est pas un duplicata d’une autre valeur X en plus de NULL).

Exemples

L’exemple suivant montre comment la fonction renvoie un ARRAY sans les éléments en double A et NULL à partir d’un ARRAY constant en entrée :

SELECT ARRAY_DISTINCT(['A', 'A', 'B', NULL, NULL]);

+---------------------------------------------+
| ARRAY_DISTINCT(['A', 'A', 'B', NULL, NULL]) |
|---------------------------------------------|
| [                                           |
|   "A",                                      |
|   "B",                                      |
|   undefined                                 |
| ]                                           |
+---------------------------------------------+

L’exemple suivant montre comment le passage de valeurs NULL (au lieu d’un ARRAY) renvoie une valeur NULL :

SELECT ARRAY_DISTINCT(NULL);

+----------------------+
| ARRAY_DISTINCT(NULL) |
|----------------------|
| NULL                 |
+----------------------+

L’exemple suivant montre comment la fonction supprime les OBJECTs en double qui sont des éléments de l’ARRAY en entrée. L’exemple utilise les constantes OBJECT et ARRAY pour construire les OBJECTs et ARRAY.

SELECT ARRAY_DISTINCT( [ {'a': 1, 'b': 2}, {'a': 1, 'b': 2}, {'a': 1, 'b': 3} ] );

+----------------------------------------------------------------------------+
| ARRAY_DISTINCT( [ {'A': 1, 'B': 2}, {'A': 1, 'B': 2}, {'A': 1, 'B': 3} ] ) |
|----------------------------------------------------------------------------|
| [                                                                          |
|   {                                                                        |
|     "a": 1,                                                                |
|     "b": 2                                                                 |
|   },                                                                       |
|   {                                                                        |
|     "a": 1,                                                                |
|     "b": 3                                                                 |
|   }                                                                        |
| ]                                                                          |
+----------------------------------------------------------------------------+

Comme le montre l’exemple, le dernier élément n’est pas considéré comme un doublon car b a une valeur différente (3 et non 2).

Revenir au début