Hologres:Funções do ClickHouse

CREATE TABLE public.tb1 (
  id bigint NOT NULL,
  id_text text,
  data_date text,
  data_float text,
  data_text text
);
INSERT INTO public.tb1 VALUES (1234,'123','20190102','1.23','hologres');

toString(anyelement)

Converte um valor de qualquer tipo para TEXT.

SELECT toString(id) FROM public.tb1;

1234

toInt64(anyelement)

Converte um valor numérico (exceto BIGINT) para BIGINT.

SELECT toInt64(id_text) FROM public.tb1;

1234

toInt32(anyelement)

Converte um valor numérico (exceto INT) para INT.

SELECT toInt32(id_text) FROM public.tb1;

123

toDate(text)

Converte um valor TEXT para DATE. A entrada deve estar em um formato de data válido; caso contrário, ocorre um erro.

Conversão bem-sucedida:

SELECT toDate(data_date) FROM public.tb1;

2019-01-02

Falha na conversão (formato incompatível):

SELECT toDate(data_text) FROM public.tb1;

ERROR: *** invalid input syntax for type date ***

toFloat64(anyelement)

Converte um valor numérico (exceto DOUBLE PRECISION) para DOUBLE PRECISION.

SELECT toFloat64(data_float) FROM public.tb1;

1.23

toYear, toMonth e toQuarter

Extraem o ano, mês ou trimestre de um timestamp. Use extract(field FROM timestamp) ou date_part(text, timestamp). Para mais detalhes, veja Funções de truncamento de data e hora.

Extrair o mês:

SELECT extract(month FROM timestamp '2001-02-16 20:38:40');

2

Extrair o trimestre:

SELECT extract(quarter FROM timestamp '2001-02-16 20:38:40');

1

addDays, addMonths e addYears

Adicionam um intervalo de tempo a uma data ou timestamp por meio do operador +.

SELECT date '2001-09-28' + interval '1 hour';

2001-09-28 01:00:00

subtractDays, subtractMonths e subtractYears

Subtraem um intervalo de tempo de uma data ou timestamp usando o operador -.

SELECT date '2001-09-28' - interval '1 day';

2001-09-27 00:00:00

argMin(x, y)

Retorna o valor de x correspondente ao valor mínimo de y. Se o valor mínimo de y estiver associado a múltiplos valores de x, a função retorna o menor entre esses valores de x.

Requer Hologres V1.3.36 ou superior. Para a definição da tabela de exemplo, consulte Dados de exemplo.

SELECT min_by(name, cost) FROM test;

 min_by
--------
 cc
(1 row)

argMax(x, y)

Retorna o valor de x associado ao valor máximo de y. Quando o valor máximo de y corresponde a vários valores de x, a função retorna o maior desses valores de x.

Requer Hologres V1.3.36 ou posterior. A definição da tabela de exemplo está disponível em Dados de exemplo.

SELECT id, max_by(name, cost) FROM test GROUP BY id;

 id | max_by
----+--------
  2 | bb
  1 | aaa
  3 | c
(3 rows)

groupArray(anyelement)

Agrupa todos os valores de uma expressão em um array. Use array_agg(anyelement).

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;

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

arrayJoin(anyarray)

Expande cada elemento do array em uma linha separada. Use unnest(anyarray).

SELECT unnest(ARRAY[1,2]);

1
2

arrayConcat(anyarray, anyarray...)

Concatena arrays mediante a função array_cat(anyarray, anyarray). Como array_cat aceita apenas dois arrays por vez, encadeie várias chamadas para concatenar mais de dois arrays.

SELECT array_cat(array_cat(ARRAY[1,2], ARRAY[3,4]), ARRAY[5,6]);

{1,2,3,4,5,6}

arrayDistinct(anyarray)

Gera um novo array sem elementos duplicados. Use array_distinct(anyarray).

Requer Hologres V1.3.19 ou versão mais recente. Não use constantes como parâmetros de entrada.

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;

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

arrayMin(anyarray)

Retorna o menor valor presente em um array. Use array_min(anyarray).

Requer Hologres 1.3.19 ou posterior. Não use constantes como parâmetros de entrada.

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;

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

arrayMax(anyarray)

Retorna o maior valor contido em um array. Use array_max(anyarray).

Requer Hologres 1.3.19 ou superior. Não use constantes como parâmetros de entrada.

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;

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

arraySum(anyarray)

Calcula a soma de todos os elementos de um array. Expanda o array em linhas com unnest e aplique sum em seguida.

SELECT sum(ele) FROM (SELECT unnest(ARRAY[1,2,4]) AS ele) a;

7

bitmapToArray(roaringbitmap)

Converte um Roaring bitmap em um array de inteiros. Use rb_to_array(roaringbitmap).

SELECT rb_to_array(rb_build('{1,2,3}'));

{1,2,3}

groupBitmapState(integer)

Crie um Roaring bitmap a partir de um grupo de valores inteiros. Use rb_build_agg(integer).

SELECT rb_build_agg(1);

\x3a3000000100000000000000100000000100

groupBitmap(integer)

Determina a cardinalidade de um Roaring bitmap construído com base em um conjunto de valores inteiros. Combine rb_cardinality(rb_build_agg(integer)): primeiro rb_build_agg agrega os valores em um Roaring bitmap e depois rb_cardinality conta os elementos distintos.

SELECT rb_cardinality(rb_build_agg(1));

1

groupBitmapAndState(roaringbitmap)

Executa uma operação de agregação AND entre Roaring bitmaps e retorna o bitmap resultante. Use rb_and_agg(roaringbitmap).

SELECT rb_and_agg(rb_build('{1,2,3}'));

\x3a300000010000000000020010000000010002000300

groupBitmapOrState(roaringbitmap)

Realiza uma agregação OR sobre Roaring bitmaps e retorna o bitmap final. Use rb_or_agg(roaringbitmap).

SELECT rb_or_agg(rb_build('{1,2,3}'));

\x3a300000010000000000020010000000010002000300

groupBitmapAnd(roaringbitmap)

Efetua uma operação de agregação AND entre Roaring bitmaps e retorna a cardinalidade do resultado. Use rb_and_cardinality_agg(roaringbitmap).

SELECT rb_and_cardinality_agg(rb_build('{1,2,3}'));

3

groupBitmapOr(roaringbitmap)

Aplica uma agregação OR aos Roaring bitmaps e retorna a cardinalidade do bitmap gerado. Use rb_or_cardinality_agg(roaringbitmap).

SELECT rb_or_cardinality_agg(rb_build('{1,2,3}'));

3

sipHash64(text)

Retorna um valor SipHash de 64 bits para uma entrada de texto. No ClickHouse, o tipo de retorno é UInt64; no Hologres, é BIGINT. Use hg_sip_hash_64(text).

Requer Hologres V2.0.1 ou posterior. Não use constantes como parâmetros de entrada.

CREATE TABLE test_hg_sip_hash_64_text (c1 text);
INSERT INTO test_hg_sip_hash_64_text VALUES ('abc');

SELECT hg_sip_hash_64(c1) FROM test_hg_sip_hash_64_text;

4596069200710135518