Hologres:Array functions

ARRAY_TO_STRING

array_to_string(anyarray, text[, text]) → TEXT

Concatène les éléments d'un tableau à l'aide d'un séparateur spécifié. Le troisième argument facultatif remplace les éléments NULL ; s'il est omis, les valeurs NULL sont ignorées.

Paramètres

Exemple

-- Result: 1,2,3
SELECT array_to_string(ARRAY[1, 2, 3], ',');

ARRAY_AGG

array_agg(anyelement) → ARRAY

Agrège les valeurs d'une colonne provenant de plusieurs lignes dans un seul tableau. Deux formes de syntaxe sont prises en charge.

Syntaxe 1 : Agrégation de base

array_agg(anyelement)

Syntaxe 2 : Agrégation avec tri et filtrage

array_agg(expression [order_by_clause]) [FILTER (WHERE filter_clause)]

Paramètres

Notes d'utilisation

• Pris en charge dans Hologres V1.3 et versions ultérieures : DECIMAL, DATE, TIMESTAMP, TIMESTAMPTZ.

• Non pris en charge : JSON, JSONB, TIMETZ, INTERVAL, INET, OID, UUID, ARRAY.

• La clause FILTER nécessite Hologres V1.3 ou version ultérieure. Pour mettre à niveau votre instance, consultez les rubriques Mise à niveau de l'instance ou Comment obtenir plus d'assistance en ligne ?.

Exemples

Agrégation de base :

CREATE TABLE test_array_agg_int (
    c1 int
);

INSERT INTO test_array_agg_int
    VALUES (1), (2);

SELECT array_agg(c1)
FROM test_array_agg_int;

Résultat :

 array_agg
-----------
 {2,1}
(1 row)

Agrégation avec FILTER (nécessite Hologres V1.3+) :

SELECT array_agg(c1) FILTER (WHERE c1 > 1)
FROM test_array_agg_int;

Résultat :

 array_agg
-----------
 {2}
(1 row)

ARRAY_APPEND

array_append(anyarray, anyelement) → ARRAY

Ajoute un élément à la fin d'un tableau.

Paramètres

Exemple

-- Result: {1,2,3}
SELECT array_append(ARRAY[1,2], 3);

ARRAY_CAT

array_cat(anyarray, anyarray) → ARRAY

Concatène deux tableaux du même type d'élément.

Paramètres

Exemple

-- Result: {1,2,3,4,5}
SELECT array_cat(ARRAY[1,2,3], ARRAY[4,5]);

ARRAY_NDIMS

array_ndims(anyarray) → INT

Renvoie le nombre de dimensions d'un tableau.

Paramètres

Exemple

-- Result: 2
SELECT array_ndims(ARRAY[[1,2,3], [4,5,6]]);

ARRAY_DIMS

array_dims(anyarray) → TEXT

Renvoie les limites des dimensions d'un tableau sous forme de chaîne de texte, en affichant les limites inférieure et supérieure de chaque dimension.

Paramètres

Exemple

-- Result: [1:2][1:3]
SELECT array_dims(ARRAY[[1,2,3], [4,5,6]]);

ARRAY_LENGTH

array_length(anyarray, int) → INT

Renvoie le nombre d'éléments dans la dimension spécifiée d'un tableau. Les dimensions sont numérotées à partir de 1.

Paramètres

Exemple

-- Result: 3
SELECT array_length(ARRAY[1,2,3], 1);

ARRAY_LOWER

array_lower(anyarray, int) → INT

Renvoie la limite inférieure de la dimension de tableau spécifiée. Pour les tableaux standard, cette valeur est 1. Pour les tableaux avec une limite inférieure personnalisée (tels que '[0:2]={1,2,3}'::int[]), la limite inférieure réelle est renvoyée. Les dimensions sont numérotées à partir de 1.

Paramètres

Exemple

-- Result: 0
SELECT array_lower('[0:2]={1,2,3}'::int[], 1);

ARRAY_POSITIONS

array_positions(anyarray, anyelement) → ARRAY

Renvoie les indices d'un élément spécifié dans un tableau unidimensionnel.

Paramètres

Exemple

-- Result: {1,2,4}
SELECT array_positions(ARRAY['A','A','B','A'], 'A');

ARRAY_PREPEND

array_prepend(anyelement, anyarray) → ARRAY

Ajoute un élément au début d'un tableau.

Paramètres

Exemple

-- Result: {1,2,3}
SELECT array_prepend(1, ARRAY[2,3]);

ARRAY_REMOVE

array_remove(anyarray, anyelement) → ARRAY

Supprime tous les éléments égaux à la valeur spécifiée d'un tableau unidimensionnel.

Paramètres

Exemple

-- Result: {1,3}
SELECT array_remove(ARRAY[1,2,3,2], 2);

ARRAY_SORT

array_sort(anyarray) → ARRAY

Trie les éléments d'un tableau par ordre croissant.

Notes d'utilisation

Paramètres

Exemple

-- Result: {1,1,2,3}
SELECT array_sort(ARRAY[1,3,2,1]);

ARRAY_UPPER

array_upper(anyarray, int) → INT

Renvoie la limite supérieure de la dimension de tableau spécifiée. Pour un tableau unidimensionnel standard, cette valeur correspond au nombre d'éléments. Les dimensions sont numérotées à partir de 1.

Paramètres

Exemple

-- Result: 4
SELECT array_upper(ARRAY[1,8,3,7], 1);

UNNEST

unnest(anyarray) → setof TEXT

Développe chaque élément d'un tableau en une ligne distincte. Utilisez cette fonction dans la clause FROM ou comme fonction renvoyant un ensemble.

Paramètres

Exemple

SELECT unnest(ARRAY[1,2]);

Résultat :

unnest
------
1
2
(2 rows)

ARRAY_MAX

array_max(array) → INT

Renvoie la valeur maximale des éléments d'un tableau. Les valeurs NULL sont ignorées lors du calcul. Nécessite Hologres V1.3.19 ou version ultérieure.

array_max ne prend pas en charge les requêtes sur des constantes ; utilisez une colonne de table en entrée.

Paramètres

Exemple

CREATE TABLE test_array_max_int (
    c1 int[]
);

INSERT INTO test_array_max_int
    VALUES (NULL), (ARRAY[-2, NULL, -3, -12, -7]);

SELECT c1, array_max(c1)
FROM test_array_max_int;

Résultat :

        c1        | array_max
------------------+-----------
 \N               | \N
 {-2,0,-3,-12,-7} |         0
(2 rows)

ARRAY_MIN

array_min(array) → INT

Renvoie la valeur minimale des éléments d'un tableau. Nécessite Hologres V1.3.19 ou version ultérieure.

array_min ne prend pas en charge les requêtes sur des constantes ; utilisez une colonne de table en entrée.

Paramètres

Exemple

CREATE TABLE test_array_min_text (
    c1 text[]
);

INSERT INTO test_array_min_text
    VALUES (NULL), (ARRAY['hello', 'holo', 'blackhole', 'array']);

SELECT c1, array_min(c1)
FROM test_array_min_text;

Résultat :

              c1              | array_min
------------------------------+-----------
 \N                           | \N
 {hello,holo,blackhole,array} | array
(2 rows)

ARRAY_CONTAINS

array_contains(array, target_value) → BOOLEAN

Vérifie si un tableau contient une valeur spécifiée. Renvoie true si la valeur est trouvée, false sinon. Nécessite Hologres V1.3.19 ou version ultérieure.

array_contains ne prend pas en charge les requêtes sur des constantes ; utilisez une colonne de table en entrée.

Paramètres

Exemple

CREATE TABLE test_array_contains_text (
    c1 text[],
    c2 text
);

INSERT INTO test_array_contains_text
    VALUES (ARRAY[NULL, 'cs', 'holo', 'sql', 'a', NULL, ''], 'holo'),
           (ARRAY['holo', 'array', 'FE', 'l', NULL, ''], 'function');

SELECT c1, c2, array_contains(c1, c2)
FROM test_array_contains_text;

Résultat :

            c1            |    c2    | array_contains
--------------------------+----------+----------------
 {holo,array,FE,l,"",""}  | function | f
 {"",cs,holo,sql,a,"",""} | holo     | t
(2 rows)

ARRAY_EXCEPT

array_except(array1, array2) → ARRAY

Renvoie les éléments présents dans array1 mais absents de array2. Nécessite Hologres V1.3.19 ou version ultérieure.

array_except ne prend pas en charge les requêtes sur des constantes ; utilisez des colonnes de table en entrée.

Paramètres

Exemple

CREATE TABLE test_array_except_text (
    c1 text[],
    c2 text[]
);

INSERT INTO test_array_except_text
    VALUES (ARRAY['o', 'y', 'l', 'l', NULL, ''], NULL),
           (ARRAY['holo', 'hello', 'hello', 'SQL', '', 'blackhole'], ARRAY['holo', 'SQL', NULL, 'kk']);

SELECT c1, c2, array_except(c1, c2)
FROM test_array_except_text;

Résultat :

                 c1                  |        c2        |   array_except
-------------------------------------+------------------+-------------------
 {o,y,l,l,"",""}                     |                  | {o,l,y,""}
 {holo,hello,hello,SQL,"",blackhole} | {holo,SQL,"",kk} | {blackhole,hello}
(2 rows)

ARRAY_DISTINCT

array_distinct(array) → ARRAY

Supprime les éléments en double d'un tableau. Nécessite Hologres V1.3.19 ou version ultérieure.

array_distinct ne prend pas en charge les requêtes sur des constantes ; utilisez une colonne de table en entrée.

Paramètres

Exemple

CREATE TABLE test_array_distinct_text (
    c1 text[]
);

INSERT INTO test_array_distinct_text
    VALUES (ARRAY['holo', 'hello', 'holo', 'SQL', 'SQL']),
           (ARRAY[]::text[]);

SELECT c1, array_distinct(c1)
FROM test_array_distinct_text;

Résultat :

            c1             |  array_distinct
---------------------------+------------------
 {holo,hello,holo,SQL,SQL} | {SQL,hello,holo}
 {}                        | {NULL}
(2 rows)

ARRAY_UNION

array_union(array1, array2) → ARRAY

Fusionne deux tableaux en un nouveau tableau et supprime les éléments en double. Nécessite Hologres V1.3.19 ou version ultérieure.

array_union ne prend pas en charge les requêtes sur des constantes ; utilisez des colonnes de table en entrée.

Paramètres

Exemple

CREATE TABLE test_array_union_int (
    c1 int[],
    c2 int[]
);

INSERT INTO test_array_union_int
    VALUES (NULL, ARRAY[2, -3, 2, 7]),
           (ARRAY[2, 7, -3, 2, 7], ARRAY[12, 9, 8, 7]);

SELECT c1, c2, array_union(c1, c2)
FROM test_array_union_int;

Résultat :

      c1      |     c2     |   array_union
--------------+------------+-----------------
 \N           | {2,-3,2,7} | {2,7,-3}
 {2,7,-3,2,7} | {12,9,8,7} | {9,2,7,8,12,-3}
(2 rows)

REGEXP_MATCH

regexp_match(str TEXT, pattern TEXT) → ARRAY

Fait correspondre une chaîne à une expression régulière et renvoie un tableau des sous-chaînes capturées.

Paramètres

Exemple

SELECT regexp_match('foobarbequebaz', '(bar)(beque)');

Résultat :

 regexp_match
--------------
 {bar,beque}

REGEXP_SPLIT_TO_ARRAY

regexp_split_to_array(str TEXT, pattern TEXT) → ARRAY

Divise une chaîne selon un délimiteur d'expression régulière et renvoie les parties sous forme de tableau.

Paramètres

Exemple

CREATE TABLE interests_test (
    name text,
    intrests text
);

INSERT INTO interests_test
    VALUES ('Ava', 'singing, dancing'),
           ('Bob', 'playing football, running, painting'),
           ('Jack', 'arranging flowers, writing calligraphy, playing the piano, sleeping');

SELECT name, regexp_split_to_array(intrests, ',')
FROM interests_test;

Résultat :

name | regexp_split_to_array
----------------------------
Ava  | {singing, dancing}
Bob  | {playing football, running, painting}
Jack | {arranging flowers, writing calligraphy, playing the piano, sleeping}