Předdefinované funkce

Agregační funkce

Funkce Description
Any (výraz) Vrátí hodnotu true, pokud alespoň jedna hodnota expr má hodnotu true.
approx_count_distinct (výraz [, příbuzní]) Vrátí odhadovanou mohutnost podle HyperLogLog + +. relativeSD definuje maximální povolenou chybu odhadu.
approx_percentile (sloupec, procento [, přesnost]) Vrátí přibližnou hodnotu percentilu číselného sloupce col v daném procentu. Hodnota procenta musí být v rozmezí od 0,0 do 1,0. accuracyParametr (default: 10000) je kladný numerický literál, který ovládá přesnost sbližování za cenu paměti. Vyšší hodnota accuracy má lepší přesnost, 1.0/accuracy je relativní chyba aproximace. Když percentage je pole, každá hodnota pole PERCENTAGE musí být mezi 0,0 a 1,0. V tomto případě vrátí pole přibližného percentilu sloupce col v daném procentuálním poli.
Prům (výraz) Vrátí průměr počítaný z hodnot skupiny.
bit_or (výraz) Vrátí bitové nebo všechny vstupní hodnoty, které nejsou null, nebo hodnotu null, pokud žádný není.
bit_xor (výraz) Vrátí logickou XOR pro všechny vstupní hodnoty, které nejsou null, nebo hodnotu null, pokud žádný není.
bool_and (výraz) Vrátí hodnotu true, pokud jsou všechny hodnoty expr true.
bool_or (výraz) Vrátí hodnotu true, pokud alespoň jedna hodnota expr má hodnotu true.
collect_list (výraz) Shromažďuje a vrací seznam nejedinečných prvků.
collect_set (výraz) Shromažďuje a vrací sadu jedinečných prvků.
korespondenční (Výraz1, Výraz2) Vrátí koeficient Pearsonova korelace mezi sadou párů čísel.
počet (*) Vrátí celkový počet načtených řádků, včetně řádků obsahujících hodnoty null.
Count (Expr [; expr...]) Vrátí počet řádků, pro které jsou zadané výrazy všechny, které nejsou null.
Count (DISTINCT výraz [, expr...]) Vrátí počet řádků, pro které jsou zadané výrazy jedinečné a které nejsou null.
count_if (výraz) Vrátí počet TRUE hodnot výrazu.
count_min_sketch (sloupec, EPS, důvěra, semena) Vrátí náčrt sloupce Count-min se zadaným protokolem ESP, jistotou a osivem. Výsledkem je pole bajtů, které lze deserializovat na CountMinSketch před využitím. Počet – minimální náčrt je pravděpodobnostní datová struktura, která se používá pro odhad mohutnosti pomocí dílčího lineárního prostoru.
covar_pop (Výraz1, Výraz2) Vrátí kovarianci populace množiny číselných párů.
covar_samp (Výraz1, Výraz2) Vrátí koodchylku sady číselných párů.
Každý (výraz) Vrátí hodnotu true, pokud jsou všechny hodnoty expr true.
First (Expr [; isIgnoreNull]) Vrátí první hodnotu expr pro skupinu řádků. Pokud isIgnoreNull má hodnotu true, vrátí pouze hodnoty, které nejsou null.
first_value (Expr [; isIgnoreNull]) Vrátí první hodnotu expr pro skupinu řádků. Pokud isIgnoreNull má hodnotu true, vrátí pouze hodnoty, které nejsou null.
špičatost (výraz) Vrátí hodnotu fluktuace vypočítanou z hodnot skupiny.
Last (výraz [; isIgnoreNull]) Vrátí poslední hodnotu expr pro skupinu řádků. Pokud isIgnoreNull má hodnotu true, vrátí pouze hodnoty, které nejsou null.
last_value (Expr [; isIgnoreNull]) Vrátí poslední hodnotu expr pro skupinu řádků. Pokud isIgnoreNull má hodnotu true, vrátí pouze hodnoty, které nejsou null.
Max (výraz) Vrátí maximální hodnotu expr .
max_by (x, y) Vrátí hodnotu x přidruženou k maximální hodnotě y .
střed_hodn (výraz) Vrátí průměr počítaný z hodnot skupiny.
min (výraz) Vrátí minimální hodnotu expr .
min_by (x, y) Vrátí hodnotu x přidruženou k minimální hodnotě y .
percentil (sloupec;, procenta [, frekvence]) Vrátí přesnou hodnotu percentilu číselného sloupce s col daným procentem. Hodnota procenta musí být v rozmezí od 0,0 do 1,0. Hodnota frekvence by měla být kladný integrál.
percentil (sloupec; pole (percentage1 [; percentage2]...) [, frekvence]) Vrátí přesné pole hodnoty percentilu číselného sloupce s col danými procenty. Každá hodnota pole procento musí být v rozmezí od 0,0 do 1,0. Hodnota frekvence by měla být kladný integrál.
percentile_approx (sloupec, procento [, přesnost]) Vrátí přibližnou hodnotu percentilu číselného sloupce col v daném procentu. Hodnota procenta musí být v rozmezí od 0,0 do 1,0. accuracyParametr (default: 10000) je kladný numerický literál, který ovládá přesnost sbližování za cenu paměti. Vyšší hodnota accuracy má lepší přesnost, 1.0/accuracy je relativní chyba aproximace. Když percentage je pole, každá hodnota pole PERCENTAGE musí být mezi 0,0 a 1,0. V tomto případě vrátí pole přibližného percentilu sloupce col v daném procentuálním poli.
asymetrie (výraz) Vrátí hodnotu asymetrie vypočítanou z hodnot skupiny.
nějaké (výraz) Vrátí hodnotu true, pokud alespoň jedna hodnota expr má hodnotu true.
STD (výraz) Vrátí směrodatnou odchylku vzorku vypočítanou z hodnot skupiny.
StdDev (výraz) Vrátí směrodatnou odchylku vzorku vypočítanou z hodnot skupiny.
stddev_pop (výraz) Vrátí směrodatnou odchylku základního souboru vypočítanou z hodnot skupiny.
stddev_samp (výraz) Vrátí směrodatnou odchylku vzorku vypočítanou z hodnot skupiny.
Sum (výraz) Vrátí součet vypočítaný z hodnot skupiny.
var_pop (výraz) Vrátí odchylku základního souboru vypočítanou z hodnot skupiny.
var_samp (výraz) Vrátí odchylku vzorku vypočítanou z hodnot skupiny.
Variance (výraz) Vrátí odchylku vzorku vypočítanou z hodnot skupiny.

Příklady

-- any
SELECT any(col) FROM VALUES (true), (false), (false) AS tab(col);
+--------+
|any(col)|
+--------+
|    true|
+--------+

SELECT any(col) FROM VALUES (NULL), (true), (false) AS tab(col);
+--------+
|any(col)|
+--------+
|    true|
+--------+

SELECT any(col) FROM VALUES (false), (false), (NULL) AS tab(col);
+--------+
|any(col)|
+--------+
|   false|
+--------+

-- approx_count_distinct
SELECT approx_count_distinct(col1) FROM VALUES (1), (1), (2), (2), (3) tab(col1);
+---------------------------+
|approx_count_distinct(col1)|
+---------------------------+
|                          3|
+---------------------------+

-- approx_percentile
SELECT approx_percentile(10.0, array(0.5, 0.4, 0.1), 100);
+--------------------------------------------------+
|approx_percentile(10.0, array(0.5, 0.4, 0.1), 100)|
+--------------------------------------------------+
|                                [10.0, 10.0, 10.0]|
+--------------------------------------------------+

SELECT approx_percentile(10.0, 0.5, 100);
+-------------------------------------------------+
|approx_percentile(10.0, CAST(0.5 AS DOUBLE), 100)|
+-------------------------------------------------+
|                                             10.0|
+-------------------------------------------------+

-- avg
SELECT avg(col) FROM VALUES (1), (2), (3) AS tab(col);
+--------+
|avg(col)|
+--------+
|     2.0|
+--------+

SELECT avg(col) FROM VALUES (1), (2), (NULL) AS tab(col);
+--------+
|avg(col)|
+--------+
|     1.5|
+--------+

-- bit_or
SELECT bit_or(col) FROM VALUES (3), (5) AS tab(col);
+-----------+
|bit_or(col)|
+-----------+
|          7|
+-----------+

-- bit_xor
SELECT bit_xor(col) FROM VALUES (3), (5) AS tab(col);
+------------+
|bit_xor(col)|
+------------+
|           6|
+------------+

-- bool_and
SELECT bool_and(col) FROM VALUES (true), (true), (true) AS tab(col);
+-------------+
|bool_and(col)|
+-------------+
|         true|
+-------------+

SELECT bool_and(col) FROM VALUES (NULL), (true), (true) AS tab(col);
+-------------+
|bool_and(col)|
+-------------+
|         true|
+-------------+

SELECT bool_and(col) FROM VALUES (true), (false), (true) AS tab(col);
+-------------+
|bool_and(col)|
+-------------+
|        false|
+-------------+

-- bool_or
SELECT bool_or(col) FROM VALUES (true), (false), (false) AS tab(col);
+------------+
|bool_or(col)|
+------------+
|        true|
+------------+

SELECT bool_or(col) FROM VALUES (NULL), (true), (false) AS tab(col);
+------------+
|bool_or(col)|
+------------+
|        true|
+------------+

SELECT bool_or(col) FROM VALUES (false), (false), (NULL) AS tab(col);
+------------+
|bool_or(col)|
+------------+
|       false|
+------------+

-- collect_list
SELECT collect_list(col) FROM VALUES (1), (2), (1) AS tab(col);
+-----------------+
|collect_list(col)|
+-----------------+
|        [1, 2, 1]|
+-----------------+

-- collect_set
SELECT collect_set(col) FROM VALUES (1), (2), (1) AS tab(col);
+----------------+
|collect_set(col)|
+----------------+
|          [1, 2]|
+----------------+

-- corr
SELECT corr(c1, c2) FROM VALUES (3, 2), (3, 3), (6, 4) as tab(c1, c2);
+--------------------------------------------+
|corr(CAST(c1 AS DOUBLE), CAST(c2 AS DOUBLE))|
+--------------------------------------------+
|                          0.8660254037844387|
+--------------------------------------------+

-- count
SELECT count(*) FROM VALUES (NULL), (5), (5), (20) AS tab(col);
+--------+
|count(1)|
+--------+
|       4|
+--------+

SELECT count(col) FROM VALUES (NULL), (5), (5), (20) AS tab(col);
+----------+
|count(col)|
+----------+
|         3|
+----------+

SELECT count(DISTINCT col) FROM VALUES (NULL), (5), (5), (10) AS tab(col);
+-------------------+
|count(DISTINCT col)|
+-------------------+
|                  2|
+-------------------+

-- count_if
SELECT count_if(col % 2 = 0) FROM VALUES (NULL), (0), (1), (2), (3) AS tab(col);
+-------------------------+
|count_if(((col % 2) = 0))|
+-------------------------+
|                        2|
+-------------------------+

SELECT count_if(col IS NULL) FROM VALUES (NULL), (0), (1), (2), (3) AS tab(col);
+-----------------------+
|count_if((col IS NULL))|
+-----------------------+
|                      1|
+-----------------------+

-- covar_pop
SELECT covar_pop(c1, c2) FROM VALUES (1,1), (2,2), (3,3) AS tab(c1, c2);
+-------------------------------------------------+
|covar_pop(CAST(c1 AS DOUBLE), CAST(c2 AS DOUBLE))|
+-------------------------------------------------+
|                               0.6666666666666666|
+-------------------------------------------------+

-- covar_samp
SELECT covar_samp(c1, c2) FROM VALUES (1,1), (2,2), (3,3) AS tab(c1, c2);
+--------------------------------------------------+
|covar_samp(CAST(c1 AS DOUBLE), CAST(c2 AS DOUBLE))|
+--------------------------------------------------+
|                                               1.0|
+--------------------------------------------------+

-- every
SELECT every(col) FROM VALUES (true), (true), (true) AS tab(col);
+----------+
|every(col)|
+----------+
|      true|
+----------+

SELECT every(col) FROM VALUES (NULL), (true), (true) AS tab(col);
+----------+
|every(col)|
+----------+
|      true|
+----------+

SELECT every(col) FROM VALUES (true), (false), (true) AS tab(col);
+----------+
|every(col)|
+----------+
|     false|
+----------+

-- first
SELECT first(col) FROM VALUES (10), (5), (20) AS tab(col);
+-----------------+
|first(col, false)|
+-----------------+
|               10|
+-----------------+

SELECT first(col) FROM VALUES (NULL), (5), (20) AS tab(col);
+-----------------+
|first(col, false)|
+-----------------+
|             null|
+-----------------+

SELECT first(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);
+----------------+
|first(col, true)|
+----------------+
|               5|
+----------------+

-- first_value
SELECT first_value(col) FROM VALUES (10), (5), (20) AS tab(col);
+-----------------------+
|first_value(col, false)|
+-----------------------+
|                     10|
+-----------------------+

SELECT first_value(col) FROM VALUES (NULL), (5), (20) AS tab(col);
+-----------------------+
|first_value(col, false)|
+-----------------------+
|                   null|
+-----------------------+

SELECT first_value(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);
+----------------------+
|first_value(col, true)|
+----------------------+
|                     5|
+----------------------+

-- kurtosis
SELECT kurtosis(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
+-----------------------------+
|kurtosis(CAST(col AS DOUBLE))|
+-----------------------------+
|          -0.7014368047529618|
+-----------------------------+

SELECT kurtosis(col) FROM VALUES (1), (10), (100), (10), (1) as tab(col);
+-----------------------------+
|kurtosis(CAST(col AS DOUBLE))|
+-----------------------------+
|          0.19432323191698986|
+-----------------------------+

-- last
SELECT last(col) FROM VALUES (10), (5), (20) AS tab(col);
+----------------+
|last(col, false)|
+----------------+
|              20|
+----------------+

SELECT last(col) FROM VALUES (10), (5), (NULL) AS tab(col);
+----------------+
|last(col, false)|
+----------------+
|            null|
+----------------+

SELECT last(col, true) FROM VALUES (10), (5), (NULL) AS tab(col);
+---------------+
|last(col, true)|
+---------------+
|              5|
+---------------+

-- last_value
SELECT last_value(col) FROM VALUES (10), (5), (20) AS tab(col);
+----------------------+
|last_value(col, false)|
+----------------------+
|                    20|
+----------------------+

SELECT last_value(col) FROM VALUES (10), (5), (NULL) AS tab(col);
+----------------------+
|last_value(col, false)|
+----------------------+
|                  null|
+----------------------+

SELECT last_value(col, true) FROM VALUES (10), (5), (NULL) AS tab(col);
+---------------------+
|last_value(col, true)|
+---------------------+
|                    5|
+---------------------+

-- max
SELECT max(col) FROM VALUES (10), (50), (20) AS tab(col);
+--------+
|max(col)|
+--------+
|      50|
+--------+

-- max_by
SELECT max_by(x, y) FROM VALUES (('a', 10)), (('b', 50)), (('c', 20)) AS tab(x, y);
+------------+
|max_by(x, y)|
+------------+
|           b|
+------------+

-- mean
SELECT mean(col) FROM VALUES (1), (2), (3) AS tab(col);
+---------+
|mean(col)|
+---------+
|      2.0|
+---------+

SELECT mean(col) FROM VALUES (1), (2), (NULL) AS tab(col);
+---------+
|mean(col)|
+---------+
|      1.5|
+---------+

-- min
SELECT min(col) FROM VALUES (10), (-1), (20) AS tab(col);
+--------+
|min(col)|
+--------+
|      -1|
+--------+

-- min_by
SELECT min_by(x, y) FROM VALUES (('a', 10)), (('b', 50)), (('c', 20)) AS tab(x, y);
+------------+
|min_by(x, y)|
+------------+
|           a|
+------------+

-- percentile
SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);
+---------------------------------------+
|percentile(col, CAST(0.3 AS DOUBLE), 1)|
+---------------------------------------+
|                                    3.0|
+---------------------------------------+

SELECT percentile(col, array(0.25, 0.75)) FROM VALUES (0), (10) AS tab(col);
+-------------------------------------+
|percentile(col, array(0.25, 0.75), 1)|
+-------------------------------------+
|                           [2.5, 7.5]|
+-------------------------------------+

-- percentile_approx
SELECT percentile_approx(10.0, array(0.5, 0.4, 0.1), 100);
+--------------------------------------------------+
|percentile_approx(10.0, array(0.5, 0.4, 0.1), 100)|
+--------------------------------------------------+
|                                [10.0, 10.0, 10.0]|
+--------------------------------------------------+

SELECT percentile_approx(10.0, 0.5, 100);
+-------------------------------------------------+
|percentile_approx(10.0, CAST(0.5 AS DOUBLE), 100)|
+-------------------------------------------------+
|                                             10.0|
+-------------------------------------------------+

-- skewness
SELECT skewness(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
+-----------------------------+
|skewness(CAST(col AS DOUBLE))|
+-----------------------------+
|           1.1135657469022013|
+-----------------------------+

SELECT skewness(col) FROM VALUES (-1000), (-100), (10), (20) AS tab(col);
+-----------------------------+
|skewness(CAST(col AS DOUBLE))|
+-----------------------------+
|          -1.1135657469022011|
+-----------------------------+

-- some
SELECT some(col) FROM VALUES (true), (false), (false) AS tab(col);
+---------+
|some(col)|
+---------+
|     true|
+---------+

SELECT some(col) FROM VALUES (NULL), (true), (false) AS tab(col);
+---------+
|some(col)|
+---------+
|     true|
+---------+

SELECT some(col) FROM VALUES (false), (false), (NULL) AS tab(col);
+---------+
|some(col)|
+---------+
|    false|
+---------+

-- std
SELECT std(col) FROM VALUES (1), (2), (3) AS tab(col);
+------------------------+
|std(CAST(col AS DOUBLE))|
+------------------------+
|                     1.0|
+------------------------+

-- stddev
SELECT stddev(col) FROM VALUES (1), (2), (3) AS tab(col);
+---------------------------+
|stddev(CAST(col AS DOUBLE))|
+---------------------------+
|                        1.0|
+---------------------------+

-- stddev_pop
SELECT stddev_pop(col) FROM VALUES (1), (2), (3) AS tab(col);
+-------------------------------+
|stddev_pop(CAST(col AS DOUBLE))|
+-------------------------------+
|              0.816496580927726|
+-------------------------------+

-- stddev_samp
SELECT stddev_samp(col) FROM VALUES (1), (2), (3) AS tab(col);
+--------------------------------+
|stddev_samp(CAST(col AS DOUBLE))|
+--------------------------------+
|                             1.0|
+--------------------------------+

-- sum
SELECT sum(col) FROM VALUES (5), (10), (15) AS tab(col);
+--------+
|sum(col)|
+--------+
|      30|
+--------+

SELECT sum(col) FROM VALUES (NULL), (10), (15) AS tab(col);
+--------+
|sum(col)|
+--------+
|      25|
+--------+

SELECT sum(col) FROM VALUES (NULL), (NULL) AS tab(col);
+--------+
|sum(col)|
+--------+
|    null|
+--------+

-- var_pop
SELECT var_pop(col) FROM VALUES (1), (2), (3) AS tab(col);
+----------------------------+
|var_pop(CAST(col AS DOUBLE))|
+----------------------------+
|          0.6666666666666666|
+----------------------------+

-- var_samp
SELECT var_samp(col) FROM VALUES (1), (2), (3) AS tab(col);
+-----------------------------+
|var_samp(CAST(col AS DOUBLE))|
+-----------------------------+
|                          1.0|
+-----------------------------+

-- variance
SELECT variance(col) FROM VALUES (1), (2), (3) AS tab(col);
+-----------------------------+
|variance(CAST(col AS DOUBLE))|
+-----------------------------+
|                          1.0|
+-----------------------------+

Funkce okna

Funkce Description
cume_dist () Vypočítá pozici hodnoty relativní ke všem hodnotám v oddílu.
dense_rank () Vypočítá pořadí hodnoty ve skupině hodnot. Výsledkem je jedna plus dříve přiřazená hodnota pořadí. Na rozdíl od pořadí funkcí dense_rank nevytvoří mezery v pořadí řazení.
Lag (vstup [, posun [, výchozí]]) Vrátí hodnotu input na offset řádku th před aktuální řádek v okně. Výchozí hodnota offset je 1 a výchozí hodnota default je null. Pokud hodnota input na offset řádku th má hodnotu null, je vrácena hodnota null. Pokud žádný takový posunový řádek neexistuje (např. Pokud je posun 1, první řádek okna neobsahuje žádný předchozí řádek), default bude vrácen.
Olovo (Input [; offset [; default]]) Vrátí hodnotu input na offset řádku th po aktuálním řádku v okně. Výchozí hodnota offset je 1 a výchozí hodnota default je null. Pokud hodnota input na offset řádku th má hodnotu null, je vrácena hodnota null. Pokud neexistuje žádný takový posunový řádek (např. Pokud je posun 1, poslední řádek okna neobsahuje žádný další řádek), default je vrácen.
NTILE (n) Vydělí řádky pro každý oddíl okna do n intervalů v rozsahu od 1 do nejvýše n .
percent_rank () Vypočítá procento řazení hodnoty ve skupině hodnot.
Rank () Vypočítá pořadí hodnoty ve skupině hodnot. Výsledkem je jedna hodnota plus počet řádků předcházejících nebo rovných aktuálnímu řádku v pořadí oddílu. Hodnoty budou v posloupnosti vydávat mezery.
row_number() Přiřadí jedinečné pořadové číslo každému řádku počínaje jedním, podle pořadí řádků v rámci oddílu okna.

Funkce pro práci s poli

Funkce Description
array_contains (pole, hodnota) Vrátí hodnotu true, pokud pole obsahuje hodnotu.
array_distinct (pole) Odstraní z pole duplicitní hodnoty.
array_except (pole1, pole2) Vrátí pole prvků v pole1, ale ne v poli pole2 bez duplicitních hodnot.
array_intersect (pole1, pole2) Vrátí pole prvků v průsečíku pole1 a pole2 bez duplicitních hodnot.
array_join (Array; oddělovač [; nullReplacement]) Zřetězí prvky daného pole pomocí oddělovače a volitelného řetězce, který nahradí hodnoty null. Pokud není nastavená žádná hodnota pro nullReplacement, vyfiltruje se jakákoli hodnota null.
array_max (pole) Vrátí maximální hodnotu v poli. Prvky s hodnotou NULL jsou vynechány.
array_min (pole) Vrátí minimální hodnotu v poli. Prvky s hodnotou NULL jsou vynechány.
array_position (pole, element) Vrátí index (založený na 1) prvního prvku pole jako Long.
array_remove (pole, element) Odebere všechny prvky, které se rovnají elementu z pole Array.
array_repeat (element, Count) Vrátí pole obsahující časy počtu prvků.
array_union (pole1, pole2) Vrátí pole prvků sjednocení pole1 a pole2 bez duplicitních hodnot.
arrays_overlap (a1, a2) Vrátí hodnotu true, pokud a1 obsahuje alespoň prvek, který není null, který je přítomný také v buňce a2. Pokud pole nemají žádný společný prvek a jsou v něm neprázdné a některé z nich obsahují prázdný element null, v opačném případě false.
arrays_zip (a1, a2,...) Vrátí sloučené pole struktur, ve kterých N-tou struktura obsahuje všechny N-tém hodnoty vstupních polí.
Concat (Sloupec1; col2,..., colN) Vrací zřetězení ve sloupci Sloupec1, col2,..., colN.
sloučit (arrayOfArrays) Transformuje pole polí do jednoho pole.
Reverse (pole) Vrátí obrácený řetězec nebo pole s obráceným pořadím prvků.
sekvence (spuštění, zastavení, krok) Generuje pole prvků od začátku do zastavení (včetně), které se zvyšuje podle kroku. Typ vrácených prvků je stejný jako typ výrazů argumentů. Podporované typy jsou: Byte, Short, Integer, Long, datum, časové razítko. Výrazy Start a stop se musí přeložit na stejný typ. Pokud jsou výrazy Start a stop přeloženy na typ Date nebo timestamp, musí být výraz kroku přeložen na typ interval, jinak na stejný typ jako výrazy Start a stop.
náhodně (pole) Vrátí náhodnou permutaci daného pole.
řez (x, začátek, délka) Pole podmnožiny x počínaje počátkem indexu (indexy pole začínají na 1 nebo od konce, pokud je počátek záporné) se zadanou délkou.
sort_array (Array [; ascendingOrder]) Seřadí vstupní pole ve vzestupném nebo sestupném pořadí podle přirozeného řazení prvků pole. Prvky null jsou umístěny na začátku vráceného pole ve vzestupném pořadí nebo na konci vráceného pole v sestupném pořadí.

Příklady

-- array_contains
SELECT array_contains(array(1, 2, 3), 2);
+---------------------------------+
|array_contains(array(1, 2, 3), 2)|
+---------------------------------+
|                             true|
+---------------------------------+

-- array_distinct
SELECT array_distinct(array(1, 2, 3, null, 3));
+----------------------------------------------------+
|array_distinct(array(1, 2, 3, CAST(NULL AS INT), 3))|
+----------------------------------------------------+
|                                          [1, 2, 3,]|
+----------------------------------------------------+

-- array_except
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
+--------------------------------------------+
|array_except(array(1, 2, 3), array(1, 3, 5))|
+--------------------------------------------+
|                                         [2]|
+--------------------------------------------+

-- array_intersect
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
+-----------------------------------------------+
|array_intersect(array(1, 2, 3), array(1, 3, 5))|
+-----------------------------------------------+
|                                         [1, 3]|
+-----------------------------------------------+

-- array_join
SELECT array_join(array('hello', 'world'), ' ');
+----------------------------------+
|array_join(array(hello, world),  )|
+----------------------------------+
|                       hello world|
+----------------------------------+

SELECT array_join(array('hello', null ,'world'), ' ');
+--------------------------------------------------------+
|array_join(array(hello, CAST(NULL AS STRING), world),  )|
+--------------------------------------------------------+
|                                             hello world|
+--------------------------------------------------------+

SELECT array_join(array('hello', null ,'world'), ' ', ',');
+-----------------------------------------------------------+
|array_join(array(hello, CAST(NULL AS STRING), world),  , ,)|
+-----------------------------------------------------------+
|                                              hello , world|
+-----------------------------------------------------------+

-- array_max
SELECT array_max(array(1, 20, null, 3));
+---------------------------------------------+
|array_max(array(1, 20, CAST(NULL AS INT), 3))|
+---------------------------------------------+
|                                           20|
+---------------------------------------------+

-- array_min
SELECT array_min(array(1, 20, null, 3));
+---------------------------------------------+
|array_min(array(1, 20, CAST(NULL AS INT), 3))|
+---------------------------------------------+
|                                            1|
+---------------------------------------------+

-- array_position
SELECT array_position(array(3, 2, 1), 1);
+---------------------------------+
|array_position(array(3, 2, 1), 1)|
+---------------------------------+
|                                3|
+---------------------------------+

-- array_remove
SELECT array_remove(array(1, 2, 3, null, 3), 3);
+-----------------------------------------------------+
|array_remove(array(1, 2, 3, CAST(NULL AS INT), 3), 3)|
+-----------------------------------------------------+
|                                              [1, 2,]|
+-----------------------------------------------------+

-- array_repeat
SELECT array_repeat('123', 2);
+--------------------+
|array_repeat(123, 2)|
+--------------------+
|          [123, 123]|
+--------------------+

-- array_union
SELECT array_union(array(1, 2, 3), array(1, 3, 5));
+-------------------------------------------+
|array_union(array(1, 2, 3), array(1, 3, 5))|
+-------------------------------------------+
|                               [1, 2, 3, 5]|
+-------------------------------------------+

-- arrays_overlap
SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5));
+----------------------------------------------+
|arrays_overlap(array(1, 2, 3), array(3, 4, 5))|
+----------------------------------------------+
|                                          true|
+----------------------------------------------+

-- arrays_zip
SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4));
+------------------------------------------+
|arrays_zip(array(1, 2, 3), array(2, 3, 4))|
+------------------------------------------+
|                      [[1, 2], [2, 3], ...|
+------------------------------------------+

SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4));
+-------------------------------------------------+
|arrays_zip(array(1, 2), array(2, 3), array(3, 4))|
+-------------------------------------------------+
|                             [[1, 2, 3], [2, 3...|
+-------------------------------------------------+

-- concat
SELECT concat('Spark', 'SQL');
+------------------+
|concat(Spark, SQL)|
+------------------+
|          SparkSQL|
+------------------+

SELECT concat(array(1, 2, 3), array(4, 5), array(6));
+---------------------------------------------+
|concat(array(1, 2, 3), array(4, 5), array(6))|
+---------------------------------------------+
|                           [1, 2, 3, 4, 5, 6]|
+---------------------------------------------+

-- flatten
SELECT flatten(array(array(1, 2), array(3, 4)));
+----------------------------------------+
|flatten(array(array(1, 2), array(3, 4)))|
+----------------------------------------+
|                            [1, 2, 3, 4]|
+----------------------------------------+

-- reverse
SELECT reverse('Spark SQL');
+------------------+
|reverse(Spark SQL)|
+------------------+
|         LQS krapS|
+------------------+

SELECT reverse(array(2, 1, 4, 3));
+--------------------------+
|reverse(array(2, 1, 4, 3))|
+--------------------------+
|              [3, 4, 1, 2]|
+--------------------------+

-- sequence
SELECT sequence(1, 5);
+---------------+
| sequence(1, 5)|
+---------------+
|[1, 2, 3, 4, 5]|
+---------------+

SELECT sequence(5, 1);
+---------------+
| sequence(5, 1)|
+---------------+
|[5, 4, 3, 2, 1]|
+---------------+

SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month);
+---------------------------------------------------------------------------+
|sequence(to_date('2018-01-01'), to_date('2018-03-01'), INTERVAL '1 months')|
+---------------------------------------------------------------------------+
|                                                       [2018-01-01, 2018...|
+---------------------------------------------------------------------------+

-- shuffle
SELECT shuffle(array(1, 20, 3, 5));
+---------------------------+
|shuffle(array(1, 20, 3, 5))|
+---------------------------+
|              [5, 20, 3, 1]|
+---------------------------+

SELECT shuffle(array(1, 20, null, 3));
+-------------------------------------------+
|shuffle(array(1, 20, CAST(NULL AS INT), 3))|
+-------------------------------------------+
|                                [20, 3,, 1]|
+-------------------------------------------+

-- slice
SELECT slice(array(1, 2, 3, 4), 2, 2);
+------------------------------+
|slice(array(1, 2, 3, 4), 2, 2)|
+------------------------------+
|                        [2, 3]|
+------------------------------+

SELECT slice(array(1, 2, 3, 4), -2, 2);
+-------------------------------+
|slice(array(1, 2, 3, 4), -2, 2)|
+-------------------------------+
|                         [3, 4]|
+-------------------------------+

-- sort_array
SELECT sort_array(array('b', 'd', null, 'c', 'a'), true);
+---------------------------------------------------------+
|sort_array(array(b, d, CAST(NULL AS STRING), c, a), true)|
+---------------------------------------------------------+
|                                           [, a, b, c, d]|
+---------------------------------------------------------+

Funkce mapy

Funkce Description
map_concat (,... mapování) Vrátí sjednocení všech daných map.
map_entries (mapa) Vrátí neuspořádané pole všech položek v dané mapě.
map_from_entries (arrayOfEntries) Vrátí mapu vytvořenou z daného pole položek.
map_keys (mapa) Vrátí neuspořádané pole obsahující klíče mapy.
map_values (mapa) Vrátí neuspořádané pole obsahující hodnoty mapy.

Příklady

-- map_concat
SELECT map_concat(map(1, 'a', 2, 'b'), map(3, 'c'));
+--------------------------------------+
|map_concat(map(1, a, 2, b), map(3, c))|
+--------------------------------------+
|                  [1 -> a, 2 -> b, ...|
+--------------------------------------+

-- map_entries
SELECT map_entries(map(1, 'a', 2, 'b'));
+----------------------------+
|map_entries(map(1, a, 2, b))|
+----------------------------+
|            [[1, a], [2, b]]|
+----------------------------+

-- map_from_entries
SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b')));
+---------------------------------------------------+
|map_from_entries(array(struct(1, a), struct(2, b)))|
+---------------------------------------------------+
|                                   [1 -> a, 2 -> b]|
+---------------------------------------------------+

-- map_keys
SELECT map_keys(map(1, 'a', 2, 'b'));
+-------------------------+
|map_keys(map(1, a, 2, b))|
+-------------------------+
|                   [1, 2]|
+-------------------------+

-- map_values
SELECT map_values(map(1, 'a', 2, 'b'));
+---------------------------+
|map_values(map(1, a, 2, b))|
+---------------------------+
|                     [a, b]|
+---------------------------+

Funkce Date a timestamp

Informace o formátech data a časového razítka naleznete v tématu vzory data a času.

Funkce Description
add_months (start_date, num_months) Vrátí datum, které následuje num_months po start_date .
current_date () Vrátí aktuální datum na začátku vyhodnocení dotazu.
current_timestamp () Vrátí aktuální časové razítko na začátku vyhodnocení dotazu.
date_add (start_date, num_days) Vrátí datum, které následuje num_days po start_date .
date_format (časové razítko, FMT) Převede timestamp na hodnotu řetězce ve formátu určeném formátem data fmt .
date_part (pole, zdroj) Extrahuje část data/časového razítka nebo zdroje intervalu.
date_sub (start_date, num_days) Vrátí datum, které je num_days před start_date .
date_trunc (FMT, TS) Vrátí časové razítko ts zkrácené na jednotku určenou modelem formátu fmt .
DateDiff (endDate, startDate) Vrátí počet dní od startDate do endDate .
DayOfWeek (datum) Vrátí den v týdnu pro datum nebo časové razítko (1 = neděle, 2 = pondělí,..., 7 = sobota).
DAYOFYEAR (datum) Vrátí den v roce pro datum nebo časové razítko.
from_unixtime (unix_time, formát) Vrátí unix_time v zadaném format .
from_utc_timestamp (časové razítko, časové pásmo) S ohledem na časové razítko, jako je například "2017-07-14 02:40:00.0", je interpretováno jako čas ve standardu UTC a vykreslí tento čas jako časové razítko v daném časovém pásmu. Například "GMT + 1" by znamenal "2017-07-14 03:40:00.0".
Hour (časové razítko) Vrátí složku hodin řetězce nebo časového razítka.
last_day (datum) Vrátí poslední den v měsíci, do kterého datum patří.
make_date (rok, měsíc, den) Vytvořit datum z polí rok, měsíc a den
make_timestamp (rok, měsíc, den, hodina, minimum, SEK [, TimeZone]) Vytvořte časové razítko z polí rok, měsíc, den, hodina, minimum, SEK a timezone.
minuta (časové razítko) Vrátí komponentu minut řetězce nebo časového razítka.
month (datum) Vrátí složku měsíce pro datum nebo časové razítko.
months_between (timestamp1; timestamp2 [; roundOff]) Pokud timestamp1 je pozdější než timestamp2 , je výsledek kladný. Pokud timestamp1 a timestamp2 jsou ke stejnému dni měsíce nebo jsou oba poslední den v měsíci, denní doba je ignorována. V opačném případě se rozdíl vypočítá na základě 31 dnů měsíčně a zaokrouhleno na 8 číslic, pokud roundOff = false.
next_day (start_date, day_of_week) Vrátí první datum, které je pozdější než start_date a pojmenované, jak je uvedeno.
now() Vrátí aktuální časové razítko na začátku vyhodnocení dotazu.
čtvrtletí (datum) Vrátí čtvrtletí roku v roce pro datum v rozsahu od 1 do 4.
druhé (časové razítko) Vrátí druhou komponentu řetězce nebo časového razítka.
to_date (date_str [, FMT]) Analyzuje date_str výraz fmt výrazem na datum. Vrací hodnotu null s neplatným vstupem. Ve výchozím nastavení sleduje pravidla přetypování na datum, pokud fmt je vynecháno.
to_timestamp (timestamp_str [, FMT]) Analyzuje timestamp_str výraz fmt výrazem na časové razítko. Vrací hodnotu null s neplatným vstupem. Ve výchozím nastavení sleduje pravidla přetypování na časové razítko, pokud fmt je vynecháno.
to_unix_timestamp (timeExp [, formát]) Vrátí časové razítko systému UNIX daného času.
to_utc_timestamp (časové razítko, časové pásmo) S ohledem na časové razítko, jako je například "2017-07-14 02:40:00.0", je interpretováno jako čas v daném časovém pásmu a vykreslí tento čas jako časové razítko ve formátu UTC. Například "GMT + 1" by znamenal "2017-07-14 01:40:00.0"
TRUNC – (datefmt) Vrátí date s časovou částkou dne zkrácenou na jednotku určenou modelem formátu fmt .
unix_timestamp ([timeExp [formát]]) Vrátí časové razítko systému UNIX aktuálního nebo zadaného času.
den v týdnu (datum) Vrátí den v týdnu pro datum nebo časové razítko (0 = pondělí, 1 = úterý,..., 6 = neděle).
WeekOfYear (datum) Vrátí týden v roce daného data. Týden se považuje za začátek v pondělí a týden 1 je první týden se >3 dny.
Year (datum) Vrátí složku roku pro datum nebo časové razítko.
Window (timeColumn, windowDuration, slideDuration, Čas_spuštění) Nastavit interval řádky do jednoho nebo více časových intervalů pro systém Windows podle časového razítka určující sloupec.

Příklady

-- add_months
SELECT add_months('2016-08-31', 1);
+---------------------------------------+
|add_months(CAST(2016-08-31 AS DATE), 1)|
+---------------------------------------+
|                             2016-09-30|
+---------------------------------------+

-- current_date
SELECT current_date();
+--------------+
|current_date()|
+--------------+
|    2020-06-06|
+--------------+

SELECT current_date;
+--------------+
|current_date()|
+--------------+
|    2020-06-06|
+--------------+

-- current_timestamp
SELECT current_timestamp();
+--------------------+
| current_timestamp()|
+--------------------+
|2020-06-06 14:00:...|
+--------------------+

SELECT current_timestamp;
+--------------------+
| current_timestamp()|
+--------------------+
|2020-06-06 14:00:...|
+--------------------+

-- date_add
SELECT date_add('2016-07-30', 1);
+-------------------------------------+
|date_add(CAST(2016-07-30 AS DATE), 1)|
+-------------------------------------+
|                           2016-07-31|
+-------------------------------------+

-- date_format
SELECT date_format('2016-04-08', 'y');
+---------------------------------------------+
|date_format(CAST(2016-04-08 AS TIMESTAMP), y)|
+---------------------------------------------+
|                                         2016|
+---------------------------------------------+

-- date_part
SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');
+---------------------------------------------------------+
|date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456')|
+---------------------------------------------------------+
|                                                     2019|
+---------------------------------------------------------+

SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456');
+---------------------------------------------------------+
|date_part('week', TIMESTAMP '2019-08-12 01:00:00.123456')|
+---------------------------------------------------------+
|                                                       33|
+---------------------------------------------------------+

SELECT date_part('doy', DATE'2019-08-12');
+-----------------------------------+
|date_part('doy', DATE '2019-08-12')|
+-----------------------------------+
|                                224|
+-----------------------------------+

SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001');
+------------------------------------------------------------+
|date_part('SECONDS', TIMESTAMP '2019-10-01 00:00:01.000001')|
+------------------------------------------------------------+
|                                                    1.000001|
+------------------------------------------------------------+

SELECT date_part('days', interval 1 year 10 months 5 days);
+------------------------------------------------------+
|date_part('days', INTERVAL '1 years 10 months 5 days')|
+------------------------------------------------------+
|                                                     5|
+------------------------------------------------------+

SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+----------------------------------------------------------+
|date_part('seconds', INTERVAL '5 hours 30.001001 seconds')|
+----------------------------------------------------------+
|                                                 30.001001|
+----------------------------------------------------------+

-- date_sub
SELECT date_sub('2016-07-30', 1);
+-------------------------------------+
|date_sub(CAST(2016-07-30 AS DATE), 1)|
+-------------------------------------+
|                           2016-07-29|
+-------------------------------------+

-- date_trunc
SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359');
+------------------------------------------------------------+
|date_trunc(YEAR, CAST(2015-03-05T09:32:05.359 AS TIMESTAMP))|
+------------------------------------------------------------+
|                                         2015-01-01 00:00:00|
+------------------------------------------------------------+

SELECT date_trunc('MM', '2015-03-05T09:32:05.359');
+----------------------------------------------------------+
|date_trunc(MM, CAST(2015-03-05T09:32:05.359 AS TIMESTAMP))|
+----------------------------------------------------------+
|                                       2015-03-01 00:00:00|
+----------------------------------------------------------+

SELECT date_trunc('DD', '2015-03-05T09:32:05.359');
+----------------------------------------------------------+
|date_trunc(DD, CAST(2015-03-05T09:32:05.359 AS TIMESTAMP))|
+----------------------------------------------------------+
|                                       2015-03-05 00:00:00|
+----------------------------------------------------------+

SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359');
+------------------------------------------------------------+
|date_trunc(HOUR, CAST(2015-03-05T09:32:05.359 AS TIMESTAMP))|
+------------------------------------------------------------+
|                                         2015-03-05 09:00:00|
+------------------------------------------------------------+

SELECT date_trunc('MILLISECOND', '2015-03-05T09:32:05.123456');
+----------------------------------------------------------------------+
|date_trunc(MILLISECOND, CAST(2015-03-05T09:32:05.123456 AS TIMESTAMP))|
+----------------------------------------------------------------------+
|                                                  2015-03-05 09:32:...|
+----------------------------------------------------------------------+

-- datediff
SELECT datediff('2009-07-31', '2009-07-30');
+------------------------------------------------------------+
|datediff(CAST(2009-07-31 AS DATE), CAST(2009-07-30 AS DATE))|
+------------------------------------------------------------+
|                                                           1|
+------------------------------------------------------------+

SELECT datediff('2009-07-30', '2009-07-31');
+------------------------------------------------------------+
|datediff(CAST(2009-07-30 AS DATE), CAST(2009-07-31 AS DATE))|
+------------------------------------------------------------+
|                                                          -1|
+------------------------------------------------------------+

-- dayofweek
SELECT dayofweek('2009-07-30');
+-----------------------------------+
|dayofweek(CAST(2009-07-30 AS DATE))|
+-----------------------------------+
|                                  5|
+-----------------------------------+

-- dayofyear
SELECT dayofyear('2016-04-09');
+-----------------------------------+
|dayofyear(CAST(2016-04-09 AS DATE))|
+-----------------------------------+
|                                100|
+-----------------------------------+

-- from_unixtime
SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss');
+-----------------------------------------------------+
|from_unixtime(CAST(0 AS BIGINT), yyyy-MM-dd HH:mm:ss)|
+-----------------------------------------------------+
|                                  1970-01-01 00:00:00|
+-----------------------------------------------------+

-- from_utc_timestamp
SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul');
+-------------------------------------------------------------+
|from_utc_timestamp(CAST(2016-08-31 AS TIMESTAMP), Asia/Seoul)|
+-------------------------------------------------------------+
|                                          2016-08-31 09:00:00|
+-------------------------------------------------------------+

-- hour
SELECT hour('2009-07-30 12:58:59');
+--------------------------------------------+
|hour(CAST(2009-07-30 12:58:59 AS TIMESTAMP))|
+--------------------------------------------+
|                                          12|
+--------------------------------------------+

-- last_day
SELECT last_day('2009-01-12');
+----------------------------------+
|last_day(CAST(2009-01-12 AS DATE))|
+----------------------------------+
|                        2009-01-31|
+----------------------------------+

-- make_date
SELECT make_date(2013, 7, 15);
+----------------------+
|make_date(2013, 7, 15)|
+----------------------+
|            2013-07-15|
+----------------------+

SELECT make_date(2019, 13, 1);
+----------------------+
|make_date(2019, 13, 1)|
+----------------------+
|                  null|
+----------------------+

SELECT make_date(2019, 7, NULL);
+-------------------------------------+
|make_date(2019, 7, CAST(NULL AS INT))|
+-------------------------------------+
|                                 null|
+-------------------------------------+

SELECT make_date(2019, 2, 30);
+----------------------+
|make_date(2019, 2, 30)|
+----------------------+
|                  null|
+----------------------+

-- make_timestamp
SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887);
+-----------------------------------------------------------------+
|make_timestamp(2014, 12, 28, 6, 30, CAST(45.887 AS DECIMAL(8,6)))|
+-----------------------------------------------------------------+
|                                             2014-12-28 06:30:...|
+-----------------------------------------------------------------+

SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET');
+----------------------------------------------------------------------+
|make_timestamp(2014, 12, 28, 6, 30, CAST(45.887 AS DECIMAL(8,6)), CET)|
+----------------------------------------------------------------------+
|                                                  2014-12-28 05:30:...|
+----------------------------------------------------------------------+

SELECT make_timestamp(2019, 6, 30, 23, 59, 60);
+-------------------------------------------------------------+
|make_timestamp(2019, 6, 30, 23, 59, CAST(60 AS DECIMAL(8,6)))|
+-------------------------------------------------------------+
|                                          2019-07-01 00:00:00|
+-------------------------------------------------------------+

SELECT make_timestamp(2019, 13, 1, 10, 11, 12, 'PST');
+------------------------------------------------------------------+
|make_timestamp(2019, 13, 1, 10, 11, CAST(12 AS DECIMAL(8,6)), PST)|
+------------------------------------------------------------------+
|                                                              null|
+------------------------------------------------------------------+

SELECT make_timestamp(null, 7, 22, 15, 30, 0);
+-------------------------------------------------------------------------+
|make_timestamp(CAST(NULL AS INT), 7, 22, 15, 30, CAST(0 AS DECIMAL(8,6)))|
+-------------------------------------------------------------------------+
|                                                                     null|
+-------------------------------------------------------------------------+

-- minute
SELECT minute('2009-07-30 12:58:59');
+----------------------------------------------+
|minute(CAST(2009-07-30 12:58:59 AS TIMESTAMP))|
+----------------------------------------------+
|                                            58|
+----------------------------------------------+

-- month
SELECT month('2016-07-30');
+-------------------------------+
|month(CAST(2016-07-30 AS DATE))|
+-------------------------------+
|                              7|
+-------------------------------+

-- months_between
SELECT months_between('1997-02-28 10:30:00', '1996-10-30');
+-------------------------------------------------------------------------------------------+
|months_between(CAST(1997-02-28 10:30:00 AS TIMESTAMP), CAST(1996-10-30 AS TIMESTAMP), true)|
+-------------------------------------------------------------------------------------------+
|                                                                                 3.94959677|
+-------------------------------------------------------------------------------------------+

SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false);
+--------------------------------------------------------------------------------------------+
|months_between(CAST(1997-02-28 10:30:00 AS TIMESTAMP), CAST(1996-10-30 AS TIMESTAMP), false)|
+--------------------------------------------------------------------------------------------+
|                                                                          3.9495967741935485|
+--------------------------------------------------------------------------------------------+

-- next_day
SELECT next_day('2015-01-14', 'TU');
+--------------------------------------+
|next_day(CAST(2015-01-14 AS DATE), TU)|
+--------------------------------------+
|                            2015-01-20|
+--------------------------------------+

-- now
SELECT now();
+--------------------+
|               now()|
+--------------------+
|2020-06-06 14:00:...|
+--------------------+

-- quarter
SELECT quarter('2016-08-31');
+---------------------------------+
|quarter(CAST(2016-08-31 AS DATE))|
+---------------------------------+
|                                3|
+---------------------------------+

-- second
SELECT second('2009-07-30 12:58:59');
+----------------------------------------------+
|second(CAST(2009-07-30 12:58:59 AS TIMESTAMP))|
+----------------------------------------------+
|                                            59|
+----------------------------------------------+

-- to_date
SELECT to_date('2009-07-30 04:17:52');
+------------------------------+
|to_date('2009-07-30 04:17:52')|
+------------------------------+
|                    2009-07-30|
+------------------------------+

SELECT to_date('2016-12-31', 'yyyy-MM-dd');
+-----------------------------------+
|to_date('2016-12-31', 'yyyy-MM-dd')|
+-----------------------------------+
|                         2016-12-31|
+-----------------------------------+

-- to_timestamp
SELECT to_timestamp('2016-12-31 00:12:00');
+-----------------------------------+
|to_timestamp('2016-12-31 00:12:00')|
+-----------------------------------+
|                2016-12-31 00:12:00|
+-----------------------------------+

SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd');
+----------------------------------------+
|to_timestamp('2016-12-31', 'yyyy-MM-dd')|
+----------------------------------------+
|                     2016-12-31 00:00:00|
+----------------------------------------+

-- to_unix_timestamp
SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd');
+-----------------------------------------+
|to_unix_timestamp(2016-04-08, yyyy-MM-dd)|
+-----------------------------------------+
|                               1460073600|
+-----------------------------------------+

-- to_utc_timestamp
SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul');
+-----------------------------------------------------------+
|to_utc_timestamp(CAST(2016-08-31 AS TIMESTAMP), Asia/Seoul)|
+-----------------------------------------------------------+
|                                        2016-08-30 15:00:00|
+-----------------------------------------------------------+

-- trunc
SELECT trunc('2019-08-04', 'week');
+-------------------------------------+
|trunc(CAST(2019-08-04 AS DATE), week)|
+-------------------------------------+
|                           2019-07-29|
+-------------------------------------+

SELECT trunc('2019-08-04', 'quarter');
+----------------------------------------+
|trunc(CAST(2019-08-04 AS DATE), quarter)|
+----------------------------------------+
|                              2019-07-01|
+----------------------------------------+

SELECT trunc('2009-02-12', 'MM');
+-----------------------------------+
|trunc(CAST(2009-02-12 AS DATE), MM)|
+-----------------------------------+
|                         2009-02-01|
+-----------------------------------+

SELECT trunc('2015-10-27', 'YEAR');
+-------------------------------------+
|trunc(CAST(2015-10-27 AS DATE), YEAR)|
+-------------------------------------+
|                           2015-01-01|
+-------------------------------------+

-- unix_timestamp
SELECT unix_timestamp();
+--------------------------------------------------------+
|unix_timestamp(current_timestamp(), yyyy-MM-dd HH:mm:ss)|
+--------------------------------------------------------+
|                                              1591452047|
+--------------------------------------------------------+

SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd');
+--------------------------------------+
|unix_timestamp(2016-04-08, yyyy-MM-dd)|
+--------------------------------------+
|                            1460073600|
+--------------------------------------+

-- weekday
SELECT weekday('2009-07-30');
+---------------------------------+
|weekday(CAST(2009-07-30 AS DATE))|
+---------------------------------+
|                                3|
+---------------------------------+

-- weekofyear
SELECT weekofyear('2008-02-20');
+------------------------------------+
|weekofyear(CAST(2008-02-20 AS DATE))|
+------------------------------------+
|                                   8|
+------------------------------------+

-- year
SELECT year('2016-07-30');
+------------------------------+
|year(CAST(2016-07-30 AS DATE))|
+------------------------------+
|                          2016|
+------------------------------+

Použijte dotaz na zobrazení ( readings_streaming ), které odkazuje na datový proud. Dotaz agreguje průměr každé 2 minuty a počet polí reading_1 v datovém proudu na device_type .

SELECT window.start, device_type,
  AVG(reading_1) AS reading_1,
  COUNT(reading_1) AS count_reading_1
FROM readings_streaming
GROUP BY
  window(reading_time, '2 minutes'),
  device_type
ORDER BY
  window DESC,
  device_type ASC

Funkce JSON

Funkce Description
from_json (jsonStr, Schema [; Options]) Vrací hodnotu struktury s danými jsonStr a schema .
get_json_object (json_txt, cesta) Extrahuje objekt JSON z path .
json_tuple (jsonStr, P1, P2,..., PN) Vrátí řazenou kolekci členů, jako je funkce get_json_object , ale má více názvů. Všechny vstupní parametry a typy výstupních sloupců jsou řetězce.
schema_of_json (JSON [; možnosti]) Vrátí schéma ve formátu DDL řetězce JSON.
to_json (výraz [; možnosti]) Vrátí řetězec JSON s danou hodnotou struktury.

Příklady

-- from_json
SELECT from_json('{"a":1, "b":0.8}', 'a INT, b DOUBLE');
+---------------------------+
|from_json({"a":1, "b":0.8})|
+---------------------------+
|                   [1, 0.8]|
+---------------------------+

SELECT from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
+--------------------------------+
|from_json({"time":"26/08/2015"})|
+--------------------------------+
|            [2015-08-26 00:00...|
+--------------------------------+

-- get_json_object
SELECT get_json_object('{"a":"b"}', '$.a');
+-------------------------------+
|get_json_object({"a":"b"}, $.a)|
+-------------------------------+
|                              b|
+-------------------------------+

-- json_tuple
SELECT json_tuple('{"a":1, "b":2}', 'a', 'b');
+---+---+
| c0| c1|
+---+---+
|  1|  2|
+---+---+

-- schema_of_json
SELECT schema_of_json('[{"col":0}]');
+---------------------------+
|schema_of_json([{"col":0}])|
+---------------------------+
|       array<struct<col:...|
+---------------------------+

SELECT schema_of_json('[{"col":01}]', map('allowNumericLeadingZeros', 'true'));
+----------------------------+
|schema_of_json([{"col":01}])|
+----------------------------+
|        array<struct<col:...|
+----------------------------+

-- to_json
SELECT to_json(named_struct('a', 1, 'b', 2));
+---------------------------------+
|to_json(named_struct(a, 1, b, 2))|
+---------------------------------+
|                    {"a":1,"b":2}|
+---------------------------------+

SELECT to_json(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
+---------------------------------------------------------------------+
|to_json(named_struct(time, to_timestamp('2015-08-26', 'yyyy-MM-dd')))|
+---------------------------------------------------------------------+
|                                                 {"time":"26/08/20...|
+---------------------------------------------------------------------+

SELECT to_json(array(named_struct('a', 1, 'b', 2)));
+----------------------------------------+
|to_json(array(named_struct(a, 1, b, 2)))|
+----------------------------------------+
|                         [{"a":1,"b":2}]|
+----------------------------------------+

SELECT to_json(map('a', named_struct('b', 1)));
+-----------------------------------+
|to_json(map(a, named_struct(b, 1)))|
+-----------------------------------+
|                      {"a":{"b":1}}|
+-----------------------------------+

SELECT to_json(map(named_struct('a', 1),named_struct('b', 2)));
+----------------------------------------------------+
|to_json(map(named_struct(a, 1), named_struct(b, 2)))|
+----------------------------------------------------+
|                                     {"[1]":{"b":2}}|
+----------------------------------------------------+

SELECT to_json(map('a', 1));
+------------------+
|to_json(map(a, 1))|
+------------------+
|           {"a":1}|
+------------------+

SELECT to_json(array((map('a', 1))));
+-------------------------+
|to_json(array(map(a, 1)))|
+-------------------------+
|                [{"a":1}]|
+-------------------------+