PostgreSQLLa base de données la plus sophistiquée au monde.
Documentation PostgreSQL 17.1 » Langage SQL » Fonctions et opérateurs » Fonctions et opérateurs tableau

9.19. Fonctions et opérateurs tableau #

Tableau 9.54 montre les opérateurs spécialisés disponibles pour les types tableau. En plus de ces derniers, les opérateurs habituels de comparaison montrés dans Tableau 9.1 sont disponibles pour les tableaux. Les opérateurs de comparaison comparent le contenu des tableaux éléments par éléments, en utilisant la fonction de comparaison B-tree par défaut pour le type de données de l'élément, et trient en se basant sur la première différence rencontrée. Dans les tableaux multi-dimensionnels, les éléments sont visités dans l'ordre des lignes (le dernier indice varie plus rapidement). Si les contenus de deux tableaux sont identiques mais que leur dimension est différente, la première différence dans l'information de dimension détermine l'ordre de tri.

Tableau 9.54. Opérateurs de tableau

Opérateur

Description

Exemple(s)

anyarray @> anyarrayboolean

Est-ce que le premier tableau contient le second, autrement dit, est-ce que chaque élément apparaissant dans le deuxième tableau est égal à un élément du premier tableau ? (les duplicats ne sont pas traités spécialement, donc ARRAY[1] et ARRAY[1,1] sont tous les deux considérés comme contenant l'autre.)

ARRAY[1,4,3] @> ARRAY[3,1,3]t

anyarray <@ anyarrayboolean

Est-ce que le premier tableau est contenu par le second ?

ARRAY[2,2,7] <@ ARRAY[1,7,4,2,6]t

anyarray && anyarrayboolean

Est-ce que les tableaux se surchargent, autrement dit ont des éléments en commun ?

ARRAY[1,4,3] && ARRAY[2,1]t

anycompatiblearray || anycompatiblearrayanycompatiblearray

Concatène les deux tableaux. Concaténer un tableau NULL ou un tableau vide est une opération vide ; sinon les tableaux doivent avoir le même nombre de dimensions (comme illustré dans le premier exemple) ou différer de 1 dans le nombre de dimensions (comme illustré dans le second exemple). Si les tableaux n'ont pas des éléments de types identiques, ils seront convertis dans un type commun (voir Section 10.5).

ARRAY[1,2,3] || ARRAY[4,5,6,7]{1,2,3,4,5,6,7}

ARRAY[1,2,3] || ARRAY[[4,5,6],[7,8,9.9]]{{1,2,3},{4,5,6},{7,8,9.9}}

anycompatible || anycompatiblearrayanycompatiblearray

Concatène un élément au début d'un tableau (qui doit être vide ou à une dimension).

3 || ARRAY[4,5,6]{3,4,5,6}

anycompatiblearray || anycompatibleanycompatiblearray

Concatène un élément à la fin d'un tableau (qui doit être vide ou à une dimension).

ARRAY[4,5,6] || 7{4,5,6,7}


Voir Section 8.15 pour plus de détails sur le comportement des opérateurs pour tableau. Voir Section 11.2 pour plus de détails sur les opérateurs supportant des opérations indexées.

Tableau 9.55 montre les fonctions disponibles pour utilisation avec des types tableau. Voir Section 8.15 pour plus d'informations et d'exemples sur l'utilisation de ces fonctions.

Tableau 9.55. Fonctions tableau

Fonction

Description

Exemple(s)

array_append ( anycompatiblearray, anycompatible ) → anycompatiblearray

Ajoute un élément à la fin d'un tableau (identique à l'opérateur anycompatiblearray || anycompatible).

array_append(ARRAY[1,2], 3){1,2,3}

array_cat ( anycompatiblearray, anycompatiblearray ) → anycompatiblearray

Concatène deux tableaux (identique à l'opérateur anycompatiblearray || anycompatiblearray).

array_cat(ARRAY[1,2,3], ARRAY[4,5]){1,2,3,4,5}

array_dims ( anyarray ) → text

Renvoie une représentation textuelle des dimensions du tableau.

array_dims(ARRAY[[1,2,3], [4,5,6]])[1:2][1:3]

array_fill ( anyelement, integer[] [, integer[] ] ) → anyarray

Renvoie un tableau rempli de copies de la valeur donnée, ayant les dimensions de longueurs spécifiés par le deuxième argument. Le troisième argument optionnel fournit des valeurs de limite basse pour chaque dimension (qui vaut par défaut 1).

array_fill(11, ARRAY[2,3]){{11,11,11},{11,11,11}}

array_fill(7, ARRAY[3], ARRAY[2])[2:4]={7,7,7}

array_length ( anyarray, integer ) → integer

Renvoie la longueur de la dimension réclamée du tableau. (Renvoie NULL à la place de 0 pour des dimensions vides ou manquantes.)

array_length(array[1,2,3], 1)3

array_length(array[]::int[], 1)NULL

array_length(array['text'], 2)NULL

array_lower ( anyarray, integer ) → integer

Renvoie la limite basse de la dimension réclamée du tableau.

array_lower('[0:2]={1,2,3}'::integer[], 1)0

array_ndims ( anyarray ) → integer

Renvoie le nombre de dimensions du tableau.

array_ndims(ARRAY[[1,2,3], [4,5,6]])2

array_position ( anycompatiblearray, anycompatible [, integer ] ) → integer

Renvoie l'indice de la première occurence du second argument dans le tableau, ou NULL s'il n'est pas présent. Si le troisième argument est donné, la recherche commence à cet indice. Le tableau doit être d'une dimension. Les comparaisons se font en utilisant les sémantiques de IS NOT DISTINCT FROM, donc il est possible de rechercher un NULL.

array_position(ARRAY['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'], 'mon')2

array_positions ( anycompatiblearray, anycompatible ) → integer[]

Renvoie un tableau des indices de toutes les occurrences du deuxième argument dans le tableau donné comme premier argument. Le tableau doit être à une dimension. Les comparaisons sont effectuées en utilisant les sémantiques de IS NOT DISTINCT FROM, il est donc possible de rechercher un NULL. NULL n'est renvoyé que si le tableau vaut NULL ; si la valeur n'est pas trouvée dans le tableau, un tableau vide est renvoyé.

array_positions(ARRAY['A','A','B','A'], 'A'){1,2,4}

array_prepend ( anycompatible, anycompatiblearray ) → anycompatiblearray

Ajoute un élément au début d'un tableau (identique à l'opérateur anyelement || anyarray).

array_prepend(1, ARRAY[2,3]){1,2,3}

array_remove ( anycompatiblearray, anycompatible ) → anycompatiblearray

Supprime tous les éléments identiques à la valeur donnée à partir du tableau. Le tableau doit être à une dimension. Les comparaisons sont faites en utilisant les sémantiques de IS NOT DISTINCT FROM, dont il est possible de supprimer un NULL.

array_remove(ARRAY[1,2,3,2], 2){1,3}

array_replace ( anycompatiblearray, anycompatible, anyelement ) → anycompatiblearray

Remplace chaque élément de tableau égal au second argument avec le troisième argument.

array_replace(ARRAY[1,2,5,4], 5, 3){1,2,3,4}

array_sample ( array anyarray, n integer ) → anyarray

Renvoie un tableau de n éléments sélectionnés au hasard dans array. n ne peut pas dépasser la longueur de la première dimension de array. Si array est multi-dimensionnel, un « item » est une partie ayant un premier indice indiqué.

array_sample(ARRAY[1,2,3,4,5,6], 3){2,6,1}

array_sample(ARRAY[[1,2],[3,4],[5,6]], 2){{5,6},{1,2}}

array_shuffle ( anyarray ) → anyarray

Mélange au hasard la première dimension du tableau.

array_shuffle(ARRAY[[1,2],[3,4],[5,6]]){{5,6},{1,2},{3,4}}

array_to_string ( array anyarray, delimiter text [, null_string text ] ) → text

Convertit chaque élément de tableau en sa représentation textuelle, et les concatène en les séparant par la chaîne delimiter. Si null_string est indiqué et ne vaut pas NULL, alors les entrées de tableau NULL sont représentées par cette chaîne ; sinon elles sont omises. Voir aussi string_to_array.

array_to_string(ARRAY[1, 2, 3, NULL, 5], ',', '*')1,2,3,*,5

array_upper ( anyarray, integer ) → integer

Renvoie la limite haute de la dimension demandée du tableau.

array_upper(ARRAY[1,8,3,7], 1)4

cardinality ( anyarray ) → integer

Renvoie le nombre total d'éléments dans le tableau, ou 0 si le tableau est vide.

cardinality(ARRAY[[1,2],[3,4]])4

trim_array ( array anyarray, n integer ) → anyarray

Coupe un tableau en supprimant les n derniers éléments. Si le tableau est multidimensionnel, seule la première dimension est coupée.

trim_array(ARRAY[1,2,3,4,5,6], 2){1,2,3,4}

unnest ( anyarray ) → setof anyelement

Étend un tableau en un ensemble de lignes. Les éléments du tableau sont lus dans l'ordre de stockage.

unnest(ARRAY[1,2])

 1
 2

unnest(ARRAY[['foo','bar'],['baz','quux']])

 foo
 bar
 baz
 quux
      

unnest ( anyarray, anyarray [, ... ] ) → setof anyelement, anyelement [, ... ]

Étend plusieurs tableaux (potentiellement de types de données différents) en un ensemble de lignes. Si les tableaux ne sont pas de la même longueur, alors les plus courts sont alignés avec des NULL. Cette forme est seulement autorisée dans la clause FROM d'une requête ; voir Section 7.2.1.4.

select * from unnest(ARRAY[1,2], ARRAY['foo','bar','baz']) as x(a,b)

 a |  b
---+-----
 1 | foo
 2 | bar
   | baz
      


Voir aussi Section 9.21 sur la fonction d'agrégat array_agg pour une utilisation avec les tableaux.