PostgreSQLLa base de données la plus sophistiquée au monde.

Version anglaise

9.18. Fonctions et opérateurs de tableaux

Le Tableau 9.48, « Opérateurs pour les tableaux » présente les opérateurs disponibles pour les types tableaux.

Tableau 9.48. Opérateurs pour les tableaux

OpérateurDescriptionExempleRésultat
= égal àARRAY[1.1,2.1,3.1]::int[] = ARRAY[1,2,3]t
<> différent deARRAY[1,2,3] <> ARRAY[1,2,4]t
< inférieur àARRAY[1,2,3] < ARRAY[1,2,4]t
> supérieur àARRAY[1,4,3] > ARRAY[1,2,4]t
<= inférieur ou égal àARRAY[1,2,3] <= ARRAY[1,2,3]t
>= supérieur ou égal àARRAY[1,4,3] >= ARRAY[1,4,3]t
@> contientARRAY[1,4,3] @> ARRAY[3,1]t
<@ est contenu parARRAY[2,7] <@ ARRAY[1,7,4,2,6]t
&& se chevauchent (ont des éléments en commun)ARRAY[1,4,3] && ARRAY[2,1]t
|| concaténation de tableauxARRAY[1,2,3] || ARRAY[4,5,6]{1,2,3,4,5,6}
|| concaténation de tableauxARRAY[1,2,3] || ARRAY[[4,5,6],[7,8,9]]{{1,2,3},{4,5,6},{7,8,9}}
|| concaténation d'un élément avec un tableau3 || ARRAY[4,5,6]{3,4,5,6}
|| concaténation d'un tableau avec un élémentARRAY[4,5,6] || 7{4,5,6,7}

Les comparaisons de tableaux comparent les contenus des tableaux élément par élément, en utilisant la fonction de comparaison par défaut du B-Tree pour le type de données de l'élément. Dans les tableaux multi-dimensionnels, les éléments sont visités dans l'ordre des colonnes (« row-major order », le dernier indice varie le plus rapidement). Si le contenu de deux tableaux est identique mais que les dimensions sont différentes, la première différence dans l'information de dimension détermine l'ordre de tri. (Ce fonctionnement diffère de celui des versions de PostgreSQL™ antérieures à la 8.2 : les anciennes versions indiquent que deux tableaux de même contenu sont identiques même si le nombre de dimensions ou les échelles d'indices diffèrent.)

Voir la Section 8.15, « Tableaux » pour plus de détails sur le comportement des opérateurs. Voir Section 11.2, « Types d'index » pour plus d'informations sur les opérateurs qui supportent les opérations indexées.

Le Tableau 9.49, « Fonctions pour les tableaux » présente les fonctions utilisables avec des types tableaux. Voir la Section 8.15, « Tableaux » pour plus d'informations et des exemples d'utilisation de ces fonctions.

Tableau 9.49. Fonctions pour les tableaux

FonctionType de retourDescriptionExempleRésultat
array_append (anyarray, anyelement) anyarrayajoute un élément à la fin d'un tableauarray_append(ARRAY[1,2], 3){1,2,3}
array_cat (anyarray, anyarray) anyarrayconcatène deux tableauxarray_cat(ARRAY[1,2,3], ARRAY[4,5]){1,2,3,4,5}
array_ndims(anyarray) intrenvoie le nombre de dimensions du tableauarray_ndims(ARRAY[[1,2,3], [4,5,6]])2
array_dims (anyarray) textrenvoie une représentation textuelle des dimensions d'un tableauarray_dims(array[[1,2,3], [4,5,6]])[1:2][1:3]
array_fill(anyelement, int[] [, int[]]) anyarrayrenvoie un tableau initialisé avec une valeur et des dimensions fournies, en option avec des limites basses autre que 1array_fill(7, ARRAY[3], ARRAY[2])[2:4]={7,7,7}
array_length(anyarray, int) intrenvoie la longueur de la dimension du tableauarray_length(array[1,2,3], 1)3
array_lower (anyarray, int) intrenvoie la limite inférieure du tableau donnéarray_lower('[0:2]={1,2,3}'::int[], 1)0
array_position(anyarray, anyelement [, int]) intrenvoie la position dans le tableau de la première occurrence du second argument, en débutant la recherche par le troisième argument ou au premier élément (le tableau doit être à une dimension)array_position(ARRAY['sun','mon','tue','wed','thu','fri','sat'], 'mon')2
array_positions(anyarray, anyelement) int[]renvoie un tableau des positions de toutes les occurrences du second argument dans le tableau indiqué comme premier agument (le tableau doit être à une dimension)array_positions(ARRAY['A','A','B','A'], 'A'){1,2,4}
array_prepend (anyelement, anyarray) anyarrayajoute un élément au début d'un tableauarray_prepend(1, ARRAY[2,3]){1,2,3}
array_remove(anyarray, anyelement) anyarraysupprime tous les éléments égaux à la valeur donnée à partir du table (qui doit n'avoir qu'une seule dimension)array_remove(ARRAY[1,2,3,2], 2){1,3}
array_replace(anyarray, anyelement, anyelement) anyarrayremplace chaque élément d'un tableau égal à la valeur donnée par la nouvelle valeurarray_replace(ARRAY[1,2,5,4], 5, 3){1,2,3,4}
array_to_string(anyarray, text [, text]) textconcatène des éléments de tableau en utilisant le délimiteur fourni et une chaîne nulle optionnellearray_to_string(ARRAY[1, 2, 3, NULL, 5], ',', '*')1,2,3,*,5
array_upper (anyarray, int) intrenvoie la limite supérieure du tableau donnéarray_upper(ARRAY[1,8,3,7], 1)4
cardinality(anyarray) intrenvoie le nombre total d'éléments dans le tableau ou 0 si le tableau est videcardinality(ARRAY[[1,2],[3,4]])4
string_to_array(text, text [, text]) text[]divise une chaîne en tableau d'éléments en utilisant le délimiteur fourni et la chaîne nulle optionnellestring_to_array('xx~^~yy~^~zz', '~^~', 'yy'){xx,NULL,zz}
unnest(anyarray) setof anyelementétend un tableau à un ensemble de lignesunnest(ARRAY[1,2])
1
               2
(2 rows)
unnest(anyarray, anyarray [, ...]) setof anyelement, anyelement [, ...]étend les différents tableaux (possiblement de types différents) en un ensemble de lignes. Ceci est autorisé dans la clause FROM ; voir Section 7.2.1.4, « Fonctions de table »unnest(ARRAY[1,2],ARRAY['foo','bar','baz'])
1    foo
               2    bar
               NULL baz
(3 rows)

Dans les fonctions array_position et array_positions, chaque élément du tableau est comparé à la valeur recherchée en utilisant la sémantique de IS NOT DISTINCT FROM.

Dans la fonction array_position, NULL est renvoyé si la valeur n'est pas trouvée.

Dans la fonction array_positions, NULL est renvoyé uniquement si le tableau est NULL ; si la valeur n'est pas trouvée, un tableau vide est renvoyée à la place.

Dans string_to_array, si le délimiteur vaut NULL, chaque caractère de la chaîne en entrée deviendra un élément séparé dans le tableau résultant. Si le délimiteur est une chaîne vide, alors la chaîne entière est renvoyée dans un tableau à un élément. Dans les autres cas, la chaîne en entrée est divisée à chaque occurence du délimiteur.

Dans string_to_array, si le paramètre chaîne_null est omis ou vaut NULL, aucune des sous-chaînes en entrée ne sera remplacée par NULL. Dans array_to_string, si le paramètre chaîne_null est omis ou vaut NULL, tous les éléments NULL du tableau seront simplement ignorés et non représentés dans la chaîne en sortie.

[Note]

Note

Il existe deux différences dans le comportement de string_to_array avec les versions de PostgreSQL™ antérieures à la 9.1. Tout d'abord, il renverra un tableau vide (à zéro élément) plutôt que NULL quand la chaîne en entrée est de taille zéro. Ensuite, si le délimiteur vaut NULL, la fonction divise l'entrée en caractères individuels plutôt que de renvoyer NULL comme avant.

Voir aussi Section 9.20, « Fonctions d'agrégat » à propose la fonction d'agrégat array_agg à utiliser avec les tableaux.