Hologres:Array functions

ARRAY_TO_STRING

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

Concatena los elementos del arreglo mediante un separador especificado. El tercer argumento opcional reemplaza los elementos NULL; si se omite, los valores NULL se ignoran.

Parámetros

Ejemplo

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

ARRAY_AGG

array_agg(anyelement) → ARRAY

Agrega valores de columna de varias filas en un solo arreglo. Se admiten dos formas de sintaxis.

Sintaxis 1: Agregación básica

array_agg(anyelement)

Sintaxis 2: Agregación con ordenamiento y filtrado

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

Parámetros

Notas de uso

• Compatible con Hologres V1.3 y versiones posteriores: DECIMAL, DATE, TIMESTAMP, TIMESTAMPTZ.

• No compatible: JSON, JSONB, TIMETZ, INTERVAL, INET, OID, UUID, ARRAY.

• La cláusula FILTER requiere Hologres V1.3 o posterior. Para actualizar su instancia, consulte Instance upgradation o How do I get more online support?.

Ejemplos

Agregación básica:

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;

Resultado:

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

Agregación con FILTER (requiere Hologres V1.3+):

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

Resultado:

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

ARRAY_APPEND

array_append(anyarray, anyelement) → ARRAY

Añade un elemento al final de un arreglo.

Parámetros

Ejemplo

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

ARRAY_CAT

array_cat(anyarray, anyarray) → ARRAY

Concatena dos arreglos del mismo tipo de elemento.

Parámetros

Ejemplo

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

ARRAY_NDIMS

array_ndims(anyarray) → INT

Devuelve el número de dimensiones de un arreglo.

Parámetros

Ejemplo

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

ARRAY_DIMS

array_dims(anyarray) → TEXT

Devuelve los límites de dimensión de un arreglo como una cadena de texto, donde se muestra el límite inferior y superior de cada dimensión.

Parámetros

Ejemplo

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

ARRAY_LENGTH

array_length(anyarray, int) → INT

Devuelve el número de elementos en la dimensión especificada de un arreglo. Las dimensiones se numeran a partir de 1.

Parámetros

Ejemplo

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

ARRAY_LOWER

array_lower(anyarray, int) → INT

Devuelve el límite inferior de la dimensión del arreglo especificada. Para los arreglos estándar, este valor es 1. En el caso de arreglos con un límite inferior personalizado (como '[0:2]={1,2,3}'::int[]), se devuelve el límite inferior real. Las dimensiones se numeran a partir de 1.

Parámetros

Ejemplo

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

ARRAY_POSITIONS

array_positions(anyarray, anyelement) → ARRAY

Devuelve los subíndices de un elemento especificado en un arreglo unidimensional.

Parámetros

Ejemplo

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

ARRAY_PREPEND

array_prepend(anyelement, anyarray) → ARRAY

Agrega un elemento al inicio de un arreglo.

Parámetros

Ejemplo

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

ARRAY_REMOVE

array_remove(anyarray, anyelement) → ARRAY

Elimina todos los elementos iguales al valor especificado de un arreglo unidimensional.

Parámetros

Ejemplo

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

ARRAY_SORT

array_sort(anyarray) → ARRAY

Ordena los elementos de un arreglo en orden ascendente.

Notas de uso

Parámetros

Ejemplo

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

ARRAY_UPPER

array_upper(anyarray, int) → INT

Devuelve el límite superior de la dimensión del arreglo especificada. Para un arreglo estándar de una dimensión, esto equivale al número de elementos. Las dimensiones se numeran a partir de 1.

Parámetros

Ejemplo

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

UNNEST

unnest(anyarray) → setof TEXT

Expande cada elemento de un arreglo en una fila independiente. Utilice esta función en la cláusula FROM o como una función que devuelve conjuntos.

Parámetros

Ejemplo

SELECT unnest(ARRAY[1,2]);

Resultado:

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

ARRAY_MAX

array_max(array) → INT

Devuelve el valor máximo de los elementos en un arreglo. Los valores NULL se omiten durante el cálculo. Requiere Hologres V1.3.19 o posterior.

array_max no admite consultas constantes; utilice una columna de tabla como entrada.

Parámetros

Ejemplo

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;

Resultado:

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

ARRAY_MIN

array_min(array) → INT

Devuelve el valor mínimo de los elementos en un arreglo. Requiere Hologres V1.3.19 o posterior.

array_min no admite consultas constantes; utilice una columna de tabla como entrada.

Parámetros

Ejemplo

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;

Resultado:

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

ARRAY_CONTAINS

array_contains(array, target_value) → BOOLEAN

Comprueba si un arreglo contiene un valor específico. Devuelve true si lo encuentra y false en caso contrario. Requiere Hologres V1.3.19 o posterior.

array_contains no admite consultas constantes; utilice una columna de tabla como entrada.

Parámetros

Ejemplo

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;

Resultado:

            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

Devuelve los elementos de array1 que no están presentes en array2. Requiere Hologres V1.3.19 o posterior.

array_except no admite consultas constantes; utilice columnas de tabla como entrada.

Parámetros

Ejemplo

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;

Resultado:

                 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

Elimina los elementos duplicados de un arreglo. Requiere Hologres V1.3.19 o posterior.

array_distinct no admite consultas constantes; utilice una columna de tabla como entrada.

Parámetros

Ejemplo

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;

Resultado:

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

ARRAY_UNION

array_union(array1, array2) → ARRAY

Combina dos arreglos en uno nuevo y elimina los elementos duplicados. Requiere Hologres V1.3.19 o posterior.

array_union no admite consultas constantes; utilice columnas de tabla como entrada.

Parámetros

Ejemplo

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;

Resultado:

      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

Compara una cadena con una expresión regular y devuelve un arreglo con las subcadenas capturadas.

Parámetros

Ejemplo

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

Resultado:

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

REGEXP_SPLIT_TO_ARRAY

regexp_split_to_array(str TEXT, pattern TEXT) → ARRAY

Divide una cadena mediante un delimitador de expresión regular y devuelve las partes como un arreglo.

Parámetros

Ejemplo

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;

Resultado:

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