Hologres:Funciones de 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)

Convierte un valor de cualquier tipo a TEXT.

SELECT toString(id) FROM public.tb1;

1234

toInt64(anyelement)

Convierte un valor numérico (distinto de BIGINT) a BIGINT.

SELECT toInt64(id_text) FROM public.tb1;

1234

toInt32(anyelement)

Convierte un valor numérico (distinto de INT) a INT.

SELECT toInt32(id_text) FROM public.tb1;

123

toDate(text)

Convierte un valor TEXT a DATE. La entrada debe tener un formato de fecha válido; de lo contrario, se devuelve un error.

Conversión exitosa:

SELECT toDate(data_date) FROM public.tb1;

2019-01-02

Conversión con errores (formato incompatible):

SELECT toDate(data_text) FROM public.tb1;

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

toFloat64(anyelement)

Convierte un valor numérico (distinto de DOUBLE PRECISION) a DOUBLE PRECISION.

SELECT toFloat64(data_float) FROM public.tb1;

1.23

toYear, toMonth y toQuarter

Extraen el año, mes o trimestre de una marca de tiempo. Utilice extract(field FROM timestamp) o date_part(text, timestamp). Para más detalles, consulte Datetime truncation functions.

Extraer el mes:

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

2

Extraer el trimestre:

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

1

addDays, addMonths y addYears

Añaden un intervalo de tiempo a una fecha o marca de tiempo mediante el operador +.

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

2001-09-28 01:00:00

subtractDays, subtractMonths y subtractYears

Restan un intervalo de tiempo de una fecha o marca de tiempo mediante el operador -.

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

2001-09-27 00:00:00

argMin(x, y)

Devuelve el valor de x correspondiente al valor mínimo de y. Si el valor mínimo de y corresponde a varios valores de x, se devuelve el mínimo de dichos valores de x.

Requiere Hologres V1.3.36 o posterior. Para ver la definición de la tabla de ejemplo, consulte Sample data.

SELECT min_by(name, cost) FROM test;

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

argMax(x, y)

Devuelve el valor de x correspondiente al valor máximo de y. Si el valor máximo de y corresponde a varios valores de x, se devuelve el máximo de dichos valores de x.

Requiere Hologres V1.3.36 o posterior. Para ver la definición de la tabla de ejemplo, consulte Sample data.

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

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

groupArray(anyelement)

Concatena todos los valores de una expresión en un arreglo. Utilice 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 del arreglo en una fila independiente. Utilice unnest(anyarray).

SELECT unnest(ARRAY[1,2]);

1
2

arrayConcat(anyarray, anyarray...)

Concatena arreglos. Utilice array_cat(anyarray, anyarray). Dado que array_cat acepta dos arreglos a la vez, encadene varias llamadas para concatenar más de dos arreglos.

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

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

arrayDistinct(anyarray)

Devuelve un nuevo arreglo sin elementos duplicados. Utilice array_distinct(anyarray).

Requiere Hologres V1.3.19 o posterior. No se pueden usar 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)

Devuelve el valor mínimo de un arreglo. Utilice array_min(anyarray).

Requiere Hologres 1.3.19 o posterior. No se pueden usar 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)

Devuelve el valor máximo de un arreglo. Utilice array_max(anyarray).

Requiere Hologres 1.3.19 o posterior. No se pueden usar 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)

Devuelve la suma de todos los elementos de un arreglo. Utilice unnest para expandir el arreglo en filas y luego aplique sum.

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

7

bitmapToArray(roaringbitmap)

Convierte un mapa de bits Roaring en un arreglo de enteros. Utilice rb_to_array(roaringbitmap).

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

{1,2,3}

groupBitmapState(integer)

Construye un mapa de bits Roaring a partir de un grupo de valores enteros. Utilice rb_build_agg(integer).

SELECT rb_build_agg(1);

\x3a3000000100000000000000100000000100

groupBitmap(integer)

Calcula la cardinalidad de un mapa de bits Roaring construido a partir de un grupo de valores enteros. Utilice rb_cardinality(rb_build_agg(integer)): rb_build_agg primero agrega los valores en un mapa de bits Roaring y luego rb_cardinality cuenta los elementos distintos.

SELECT rb_cardinality(rb_build_agg(1));

1

groupBitmapAndState(roaringbitmap)

Realiza una operación de agregación AND sobre mapas de bits Roaring y devuelve el mapa de bits resultante. Utilice rb_and_agg(roaringbitmap).

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

\x3a300000010000000000020010000000010002000300

groupBitmapOrState(roaringbitmap)

Realiza una operación de agregación OR sobre mapas de bits Roaring y devuelve el mapa de bits resultante. Utilice rb_or_agg(roaringbitmap).

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

\x3a300000010000000000020010000000010002000300

groupBitmapAnd(roaringbitmap)

Realiza una operación de agregación AND sobre mapas de bits Roaring y devuelve la cardinalidad del mapa de bits resultante. Utilice rb_and_cardinality_agg(roaringbitmap).

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

3

groupBitmapOr(roaringbitmap)

Realiza una operación de agregación OR sobre mapas de bits Roaring y devuelve la cardinalidad del mapa de bits resultante. Utilice rb_or_cardinality_agg(roaringbitmap).

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

3

sipHash64(text)

Devuelve un valor SipHash de 64 bits para una entrada de texto. En ClickHouse, el tipo de retorno es UInt64; en Hologres, es BIGINT. Utilice hg_sip_hash_64(text).

Requiere Hologres V2.0.1 o posterior. No se pueden usar 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