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

9.19. Fonctions et opérateurs tableau

Tableau 9.51 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. (Ceci change des versions de PostgreSQL antérieures à la 8.2 : les anciennes versions penseront que deux tableaux de même contenu sont identiques, même si le nombre de dimensions ou l'étendu des indices est différent.)

Tableau 9.51. 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

anyarray || anyarrayanyarray

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 illustraté dans le premier exemple) ou différer de 1 dans le nombre de dimensions (comme illustré dans le second exemple).

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]]{{1,2,3},{4,5,6},{7,8,9}}

anyelement || anyarrayanyarray

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}

anyarray || anyelementanyarray

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.52 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.52. Fonctions tableau

Fonction

Description

Exemple(s)

array_append ( anyarray, anyelement ) → anyarray

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

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

array_cat ( anyarray, anyarray ) → anyarray

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

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.

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

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 ( anyarray, anyelement [, 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 ( anyarray, anyelement ) → 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 ( anyelement, anyarray ) → anyarray

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 ( anyarray, anyelement ) → anyarray

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 ( anyarray, anyelement, anyelement ) → anyarray

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_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.

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

string_to_array ( string text, delimiter text [, null_string text ] ) → text[]

Divise la chaîne string à chaque occurrence de delimiter et forme le reste des données dans le tableau text. Si delimiter est NULL, chaque caractère dans string deviendra un élément séparé dans le tableau. Si delimiter est une chaîne vide, alors string est traité comme un champ vide. Si null_string est fourni et non NULL, les champs correspondant à cette chaîne sont convertis en entrées NULL.

string_to_array('xx~~yy~~zz', '~~', 'yy'){xx,NULL,zz}

unnest ( anyarray ) → setof anyelement

Étend le tableau en un ensemble de lignes.

unnest(ARRAY[1,2])

 1
 2

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. Ceci est seulement autorisé 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


Note

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

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