Le Tableau 9.51 présente les opérateurs disponibles pour les types tableaux.
Tableau 9.51. Opérateurs pour les tableaux
| Opérateur | Description | Exemple | Résultat |
|---|---|---|---|
= | égal à | ARRAY[1.1,2.1,3.1]::int[] = ARRAY[1,2,3] | t |
<> | différent de | ARRAY[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 |
@> | contient | ARRAY[1,4,3] @> ARRAY[3,1,3] | t |
<@ | est contenu par | ARRAY[2,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 tableaux | ARRAY[1,2,3] || ARRAY[4,5,6] | {1,2,3,4,5,6} |
|| | concaténation de tableaux | ARRAY[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 tableau | 3 || ARRAY[4,5,6] | {3,4,5,6} |
|| | concaténation d'un tableau avec un élément | ARRAY[4,5,6] || 7 | {4,5,6,7} |
Les opérateurs de tri de tableau (<,
>=, etc) comparent le contenu des tableaux
élément par élément, en utilisant la fonction de comparaison B-tree
par défaut pour le type de données de l'élément et en triant sur la
première différence. Dans les tableaux multidimensionnels,
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.)
Les opérateurs de contenance de tableau (<@ et
@>) considèrent qu'un tableau est contenu dans
un autre si chacun de ses éléments apparaît dans l'autre. Les
duplicats ne sont pas spécialement traités, donc
ARRAY[1] et ARRAY[1,1] sont
tous les deux considérés comme contenant l'autre.
Voir la Section 8.15 pour plus de détails sur le comportement des opérateurs. Voir Section 11.2 pour plus d'informations sur les opérateurs qui supportent les opérations indexées.
Le Tableau 9.52 présente les fonctions utilisables avec des types tableaux. Voir la Section 8.15 pour plus d'informations et des exemples d'utilisation de ces fonctions.
Tableau 9.52. Fonctions pour les tableaux
| Fonction | Type de retour | Description | Exemple | Résultat |
|---|---|---|---|---|
| anyarray | ajoute un élément à la fin d'un tableau | array_append(ARRAY[1,2], 3) | {1,2,3} |
| anyarray | concatène deux tableaux | array_cat(ARRAY[1,2,3], ARRAY[4,5]) | {1,2,3,4,5} |
| int | renvoie le nombre de dimensions du tableau | array_ndims(ARRAY[[1,2,3], [4,5,6]]) | 2 |
| text | renvoie une représentation textuelle des dimensions d'un tableau | array_dims(array[[1,2,3], [4,5,6]]) | [1:2][1:3] |
| anyarray | renvoie un tableau initialisé avec une valeur et des dimensions fournies, en option avec des limites basses autres que 1 | array_fill(7, ARRAY[3], ARRAY[2]) | [2:4]={7,7,7} |
| int | renvoie la longueur de la dimension du tableau | array_length(array[1,2,3], 1) | 3 |
| int | renvoie la limite inférieure du tableau donné | array_lower('[0:2]={1,2,3}'::int[], 1) | 0 |
| int | renvoie la position dans le tableau de la première occurrence du deuxième 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 |
| int[] | renvoie un tableau des positions de toutes les occurrences du second argument dans le tableau indiqué comme premier argument (le tableau doit être à une dimension) | array_positions(ARRAY['A','A','B','A'], 'A') | {1,2,4} |
| anyarray | ajoute un élément au début d'un tableau | array_prepend(1, ARRAY[2,3]) | {1,2,3} |
| anyarray | supprime tous les éléments égaux à la valeur donnée à partir du tableau (qui doit n'avoir qu'une seule dimension) | array_remove(ARRAY[1,2,3,2], 2) | {1,3} |
| anyarray | remplace chaque élément d'un tableau égal à la valeur donnée par la nouvelle valeur | array_replace(ARRAY[1,2,5,4], 5, 3) | {1,2,3,4} |
| text | concatène des éléments de tableau en utilisant le délimiteur fourni et une chaîne nulle optionnelle | array_to_string(ARRAY[1, 2, 3, NULL, 5], ',', '*') | 1,2,3,*,5 |
| int | renvoie la limite supérieure du tableau donné | array_upper(ARRAY[1,8,3,7], 1) | 4 |
| int | renvoie le nombre total d'éléments dans le tableau ou 0 si le tableau est vide | cardinality(ARRAY[[1,2],[3,4]]) | 4 |
| text[] | divise une chaîne en tableau d'éléments en utilisant le délimiteur fourni et la chaîne nulle optionnelle | string_to_array('xx~^~yy~^~zz', '~^~', 'yy') | {xx,NULL,zz} |
| setof anyelement | étend un tableau à un ensemble de lignes | unnest(ARRAY[1,2]) | 1
2(2 rows) |
| 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 | 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é à 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 occurrence 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.
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 à propos de la fonction
d'agrégat array_agg à utiliser avec les tableaux.