Hologres:Funções de array

ARRAY_TO_STRING

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

Concatena elementos do array usando um separador especificado. O terceiro argumento opcional substitui elementos NULL; se omitido, os NULLs serão ignorados.

Parâmetros

Exemplo

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

ARRAY_AGG

array_agg(anyelement) → ARRAY

Agrega valores de coluna de várias linhas em um único array. Há duas formas de sintaxe com suporte.

Sintaxe 1: Agregação básica

array_agg(anyelement)

Sintaxe 2: Agregação com ordenação e filtragem

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

Parâmetros

Notas de uso

• Tipos com suporte no Hologres V1.3 e versões posteriores: DECIMAL, DATE, TIMESTAMP, TIMESTAMPTZ.

• Tipos sem suporte: JSON, JSONB, TIMETZ, INTERVAL, INET, OID, UUID, ARRAY.

• A cláusula FILTER requer Hologres V1.3 ou superior. Para atualizar sua instância, consulte Atualização de instância ou Como obter mais suporte online?.

Exemplos

Agregação 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)

Agregação com FILTER (requer 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

Adiciona um elemento ao final de um array.

Parâmetros

Exemplo

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

ARRAY_CAT

array_cat(anyarray, anyarray) → ARRAY

Concatena dois arrays do mesmo tipo de elemento.

Parâmetros

Exemplo

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

ARRAY_NDIMS

array_ndims(anyarray) → INT

Retorna o número de dimensões de um array.

Parâmetros

Exemplo

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

ARRAY_DIMS

array_dims(anyarray) → TEXT

Retorna os limites de dimensão de um array como string de texto, exibindo o limite inferior e superior de cada dimensão.

Parâmetros

Exemplo

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

ARRAY_LENGTH

array_length(anyarray, int) → INT

Retorna o número de elementos na dimensão especificada de um array. As dimensões são numeradas a partir de 1.

Parâmetros

Exemplo

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

ARRAY_LOWER

array_lower(anyarray, int) → INT

Retorna o limite inferior da dimensão especificada do array. Para arrays padrão, esse valor é 1. Para arrays com limite inferior personalizado (como '[0:2]={1,2,3}'::int[]), o limite inferior real é retornado. As dimensões são numeradas a partir de 1.

Parâmetros

Exemplo

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

ARRAY_POSITIONS

array_positions(anyarray, anyelement) → ARRAY

Retorna os índices de um elemento especificado em um array unidimensional.

Parâmetros

Exemplo

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

ARRAY_PREPEND

array_prepend(anyelement, anyarray) → ARRAY

Insere um elemento no início de um array.

Parâmetros

Exemplo

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

ARRAY_REMOVE

array_remove(anyarray, anyelement) → ARRAY

Remove todos os elementos iguais ao valor especificado de um array unidimensional.

Parâmetros

Exemplo

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

ARRAY_SORT

array_sort(anyarray) → ARRAY

Ordena os elementos de um array em ordem crescente.

Notas de uso

Parâmetros

Exemplo

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

ARRAY_UPPER

array_upper(anyarray, int) → INT

Retorna o limite superior da dimensão especificada do array. Para um array unidimensional padrão, isso equivale ao número de elementos. As dimensões são numeradas a partir de 1.

Parâmetros

Exemplo

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

UNNEST

unnest(anyarray) → setof TEXT

Expande cada elemento de um array em uma linha separada. Utilize esta função na cláusula FROM ou como função que retorna conjuntos.

Parâmetros

Exemplo

SELECT unnest(ARRAY[1,2]);

Resultado:

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

ARRAY_MAX

array_max(array) → INT

Retorna o valor máximo do elemento em um array. Valores NULL são ignorados durante o cálculo. Requer Hologres V1.3.19 ou posterior.

array_max não aceita consultas com constantes; utilize uma coluna de tabela como entrada.

Parâmetros

Exemplo

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

Retorna o valor mínimo do elemento em um array. Requer Hologres V1.3.19 ou posterior.

array_min não aceita consultas com constantes; utilize uma coluna de tabela como entrada.

Parâmetros

Exemplo

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

Verifica se um array contém um valor especificado. Retorna true se encontrado, false caso contrário. Requer Hologres V1.3.19 ou posterior.

array_contains não aceita consultas com constantes; utilize uma coluna de tabela como entrada.

Parâmetros

Exemplo

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

Retorna os elementos presentes em array1 que não existem em array2. Requer Hologres V1.3.19 ou posterior.

array_except não aceita consultas com constantes; utilize colunas de tabela como entrada.

Parâmetros

Exemplo

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

Remove elementos duplicados de um array. Requer Hologres V1.3.19 ou posterior.

array_distinct não aceita consultas com constantes; utilize uma coluna de tabela como entrada.

Parâmetros

Exemplo

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

Mescla dois arrays em um novo array e remove elementos duplicados. Requer Hologres V1.3.19 ou posterior.

array_union não aceita consultas com constantes; utilize colunas de tabela como entrada.

Parâmetros

Exemplo

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 uma string com uma expressão regular e retorna um array de substrings capturadas.

Parâmetros

Exemplo

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 uma string por um delimitador de expressão regular e retorna as partes como um array.

Parâmetros

Exemplo

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}