Definition, notes, and examples for the Array data type - AnalyticDB

Définition

Un ARRAY stocke une collection d'éléments du même type de données et autorise les doublons, à l'instar d'une liste en Java. Tous les éléments d'un tableau doivent être du même type. Par exemple, définir array<int> pour une colonne signifie que chaque élément de cette colonne est de type INT.

Les tableaux imbriqués sont pris en charge. Exemple : array<array<string>>.

Limites

Important

Vous ne pouvez pas créer d'index sur les colonnes de type ARRAY ou MAP.

Pour filtrer efficacement les données de type tableau, combinez les conditions de recherche dans vos requêtes SQL au lieu d'analyser l'intégralité des tableaux. Réduire le volume de données analysées améliore les performances des requêtes.

Utilisation des tableaux

Créer une table

L'instruction suivante crée une table comportant deux colonnes de type tableau : b de type array<int> et c de type array<array<string>>.

Create Table `array_test` (
  `a` int,
  `b` array<int>,
  `c` array<array<string>>,
  primary key (`a`)
) DISTRIBUTED BY HASH(`a`)

Insérer des données

Insérez les valeurs de tableau sous forme de chaînes JSON. L'instruction suivante insère une ligne où b vaut [1,2,3] et c vaut [["a"],["b","c"]].

insert into array_test values (1, '[1,2,3]', '[["a"],["b","c"]]');

Interroger des données

Interrogez la table pour récupérer toutes les lignes :

mysql> select * from array_test;
+------+---------+-------------------+
| a    | b       | c                 |
+------+---------+-------------------+
|    1 | [1,2,3] | [["a"],["b","c"]] |
+------+---------+-------------------+
1 row in set (0.08 sec)

Les colonnes de type ARRAY et MAP sont renvoyées au format JSON. Par exemple, c[2], une sous-colonne array<string> imbriquée, est renvoyée sous la forme d'un tableau JSON.

Accès aux éléments du tableau

Utilisez la notation entre crochets ou la fonction element_at pour récupérer des éléments par indice.

Important

Les indices de tableau commencent à 1 et non à 0. b[1] et element_at(b, 1) sont équivalents.

Le tableau suivant présente les deux syntaxes d'accès et leurs résultats :

Expression	Résultat
`b[1]`	`1` (premier élément de `b`)
`element_at(b, 1)`	`1` (premier élément de `b`)
`c[2]`	`["b","c"]` (deuxième élément de `c`)
`element_at(c, 2)`	`["b","c"]` (deuxième élément de `c`)

Exemple de requête complète :

mysql> select a,b[1],element_at(b,1),c[2],element_at(c,2) from array_test;
+------+------+-----------------+-----------+-----------------+
| a    | b[1] | element_at(b,1) | c[2]      | element_at(c,2) |
+------+------+-----------------+-----------+-----------------+
|    1 |    1 |               1 | ["b","c"] | ["b","c"]       |
+------+------+-----------------+-----------+-----------------+
1 row in set (0.11 sec)

Fonctions prises en charge

Fonction	Description	Type de retour
`element_at`	Renvoie l'élément situé à l'indice indiqué (basé sur 1). Exemple : `element_at(array[1,2], 1)` renvoie `1`.	T
`size`	Renvoie le nombre d'éléments d'un tableau.	int
`contains`	Indique si un tableau contient la valeur spécifiée. Exemple : `contains(array[1,2], 2)` renvoie `1`.	BOOL
`array_max`	Renvoie l'élément maximal d'un tableau.	T
`array_min`	Renvoie l'élément minimal d'un tableau.	T
`array_position`	Renvoie l'indice de la première occurrence d'un élément. Exemple : `array_position(array['a','b','b'],'b')` renvoie `2`.	int
`array_remove`	Supprime tous les éléments égaux à la valeur spécifiée. Exemple : `array_remove(array['a','b','b'],'b')` renvoie `['a']`.	array
`array_sort`	Trie un tableau. Exemple : `array_sort(array[3,2,1])` renvoie `[1,2,3]`.	array
`reverse`	Inverse l'ordre des éléments. Exemple : `reverse(array[5,9,3])` renvoie `[3,9,5]`.	array
`shuffle`	Renvoie le tableau avec ses éléments dans un ordre aléatoire. Exemple : `shuffle(array[1,5,8])` peut renvoyer `[5,1,8]`.	array
`slice`	Renvoie un sous-tableau. `start` correspond à l'indice de départ (basé sur 1) ; `length` indique le nombre d'éléments à renvoyer. Exemple : `slice(array[1,2,3,4,5], 3, 2)` renvoie `[3,4]`.	array
`concat`	Fusionne deux tableaux ou plus en conservant les doublons. Exemple : `concat(array[1], array[1,2])` renvoie `[1,1,2]`.	array
`array_distinct`	Supprime les éléments en double d'un tableau. Exemple : `array_distinct(array[1,1,2])` renvoie `[1,2]`.	array
`array_union`	Fusionne deux tableaux ou plus et supprime les doublons. Exemple : `array_union(array[1], array[1,2])` renvoie `[1,2]`.	array
`array_intersect`	Renvoie les éléments présents dans tous les tableaux d'entrée. Exemple : `array_intersect(array[1], array[1,2])` renvoie `[1]`.	array
`array_join`	Concatène les éléments du tableau en une chaîne à l'aide du délimiteur spécifié. Exemple : `array_join(array[1,2,3,4],'a')` renvoie `1a2a3a4`.	string
`flatten`	Aplatisse un tableau imbriqué en un tableau à un seul niveau. Exemple : `flatten(array[array[1,2],array[3]])` renvoie `[1,2,3]`.	array