組み込み関数

集計関数

関数	説明
any(expr)	`expr` の値のいずれかが true であれば true を返します。
any_value(expr[, isIgnoreNull])	行のグループに対して `expr` のいずれかの値を返します。`isIgnoreNull` が true の場合、null でない値のみを返します。
approx_count_distinct(expr[, relativeSD])	HyperLogLog++ による推定カーディナリティを返します。`relativeSD` は許容される最大相対標準偏差を定義します。
approx_percentile(col, percentage [, accuracy])	数値または ANSI 間隔列 `col` の近似 `percentage` を返します。これは、順序付けられた `col` の値（昇順にソート）の中で、`col` の値の `percentage` 以下がその値よりも小さいか等しいような最小の値です。percentage の値は 0.0 から 1.0 の間でなければなりません。`accuracy` パラメータ（デフォルト: 10000）は、メモリコストを犠牲にして近似精度を制御する正の数値リテラルです。`accuracy` の値が高いほど精度が高くなり、`1.0/accuracy` が近似の相対誤差となります。`percentage` が配列の場合、percentage 配列の各値は 0.0 から 1.0 の間でなければなりません。この場合、指定された percentage 配列での列 `col` の近似パーセンタイル配列を返します。
array_agg(expr)	重複しない要素のリストを収集して返します。
avg(expr)	グループの値から計算された平均を返します。
bit_and(expr)	null でないすべての入力値のビットごとの AND を返します。null の場合は null を返します。
bit_or(expr)	null でないすべての入力値のビットごとの OR を返します。null の場合は null を返します。
bit_xor(expr)	null でないすべての入力値のビットごとの XOR を返します。null の場合は null を返します。
bitmap_construct_agg(child)	子式すべての値から設定されたビットの位置を持つビットマップを返します。子式はほとんどの場合 bitmap_bit_position() になります。
bitmap_or_agg(child)	子式からのすべてのビットマップのビットごとの OR であるビットマップを返します。入力は bitmap_construct_agg() から作成されたビットマップである必要があります。
bool_and(expr)	`expr` のすべての値が true であれば true を返します。
bool_or(expr)	`expr` の値のいずれかが true であれば true を返します。
collect_list(expr)	重複しない要素のリストを収集して返します。
collect_set(expr)	一意の要素のセットを収集して返します。
corr(expr1, expr2)	数値ペアのセット間のピアソン相関係数を返します。
count(*)	null を含む行を含む、取得された行の総数を返します。
count(expr[, expr...])	指定された式がすべて null でない行の数を返します。
count(DISTINCT expr[, expr...])	指定された式がユニークで null でない行の数を返します。
count_if(expr)	式の true の値の数を返します。
count_min_sketch(col, eps, confidence, seed)	指定された eps、信頼度、シードを持つ列のカウント最小スキッチを返します。結果はバイト配列で、使用前に `CountMinSketch` に逆シリアル化できます。カウント最小スキッチは、サブ線形空間を使用したカーディナリティ推定に使用される確率的データ構造です。
covar_pop(expr1, expr2)	数値ペアのセットの母共分散を返します。
covar_samp(expr1, expr2)	数値ペアのセットの標本共分散を返します。
every(expr)	`expr` のすべての値が true であれば true を返します。
first(expr[, isIgnoreNull])	行のグループに対して `expr` の最初の値を返します。`isIgnoreNull` が true の場合、null でない値のみを返します。
first_value(expr[, isIgnoreNull])	行のグループに対して `expr` の最初の値を返します。`isIgnoreNull` が true の場合、null でない値のみを返します。
grouping(col)	GROUP BY で指定された列が集計されているかどうかを示します。結果セットでは、集計されている場合は 1、集計されていない場合は 0 を返します。
grouping_id([col1[, col2 ..]])	グループ化のレベルを返します。` (grouping(c1) << (n-1)) + (grouping(c2) << (n-2)) + ... + grouping(cn)` に等しくなります。
histogram_numeric(expr, nb)	nb 個のビンを使用して数値 `expr` のヒストグラムを計算します。返される値は、ヒストグラムのビンの中心を表す (x,y) ペアの配列です。`nb` の値を増やすと、ヒストグラムの近似はより細かくなりますが、外れ値の周りにアーティファクトが生じる可能性があります。実際には、20～40 個のヒストグラムビンがうまく機能するように見え、歪んだデータセットや小さなデータセットではより多くのビンが必要になります。この関数は、ビン幅が均一でないヒストグラムを作成することに注意してください。ヒストグラムの平均二乗誤差に関して保証はありませんが、実際には R/S-Plus の統計計算パッケージによって生成されるヒストグラムと同等です。注意: 返り値の 'x' フィールドの出力タイプは、集計関数で消費される入力値から伝播されます。
hll_sketch_agg(expr, lgConfigK)	HllSketch の更新可能なバイナリ表現を返します。`lgConfigK` (オプション) は K の対数（底2）であり、K は HllSketch のバケットまたはスロットの数です。
hll_union_agg(expr, allowDifferentLgConfigK)	一意な値の推定数を返します。`allowDifferentLgConfigK` (オプション) は、異なる lgConfigK 値を持つスキッチを結合することを許可します（デフォルトは false）。
kurtosis(expr)	グループの値から計算された歪度を返します。
last(expr[, isIgnoreNull])	行のグループに対して `expr` の最後の値を返します。`isIgnoreNull` が true の場合、null でない値のみを返します。
last_value(expr[, isIgnoreNull])	行のグループに対して `expr` の最後の値を返します。`isIgnoreNull` が true の場合、null でない値のみを返します。
listagg(expr[, delimiter])[ WITHIN GROUP (ORDER BY key [ASC \| DESC] [,...])]	null でない入力値の連結を、key で順序付けされた区切り文字で区切って返します。すべての値が null の場合は null を返します。
max(expr)	`expr` の最大値を返します。
max_by(x, y)	`y` の最大値に関連付けられた `x` の値を返します。
mean(expr)	グループの値から計算された平均を返します。
median(col)	数値または ANSI 間隔列 `col` の中央値を返します。
min(expr)	`expr` の最小値を返します。
min_by(x, y)	`y` の最小値に関連付けられた `x` の値を返します。
mode(col[, deterministic])	`col` 内の値の最も頻繁な値を返します。null 値は無視されます。すべての値が null であるか、行が 0 の場合は null を返します。複数の値が同じ最大頻度を持つ場合、`deterministic` が false または未定義の場合はいずれかの値が返され、`deterministic` が true の場合は最も小さい値が返されます。
mode() WITHIN GROUP (ORDER BY col)	`col` (ORDER BY 句で指定) 内の値の最も頻繁な値を返します。null 値は無視されます。すべての値が null であるか、行が 0 の場合は null を返します。複数の値が同じ最大頻度を持つ場合、1 つの値のみが返されます。頻度が同じ複数の値から、ソート順に基づいて値が選択されます。昇順の場合に最も小さい値、降順の場合に最も大きい値を返します。
percentile(col, percentage [, frequency])	数値または ANSI 間隔列 `col` の指定されたパーセンタイルでの正確なパーセンタイル値を返します。percentage の値は 0.0 から 1.0 の間でなければなりません。frequency の値は正の整数である必要があります。
percentile(col, array(percentage1 [, percentage2]...) [, frequency])	数値列 `col` の指定されたパーセンタイルでの正確なパーセンタイル値配列を返します。percentage 配列の各値は 0.0 から 1.0 の間でなければなりません。frequency の値は正の整数である必要があります。
percentile_approx(col, percentage [, accuracy])	数値または ANSI 間隔列 `col` の近似 `percentage` を返します。これは、順序付けられた `col` の値（昇順にソート）の中で、`col` の値の `percentage` 以下がその値よりも小さいか等しいような最小の値です。percentage の値は 0.0 から 1.0 の間でなければなりません。`accuracy` パラメータ（デフォルト: 10000）は、メモリコストを犠牲にして近似精度を制御する正の数値リテラルです。`accuracy` の値が高いほど精度が高くなり、`1.0/accuracy` が近似の相対誤差となります。`percentage` が配列の場合、percentage 配列の各値は 0.0 から 1.0 の間でなければなりません。この場合、指定された percentage 配列での列 `col` の近似パーセンタイル配列を返します。
percentile_cont(percentage) WITHIN GROUP (ORDER BY col)	数値または ANSI 間隔列 `col` の指定された `percentage` (ORDER BY 句で指定) に基づく連続分布のパーセンタイル値を返します。
percentile_disc(percentage) WITHIN GROUP (ORDER BY col)	数値または ANSI 間隔列 `col` の指定された `percentage` (ORDER BY 句で指定) に基づく離散分布のパーセンタイル値を返します。
regr_avgx(y, x)	グループ内の null でないペアの独立変数の平均を返します。ここで `y` は従属変数、`x` は独立変数です。
regr_avgy(y, x)	グループ内の null でないペアの従属変数の平均を返します。ここで `y` は従属変数、`x` は独立変数です。
regr_count(y, x)	グループ内の null でない数値ペアの数を返します。ここで `y` は従属変数、`x` は独立変数です。
regr_intercept(y, x)	グループ内の null でないペアの単回帰直線の切片を返します。ここで `y` は従属変数、`x` は独立変数です。
regr_r2(y, x)	グループ内の null でないペアの決定係数を返します。ここで `y` は従属変数、`x` は独立変数です。
regr_slope(y, x)	グループ内の null でないペアの線形回帰直線の傾きを返します。ここで `y` は従属変数、`x` は独立変数です。
regr_sxx(y, x)	グループ内の null でないペアの REGR_COUNT(y, x) * VAR_POP(x) を返します。ここで `y` は従属変数、`x` は独立変数です。
regr_sxy(y, x)	グループ内の null でないペアの REGR_COUNT(y, x) * COVAR_POP(y, x) を返します。ここで `y` は従属変数、`x` は独立変数です。
regr_syy(y, x)	グループ内の null でないペアの REGR_COUNT(y, x) * VAR_POP(y) を返します。ここで `y` は従属変数、`x` は独立変数です。
skewness(expr)	グループの値から計算された歪度を返します。
some(expr)	`expr` の値のいずれかが true であれば true を返します。
std(expr)	グループの値から計算された標本標準偏差を返します。
stddev(expr)	グループの値から計算された標本標準偏差を返します。
stddev_pop(expr)	グループの値から計算された母標準偏差を返します。
stddev_samp(expr)	グループの値から計算された標本標準偏差を返します。
string_agg(expr[, delimiter])[ WITHIN GROUP (ORDER BY key [ASC \| DESC] [,...])]	null でない入力値の連結を、key で順序付けされた区切り文字で区切って返します。すべての値が null の場合は null を返します。
sum(expr)	グループの値から計算された合計を返します。
try_avg(expr)	グループの値から計算された平均を返します。オーバーフローが発生した場合は null を返します。
try_sum(expr)	グループの値から計算された合計を返します。オーバーフローが発生した場合は null を返します。
var_pop(expr)	グループの値から計算された母分散を返します。
var_samp(expr)	グループの値から計算された標本分散を返します。
variance(expr)	グループの値から計算された標本分散を返します。

例

-- 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|
+--------+

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

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

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

-- 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(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col);
+-------------------------------------------------+
|approx_percentile(col, array(0.5, 0.4, 0.1), 100)|
+-------------------------------------------------+
|                                        [1, 1, 0]|
+-------------------------------------------------+

SELECT approx_percentile(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col);
+--------------------------------+
|approx_percentile(col, 0.5, 100)|
+--------------------------------+
|                               7|
+--------------------------------+

SELECT approx_percentile(col, 0.5, 100) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '1' MONTH), (INTERVAL '2' MONTH), (INTERVAL '10' MONTH) AS tab(col);
+--------------------------------+
|approx_percentile(col, 0.5, 100)|
+--------------------------------+
|              INTERVAL '1' MONTH|
+--------------------------------+

SELECT approx_percentile(col, array(0.5, 0.7), 100) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '1' SECOND), (INTERVAL '2' SECOND), (INTERVAL '10' SECOND) AS tab(col);
+--------------------------------------------+
|approx_percentile(col, array(0.5, 0.7), 100)|
+--------------------------------------------+
|                        [INTERVAL '01' SE...|
+--------------------------------------------+

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

-- 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_and
SELECT bit_and(col) FROM VALUES (3), (5) AS tab(col);
+------------+
|bit_and(col)|
+------------+
|           1|
+------------+

-- 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|
+------------+

-- bitmap_construct_agg
SELECT substring(hex(bitmap_construct_agg(bitmap_bit_position(col))), 0, 6) FROM VALUES (1), (2), (3) AS tab(col);
+--------------------------------------------------------------------+
|substring(hex(bitmap_construct_agg(bitmap_bit_position(col))), 0, 6)|
+--------------------------------------------------------------------+
|                                                              070000|
+--------------------------------------------------------------------+

SELECT substring(hex(bitmap_construct_agg(bitmap_bit_position(col))), 0, 6) FROM VALUES (1), (1), (1) AS tab(col);
+--------------------------------------------------------------------+
|substring(hex(bitmap_construct_agg(bitmap_bit_position(col))), 0, 6)|
+--------------------------------------------------------------------+
|                                                              010000|
+--------------------------------------------------------------------+

-- bitmap_or_agg
SELECT substring(hex(bitmap_or_agg(col)), 0, 6) FROM VALUES (X '10'), (X '20'), (X '40') AS tab(col);
+----------------------------------------+
|substring(hex(bitmap_or_agg(col)), 0, 6)|
+----------------------------------------+
|                                  700000|
+----------------------------------------+

SELECT substring(hex(bitmap_or_agg(col)), 0, 6) FROM VALUES (X '10'), (X '10'), (X '10') AS tab(col);
+----------------------------------------+
|substring(hex(bitmap_or_agg(col)), 0, 6)|
+----------------------------------------+
|                                  100000|
+----------------------------------------+

-- 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(c1, c2)|
+------------------+
|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|
+-----------------------+

-- count_min_sketch
SELECT hex(count_min_sketch(col, 0.5d, 0.5d, 1)) FROM VALUES (1), (2), (1) AS tab(col);
+---------------------------------------+
|hex(count_min_sketch(col, 0.5, 0.5, 1))|
+---------------------------------------+
|                   00000001000000000...|
+---------------------------------------+

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

-- covar_samp
SELECT covar_samp(c1, c2) FROM VALUES (1,1), (2,2), (3,3) AS tab(c1, c2);
+------------------+
|covar_samp(c1, c2)|
+------------------+
|               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)|
+----------+
|        10|
+----------+

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

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

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

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

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

-- grouping
SELECT name, grouping(name), sum(age) FROM VALUES (2, 'Alice'), (5, 'Bob') people(age, name) GROUP BY cube(name);
+-----+--------------+--------+
| name|grouping(name)|sum(age)|
+-----+--------------+--------+
| NULL|             1|       7|
|Alice|             0|       2|
|  Bob|             0|       5|
+-----+--------------+--------+

-- grouping_id
SELECT name, grouping_id(), sum(age), avg(height) FROM VALUES (2, 'Alice', 165), (5, 'Bob', 180) people(age, name, height) GROUP BY cube(name, height);
+-----+-------------+--------+-----------+
| name|grouping_id()|sum(age)|avg(height)|
+-----+-------------+--------+-----------+
| NULL|            2|       2|      165.0|
|Alice|            0|       2|      165.0|
|Alice|            1|       2|      165.0|
| NULL|            3|       7|      172.5|
|  Bob|            1|       5|      180.0|
|  Bob|            0|       5|      180.0|
| NULL|            2|       5|      180.0|
+-----+-------------+--------+-----------+

-- histogram_numeric
SELECT histogram_numeric(col, 5) FROM VALUES (0), (1), (2), (10) AS tab(col);
+-------------------------+
|histogram_numeric(col, 5)|
+-------------------------+
|     [{0, 1.0}, {1, 1....|
+-------------------------+

-- hll_sketch_agg
SELECT hll_sketch_estimate(hll_sketch_agg(col, 12)) FROM VALUES (1), (1), (2), (2), (3) tab(col);
+--------------------------------------------+
|hll_sketch_estimate(hll_sketch_agg(col, 12))|
+--------------------------------------------+
|                                           3|
+--------------------------------------------+

-- hll_union_agg
SELECT hll_sketch_estimate(hll_union_agg(sketch, true)) FROM (SELECT hll_sketch_agg(col) as sketch FROM VALUES (1) tab(col) UNION ALL SELECT hll_sketch_agg(col, 20) as sketch FROM VALUES (1) tab(col));
+------------------------------------------------+
|hll_sketch_estimate(hll_union_agg(sketch, true))|
+------------------------------------------------+
|                                               1|
+------------------------------------------------+

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

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

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

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

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

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

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

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

-- listagg
SELECT listagg(col) FROM VALUES ('a'), ('b'), ('c') AS tab(col);
+------------------+
|listagg(col, NULL)|
+------------------+
|               abc|
+------------------+

SELECT listagg(col) WITHIN GROUP (ORDER BY col DESC) FROM VALUES ('a'), ('b'), ('c') AS tab(col);
+--------------------------------------------------------------+
|listagg(col, NULL) WITHIN GROUP (ORDER BY col DESC NULLS LAST)|
+--------------------------------------------------------------+
|                                                           cba|
+--------------------------------------------------------------+

SELECT listagg(col) FROM VALUES ('a'), (NULL), ('b') AS tab(col);
+------------------+
|listagg(col, NULL)|
+------------------+
|                ab|
+------------------+

SELECT listagg(col) FROM VALUES ('a'), ('a') AS tab(col);
+------------------+
|listagg(col, NULL)|
+------------------+
|                aa|
+------------------+

SELECT listagg(DISTINCT col) FROM VALUES ('a'), ('a'), ('b') AS tab(col);
+---------------------------+
|listagg(DISTINCT col, NULL)|
+---------------------------+
|                         ab|
+---------------------------+

SELECT listagg(col, ', ') FROM VALUES ('a'), ('b'), ('c') AS tab(col);
+----------------+
|listagg(col, , )|
+----------------+
|         a, b, c|
+----------------+

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

-- 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|
+---------+

-- median
SELECT median(col) FROM VALUES (0), (10) AS tab(col);
+-----------+
|median(col)|
+-----------+
|        5.0|
+-----------+

SELECT median(col) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH) AS tab(col);
+--------------------+
|         median(col)|
+--------------------+
|INTERVAL '0-5' YE...|
+--------------------+

-- 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|
+------------+

-- mode
SELECT mode(col) FROM VALUES (0), (10), (10) AS tab(col);
+---------+
|mode(col)|
+---------+
|       10|
+---------+

SELECT mode(col) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH), (INTERVAL '10' MONTH) AS tab(col);
+-------------------+
|          mode(col)|
+-------------------+
|INTERVAL '10' MONTH|
+-------------------+

SELECT mode(col) FROM VALUES (0), (10), (10), (null), (null), (null) AS tab(col);
+---------+
|mode(col)|
+---------+
|       10|
+---------+

SELECT mode(col, false) FROM VALUES (-10), (0), (10) AS tab(col);
+---------+
|mode(col)|
+---------+
|        0|
+---------+

SELECT mode(col, true) FROM VALUES (-10), (0), (10) AS tab(col);
+---------------------------------------+
|mode() WITHIN GROUP (ORDER BY col DESC)|
+---------------------------------------+
|                                    -10|
+---------------------------------------+

SELECT mode() WITHIN GROUP (ORDER BY col) FROM VALUES (0), (10), (10) AS tab(col);
+---------------------------------------+
|mode() WITHIN GROUP (ORDER BY col DESC)|
+---------------------------------------+
|                                     10|
+---------------------------------------+

SELECT mode() WITHIN GROUP (ORDER BY col) FROM VALUES (0), (10), (10), (20), (20) AS tab(col);
+---------------------------------------+
|mode() WITHIN GROUP (ORDER BY col DESC)|
+---------------------------------------+
|                                     10|
+---------------------------------------+

SELECT mode() WITHIN GROUP (ORDER BY col DESC) FROM VALUES (0), (10), (10), (20), (20) AS tab(col);
+----------------------------------+
|mode() WITHIN GROUP (ORDER BY col)|
+----------------------------------+
|                                20|
+----------------------------------+

-- percentile
SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);
+-----------------------+
|percentile(col, 0.3, 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]|
+-------------------------------------+

SELECT percentile(col, 0.5) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH) AS tab(col);
+-----------------------+
|percentile(col, 0.5, 1)|
+-----------------------+
|   INTERVAL '0-5' YE...|
+-----------------------+

SELECT percentile(col, array(0.2, 0.5)) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '10' SECOND) AS tab(col);
+-----------------------------------+
|percentile(col, array(0.2, 0.5), 1)|
+-----------------------------------+
|               [INTERVAL '0 00:0...|
+-----------------------------------+

-- percentile_approx
SELECT percentile_approx(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col);
+-------------------------------------------------+
|percentile_approx(col, array(0.5, 0.4, 0.1), 100)|
+-------------------------------------------------+
|                                        [1, 1, 0]|
+-------------------------------------------------+

SELECT percentile_approx(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col);
+--------------------------------+
|percentile_approx(col, 0.5, 100)|
+--------------------------------+
|                               7|
+--------------------------------+

SELECT percentile_approx(col, 0.5, 100) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '1' MONTH), (INTERVAL '2' MONTH), (INTERVAL '10' MONTH) AS tab(col);
+--------------------------------+
|percentile_approx(col, 0.5, 100)|
+--------------------------------+
|              INTERVAL '1' MONTH|
+--------------------------------+

SELECT percentile_approx(col, array(0.5, 0.7), 100) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '1' SECOND), (INTERVAL '2' SECOND), (INTERVAL '10' SECOND) AS tab(col);
+--------------------------------------------+
|percentile_approx(col, array(0.5, 0.7), 100)|
+--------------------------------------------+
|                        [INTERVAL '01' SE...|
+--------------------------------------------+

-- percentile_cont
SELECT percentile_cont(0.25) WITHIN GROUP (ORDER BY col) FROM VALUES (0), (10) AS tab(col);
+-------------------------------------------------+
|percentile_cont(0.25) WITHIN GROUP (ORDER BY col)|
+-------------------------------------------------+
|                                              2.5|
+-------------------------------------------------+

SELECT percentile_cont(0.25) WITHIN GROUP (ORDER BY col) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH) AS tab(col);
+-------------------------------------------------+
|percentile_cont(0.25) WITHIN GROUP (ORDER BY col)|
+-------------------------------------------------+
|                             INTERVAL '0-2' YE...|
+-------------------------------------------------+

-- percentile_disc
SELECT percentile_disc(0.25) WITHIN GROUP (ORDER BY col) FROM VALUES (0), (10) AS tab(col);
+-------------------------------------------------+
|percentile_disc(0.25) WITHIN GROUP (ORDER BY col)|
+-------------------------------------------------+
|                                              0.0|
+-------------------------------------------------+

SELECT percentile_disc(0.25) WITHIN GROUP (ORDER BY col) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH) AS tab(col);
+-------------------------------------------------+
|percentile_disc(0.25) WITHIN GROUP (ORDER BY col)|
+-------------------------------------------------+
|                             INTERVAL '0-0' YE...|
+-------------------------------------------------+

-- regr_avgx
SELECT regr_avgx(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
+---------------+
|regr_avgx(y, x)|
+---------------+
|           2.75|
+---------------+

SELECT regr_avgx(y, x) FROM VALUES (1, null) AS tab(y, x);
+---------------+
|regr_avgx(y, x)|
+---------------+
|           NULL|
+---------------+

SELECT regr_avgx(y, x) FROM VALUES (null, 1) AS tab(y, x);
+---------------+
|regr_avgx(y, x)|
+---------------+
|           NULL|
+---------------+

SELECT regr_avgx(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
+---------------+
|regr_avgx(y, x)|
+---------------+
|            3.0|
+---------------+

SELECT regr_avgx(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
+---------------+
|regr_avgx(y, x)|
+---------------+
|            3.0|
+---------------+

-- regr_avgy
SELECT regr_avgy(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
+---------------+
|regr_avgy(y, x)|
+---------------+
|           1.75|
+---------------+

SELECT regr_avgy(y, x) FROM VALUES (1, null) AS tab(y, x);
+---------------+
|regr_avgy(y, x)|
+---------------+
|           NULL|
+---------------+

SELECT regr_avgy(y, x) FROM VALUES (null, 1) AS tab(y, x);
+---------------+
|regr_avgy(y, x)|
+---------------+
|           NULL|
+---------------+

SELECT regr_avgy(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
+------------------+
|   regr_avgy(y, x)|
+------------------+
|1.6666666666666667|
+------------------+

SELECT regr_avgy(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
+---------------+
|regr_avgy(y, x)|
+---------------+
|            1.5|
+---------------+

-- regr_count
SELECT regr_count(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
+----------------+
|regr_count(y, x)|
+----------------+
|               4|
+----------------+

SELECT regr_count(y, x) FROM VALUES (1, null) AS tab(y, x);
+----------------+
|regr_count(y, x)|
+----------------+
|               0|
+----------------+

SELECT regr_count(y, x) FROM VALUES (null, 1) AS tab(y, x);
+----------------+
|regr_count(y, x)|
+----------------+
|               0|
+----------------+

SELECT regr_count(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
+----------------+
|regr_count(y, x)|
+----------------+
|               3|
+----------------+

SELECT regr_count(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
+----------------+
|regr_count(y, x)|
+----------------+
|               2|
+----------------+

-- regr_intercept
SELECT regr_intercept(y, x) FROM VALUES (1, 1), (2, 2), (3, 3), (4, 4) AS tab(y, x);
+--------------------+
|regr_intercept(y, x)|
+--------------------+
|                 0.0|
+--------------------+

SELECT regr_intercept(y, x) FROM VALUES (1, null) AS tab(y, x);
+--------------------+
|regr_intercept(y, x)|
+--------------------+
|                NULL|
+--------------------+

SELECT regr_intercept(y, x) FROM VALUES (null, 1) AS tab(y, x);
+--------------------+
|regr_intercept(y, x)|
+--------------------+
|                NULL|
+--------------------+

SELECT regr_intercept(y, x) FROM VALUES (1, 1), (2, null), (3, 3), (4, 4) AS tab(y, x);
+--------------------+
|regr_intercept(y, x)|
+--------------------+
|                 0.0|
+--------------------+

SELECT regr_intercept(y, x) FROM VALUES (1, 1), (2, null), (null, 3), (4, 4) AS tab(y, x);
+--------------------+
|regr_intercept(y, x)|
+--------------------+
|                 0.0|
+--------------------+

-- regr_r2
SELECT regr_r2(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
+------------------+
|     regr_r2(y, x)|
+------------------+
|0.2727272727272726|
+------------------+

SELECT regr_r2(y, x) FROM VALUES (1, null) AS tab(y, x);
+-------------+
|regr_r2(y, x)|
+-------------+
|         NULL|
+-------------+

SELECT regr_r2(y, x) FROM VALUES (null, 1) AS tab(y, x);
+-------------+
|regr_r2(y, x)|
+-------------+
|         NULL|
+-------------+

SELECT regr_r2(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
+------------------+
|     regr_r2(y, x)|
+------------------+
|0.7500000000000001|
+------------------+

SELECT regr_r2(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
+-------------+
|regr_r2(y, x)|
+-------------+
|          1.0|
+-------------+

-- regr_slope
SELECT regr_slope(y, x) FROM VALUES (1, 1), (2, 2), (3, 3), (4, 4) AS tab(y, x);
+----------------+
|regr_slope(y, x)|
+----------------+
|             1.0|
+----------------+

SELECT regr_slope(y, x) FROM VALUES (1, null) AS tab(y, x);
+----------------+
|regr_slope(y, x)|
+----------------+
|            NULL|
+----------------+

SELECT regr_slope(y, x) FROM VALUES (null, 1) AS tab(y, x);
+----------------+
|regr_slope(y, x)|
+----------------+
|            NULL|
+----------------+

SELECT regr_slope(y, x) FROM VALUES (1, 1), (2, null), (3, 3), (4, 4) AS tab(y, x);
+----------------+
|regr_slope(y, x)|
+----------------+
|             1.0|
+----------------+

SELECT regr_slope(y, x) FROM VALUES (1, 1), (2, null), (null, 3), (4, 4) AS tab(y, x);
+----------------+
|regr_slope(y, x)|
+----------------+
|             1.0|
+----------------+

-- regr_sxx
SELECT regr_sxx(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
+------------------+
|    regr_sxx(y, x)|
+------------------+
|2.7499999999999996|
+------------------+

SELECT regr_sxx(y, x) FROM VALUES (1, null) AS tab(y, x);
+--------------+
|regr_sxx(y, x)|
+--------------+
|          NULL|
+--------------+

SELECT regr_sxx(y, x) FROM VALUES (null, 1) AS tab(y, x);
+--------------+
|regr_sxx(y, x)|
+--------------+
|          NULL|
+--------------+

SELECT regr_sxx(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
+--------------+
|regr_sxx(y, x)|
+--------------+
|           2.0|
+--------------+

SELECT regr_sxx(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
+--------------+
|regr_sxx(y, x)|
+--------------+
|           2.0|
+--------------+

-- regr_sxy
SELECT regr_sxy(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
+------------------+
|    regr_sxy(y, x)|
+------------------+
|0.7499999999999998|
+------------------+

SELECT regr_sxy(y, x) FROM VALUES (1, null) AS tab(y, x);
+--------------+
|regr_sxy(y, x)|
+--------------+
|          NULL|
+--------------+

SELECT regr_sxy(y, x) FROM VALUES (null, 1) AS tab(y, x);
+--------------+
|regr_sxy(y, x)|
+--------------+
|          NULL|
+--------------+

SELECT regr_sxy(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
+--------------+
|regr_sxy(y, x)|
+--------------+
|           1.0|
+--------------+

SELECT regr_sxy(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
+--------------+
|regr_sxy(y, x)|
+--------------+
|           1.0|
+--------------+

-- regr_syy
SELECT regr_syy(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);
+------------------+
|    regr_syy(y, x)|
+------------------+
|0.7499999999999999|
+------------------+

SELECT regr_syy(y, x) FROM VALUES (1, null) AS tab(y, x);
+--------------+
|regr_syy(y, x)|
+--------------+
|          NULL|
+--------------+

SELECT regr_syy(y, x) FROM VALUES (null, 1) AS tab(y, x);
+--------------+
|regr_syy(y, x)|
+--------------+
|          NULL|
+--------------+

SELECT regr_syy(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);
+------------------+
|    regr_syy(y, x)|
+------------------+
|0.6666666666666666|
+------------------+

SELECT regr_syy(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);
+--------------+
|regr_syy(y, x)|
+--------------+
|           0.5|
+--------------+

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

SELECT skewness(col) FROM VALUES (-1000), (-100), (10), (20) AS tab(col);
+-------------------+
|      skewness(col)|
+-------------------+
|-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(col)|
+--------+
|     1.0|
+--------+

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

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

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

-- string_agg
SELECT string_agg(col) FROM VALUES ('a'), ('b'), ('c') AS tab(col);
+---------------------+
|string_agg(col, NULL)|
+---------------------+
|                  abc|
+---------------------+

SELECT string_agg(col) WITHIN GROUP (ORDER BY col DESC) FROM VALUES ('a'), ('b'), ('c') AS tab(col);
+--------------------------------------------------------------+
|listagg(col, NULL) WITHIN GROUP (ORDER BY col DESC NULLS LAST)|
+--------------------------------------------------------------+
|                                                           cba|
+--------------------------------------------------------------+

SELECT string_agg(col) FROM VALUES ('a'), (NULL), ('b') AS tab(col);
+---------------------+
|string_agg(col, NULL)|
+---------------------+
|                   ab|
+---------------------+

SELECT string_agg(col) FROM VALUES ('a'), ('a') AS tab(col);
+---------------------+
|string_agg(col, NULL)|
+---------------------+
|                   aa|
+---------------------+

SELECT string_agg(DISTINCT col) FROM VALUES ('a'), ('a'), ('b') AS tab(col);
+------------------------------+
|string_agg(DISTINCT col, NULL)|
+------------------------------+
|                            ab|
+------------------------------+

SELECT string_agg(col, ', ') FROM VALUES ('a'), ('b'), ('c') AS tab(col);
+-------------------+
|string_agg(col, , )|
+-------------------+
|            a, b, c|
+-------------------+

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

-- 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|
+--------+

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

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

SELECT try_avg(col) FROM VALUES (interval '2147483647 months'), (interval '1 months') AS tab(col);
+------------+
|try_avg(col)|
+------------+
|        NULL|
+------------+

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

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

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

SELECT try_sum(col) FROM VALUES (9223372036854775807L), (1L) AS tab(col);
+------------+
|try_sum(col)|
+------------+
|        NULL|
+------------+

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

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

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

ウィンドウ関数

関数	説明
cume_dist()	パーティション内のすべての値に対する値の位置を計算します。
dense_rank()	値のグループ内での値のランクを計算します。結果は、以前に割り当てられたランク値に 1 を加えたものです。rank 関数とは異なり、dense_rank はランク付けシーケンスにギャップを生成しません。
lag(input[, offset[, default]])	ウィンドウ内の現在の行より `offset` 行前の `input` の値を返します。`offset` のデフォルト値は 1 で、`default` のデフォルト値は null です。`offset` 行の `input` の値が null の場合、null を返します。そのようなオフセット行がない場合（例: オフセットが 1 で、ウィンドウの最初の行に前の行がない場合）、`default` を返します。
lead(input[, offset[, default]])	ウィンドウ内の現在の行より `offset` 行後の `input` の値を返します。`offset` のデフォルト値は 1 で、`default` のデフォルト値は null です。`offset` 行の `input` の値が null の場合、null を返します。そのようなオフセット行がない場合（例: オフセットが 1 で、ウィンドウの最後の行に後続の行がない場合）、`default` を返します。
nth_value(input[, offset])	ウィンドウフレームの先頭から `offset` 番目の行の値 `input` を返します。オフセットは 1 から始まります。ignoreNulls=true の場合、`offset` 番目の行を見つけるときに null をスキップします。それ以外の場合は、すべての行が `offset` としてカウントされます。そのような `offset` 番目の行がない場合（例: オフセットが 10 で、ウィンドウフレームのサイズが 10 未満の場合）、null を返します。
ntile(n)	各ウィンドウパーティションの行を `n` 個のバケット（1 から最大 `n`）に分割します。
percent_rank()	値のグループ内での値のパーセンタイルランクを計算します。
rank()	値のグループ内での値のランクを計算します。結果は、パーティションの順序付けにおいて現在の行の前または等しい行の数に 1 を加えたものです。値はシーケンスにギャップを生成します。
row_number()	ウィンドウパーティション内の行の順序に従って、1 から始まる一意の連番を各行に割り当てます。

例

-- cume_dist
SELECT a, b, cume_dist() OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
+---+---+--------------------------------------------------------------------------------------------------------------+
|  a|  b|cume_dist() OVER (PARTITION BY a ORDER BY b ASC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+---+---+--------------------------------------------------------------------------------------------------------------+
| A1|  1|                                                                                            0.6666666666666666|
| A1|  1|                                                                                            0.6666666666666666|
| A1|  2|                                                                                                           1.0|
| A2|  3|                                                                                                           1.0|
+---+---+--------------------------------------------------------------------------------------------------------------+

-- dense_rank
SELECT a, b, dense_rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
+---+---+--------------------------------------------------------------------------------------------------------------+
|  a|  b|DENSE_RANK() OVER (PARTITION BY a ORDER BY b ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+---+---+--------------------------------------------------------------------------------------------------------------+
| A1|  1|                                                                                                             1|
| A1|  1|                                                                                                             1|
| A1|  2|                                                                                                             2|
| A2|  3|                                                                                                             1|
+---+---+--------------------------------------------------------------------------------------------------------------+

-- lag
SELECT a, b, lag(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
+---+---+-----------------------------------------------------------------------------------------------------------+
|  a|  b|lag(b, 1, NULL) OVER (PARTITION BY a ORDER BY b ASC NULLS FIRST ROWS BETWEEN -1 FOLLOWING AND -1 FOLLOWING)|
+---+---+-----------------------------------------------------------------------------------------------------------+
| A1|  1|                                                                                                       NULL|
| A1|  1|                                                                                                          1|
| A1|  2|                                                                                                          1|
| A2|  3|                                                                                                       NULL|
+---+---+-----------------------------------------------------------------------------------------------------------+

-- lead
SELECT a, b, lead(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
+---+---+----------------------------------------------------------------------------------------------------------+
|  a|  b|lead(b, 1, NULL) OVER (PARTITION BY a ORDER BY b ASC NULLS FIRST ROWS BETWEEN 1 FOLLOWING AND 1 FOLLOWING)|
+---+---+----------------------------------------------------------------------------------------------------------+
| A1|  1|                                                                                                         1|
| A1|  1|                                                                                                         2|
| A1|  2|                                                                                                      NULL|
| A2|  3|                                                                                                      NULL|
+---+---+----------------------------------------------------------------------------------------------------------+

-- nth_value
SELECT a, b, nth_value(b, 2) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
+---+---+------------------------------------------------------------------------------------------------------------------+
|  a|  b|nth_value(b, 2) OVER (PARTITION BY a ORDER BY b ASC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+---+---+------------------------------------------------------------------------------------------------------------------+
| A1|  1|                                                                                                                 1|
| A1|  1|                                                                                                                 1|
| A1|  2|                                                                                                                 1|
| A2|  3|                                                                                                              NULL|
+---+---+------------------------------------------------------------------------------------------------------------------+

-- ntile
SELECT a, b, ntile(2) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
+---+---+----------------------------------------------------------------------------------------------------------+
|  a|  b|ntile(2) OVER (PARTITION BY a ORDER BY b ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+---+---+----------------------------------------------------------------------------------------------------------+
| A1|  1|                                                                                                         1|
| A1|  1|                                                                                                         1|
| A1|  2|                                                                                                         2|
| A2|  3|                                                                                                         1|
+---+---+----------------------------------------------------------------------------------------------------------+

-- percent_rank
SELECT a, b, percent_rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
+---+---+----------------------------------------------------------------------------------------------------------------+
|  a|  b|PERCENT_RANK() OVER (PARTITION BY a ORDER BY b ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+---+---+----------------------------------------------------------------------------------------------------------------+
| A1|  1|                                                                                                             0.0|
| A1|  1|                                                                                                             0.0|
| A1|  2|                                                                                                             1.0|
| A2|  3|                                                                                                             0.0|
+---+---+----------------------------------------------------------------------------------------------------------------+

-- rank
SELECT a, b, rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
+---+---+--------------------------------------------------------------------------------------------------------+
|  a|  b|RANK() OVER (PARTITION BY a ORDER BY b ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+---+---+--------------------------------------------------------------------------------------------------------+
| A1|  1|                                                                                                       1|
| A1|  1|                                                                                                       1|
| A1|  2|                                                                                                       3|
| A2|  3|                                                                                                       1|
+---+---+--------------------------------------------------------------------------------------------------------+

-- row_number
SELECT a, b, row_number() OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);
+---+---+--------------------------------------------------------------------------------------------------------------+
|  a|  b|row_number() OVER (PARTITION BY a ORDER BY b ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+---+---+--------------------------------------------------------------------------------------------------------------+
| A1|  1|                                                                                                             1|
| A1|  1|                                                                                                             2|
| A1|  2|                                                                                                             3|
| A2|  3|                                                                                                             1|
+---+---+--------------------------------------------------------------------------------------------------------------+

配列関数

関数	説明
array(expr, ...)	指定された要素を持つ配列を返します。
array_append(array, element)	最初の引数として渡された配列の末尾に要素を追加します。要素の型は配列の要素の型と類似している必要があります。null 要素も配列に追加されます。ただし、配列が null の場合、出力は null になります。
array_compact(array)	配列から null 値を削除します。
array_contains(array, value)	配列に値が含まれている場合は true を返します。
array_distinct(array)	配列から重複する値を削除します。
array_except(array1, array2)	array1 には存在するが array2 には存在しない要素の配列を、重複なしで返します。
array_insert(x, pos, val)	`x` 配列のインデックス `pos` に `val` を配置します。配列のインデックスは 1 から始まります。最も小さい負のインデックスは -1 で、この場合、関数は最後の要素の後に新しい要素を挿入します。配列サイズを超えるインデックスは、配列を末尾に追加するか、インデックスが負の場合は配列を先頭に追加し、「null」要素を挿入します。
array_intersect(array1, array2)	array1 と array2 の共通部分の要素の配列を、重複なしで返します。
array_join(array, delimiter[, nullReplacement])	指定された配列の要素を区切り文字と、null を置き換えるためのオプションの文字列を使用して連結します。nullReplacement の値が設定されていない場合、null 値はすべてフィルタリングされます。
array_max(array)	配列内の最大値を返します。double/float 型の場合、NaN は他の非 NaN 要素よりも大きいと見なされます。null 要素はスキップされます。
array_min(array)	配列内の最小値を返します。double/float 型の場合、NaN は他の非 NaN 要素よりも大きいと見なされます。null 要素はスキップされます。
array_position(array, element)	一致する最初の要素の（1 ベースの）インデックスを long 型で返します。一致が見つからない場合は 0 を返します。
array_prepend(array, element)	最初の引数として渡された配列の先頭に要素を追加します。要素の型は配列の要素の型と同じである必要があります。null 要素も配列の先頭に追加されます。ただし、配列が null の場合、出力は null になります。
array_remove(array, element)	要素と等しいすべての要素を配列から削除します。
array_repeat(element, count)	要素を count 回含む配列を返します。
array_size(expr)	配列のサイズを返します。関数は、null 入力に対して null を返します。
array_union(array1, array2)	array1 と array2 の和集合の要素の配列を、重複なしで返します。
arrays_overlap(a1, a2)	a1 に a2 にも存在する非 null 要素が少なくとも 1 つ含まれている場合は true を返します。配列に共通の要素がなく、両方が空でなく、いずれかに null 要素が含まれている場合、null を返します。それ以外の場合は false を返します。
arrays_zip(a1, a2, ...)	入力配列の N 番目のすべての値を含む N 番目の構造体を持つ構造体のマージされた配列を返します。
flatten(arrayOfArrays)	配列の配列を 1 つの配列に変換します。
get(array, index)	指定された（0 ベースの）インデックスの配列の要素を返します。インデックスが配列の境界外を指す場合、この関数は NULL を返します。
sequence(start, stop, step)	start から stop まで（両端を含む）、step で増加する要素の配列を生成します。返される要素の型は、引数式の型と同じです。サポートされている型は、byte、short、integer、long、date、timestamp です。start および stop 式は同じ型に解決される必要があります。start および stop 式が 'date' または 'timestamp' 型に解決される場合、step 式は 'interval' または 'year-month interval' または 'day-time interval' 型に解決される必要があります。それ以外の場合は、start および stop 式と同じ型に解決される必要があります。
shuffle(array)	指定された配列のランダムな順列を返します。
slice(x, start, length)	配列 `x` をインデックス `start` (配列のインデックスは 1 から始まるか、`start` が負の場合は末尾から始まる) から指定された `length` で部分的に取得します。
sort_array(array[, ascendingOrder])	配列要素の自然順序に従って、入力配列を昇順または降順にソートします。double/float 型の場合、NaN は他の非 NaN 要素よりも大きいと見なされます。null 要素は、昇順では返される配列の先頭に、降順では末尾に配置されます。

例

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

-- array_append
SELECT array_append(array('b', 'd', 'c', 'a'), 'd');
+----------------------------------+
|array_append(array(b, d, c, a), d)|
+----------------------------------+
|                   [b, d, c, a, d]|
+----------------------------------+

SELECT array_append(array(1, 2, 3, null), null);
+----------------------------------------+
|array_append(array(1, 2, 3, NULL), NULL)|
+----------------------------------------+
|                    [1, 2, 3, NULL, N...|
+----------------------------------------+

SELECT array_append(CAST(null as Array<Int>), 2);
+---------------------+
|array_append(NULL, 2)|
+---------------------+
|                 NULL|
+---------------------+

-- array_compact
SELECT array_compact(array(1, 2, 3, null));
+-----------------------------------+
|array_compact(array(1, 2, 3, NULL))|
+-----------------------------------+
|                          [1, 2, 3]|
+-----------------------------------+

SELECT array_compact(array("a", "b", "c"));
+-----------------------------+
|array_compact(array(a, b, c))|
+-----------------------------+
|                    [a, b, c]|
+-----------------------------+

-- 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, NULL, 3))|
+---------------------------------------+
|                        [1, 2, 3, NULL]|
+---------------------------------------+

-- 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_insert
SELECT array_insert(array(1, 2, 3, 4), 5, 5);
+-------------------------------------+
|array_insert(array(1, 2, 3, 4), 5, 5)|
+-------------------------------------+
|                      [1, 2, 3, 4, 5]|
+-------------------------------------+

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

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

-- 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, NULL, world),  )|
+----------------------------------------+
|                             hello world|
+----------------------------------------+

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

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

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

-- array_position
SELECT array_position(array(312, 773, 708, 708), 708);
+----------------------------------------------+
|array_position(array(312, 773, 708, 708), 708)|
+----------------------------------------------+
|                                             3|
+----------------------------------------------+

SELECT array_position(array(312, 773, 708, 708), 414);
+----------------------------------------------+
|array_position(array(312, 773, 708, 708), 414)|
+----------------------------------------------+
|                                             0|
+----------------------------------------------+

-- array_prepend
SELECT array_prepend(array('b', 'd', 'c', 'a'), 'd');
+-----------------------------------+
|array_prepend(array(b, d, c, a), d)|
+-----------------------------------+
|                    [d, b, d, c, a]|
+-----------------------------------+

SELECT array_prepend(array(1, 2, 3, null), null);
+-----------------------------------------+
|array_prepend(array(1, 2, 3, NULL), NULL)|
+-----------------------------------------+
|                     [NULL, 1, 2, 3, N...|
+-----------------------------------------+

SELECT array_prepend(CAST(null as Array<Int>), 2);
+----------------------+
|array_prepend(NULL, 2)|
+----------------------+
|                  NULL|
+----------------------+

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

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

-- array_size
SELECT array_size(array('b', 'd', 'c', 'a'));
+-----------------------------+
|array_size(array(b, d, c, a))|
+-----------------------------+
|                            4|
+-----------------------------+

-- 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...|
+-------------------------------------------------+

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

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

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

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

-- 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' MONTH)|
+----------------------------------------------------------------------+
|                                                  [2018-01-01, 2018...|
+----------------------------------------------------------------------+

SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval '0-1' year to month);
+--------------------------------------------------------------------------------+
|sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '0-1' YEAR TO MONTH)|
+--------------------------------------------------------------------------------+
|                                                            [2018-01-01, 2018...|
+--------------------------------------------------------------------------------+

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

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

-- 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, NULL, c, a), true)|
+-----------------------------------------+
|                       [NULL, a, b, c, d]|
+-----------------------------------------+

SELECT sort_array(array('b', 'd', null, 'c', 'a'), false);
+------------------------------------------+
|sort_array(array(b, d, NULL, c, a), false)|
+------------------------------------------+
|                        [d, c, b, a, NULL]|
+------------------------------------------+

コレクション関数

関数	説明
aggregate(expr, start, merge, finish)	初期状態と配列内のすべての要素に二項演算子を適用し、これを単一の状態に削減します。最終状態は、finish 関数を適用することによって最終結果に変換されます。
array_sort(expr, func)	入力配列をソートします。`func` が省略されている場合、昇順でソートします。入力配列の要素は順序付け可能である必要があります。double/float 型の場合、NaN は他の非 NaN 要素よりも大きいと見なされます。null 要素は返される配列の末尾に配置されます。3.0.0 以降、この関数は指定された比較関数に基づいて配列をソートして返します。比較関数は、配列の 2 つの要素を表す 2 つの引数を受け取ります。最初の要素が 2 番目の要素より小さい、等しい、または大きい場合に、それぞれ負の整数、0、または正の整数を返します。比較関数が null を返した場合、関数は失敗し、エラーが発生します。
cardinality(expr)	配列またはマップのサイズを返します。この関数は、`spark.sql.ansi.enabled` が false で `spark.sql.legacy.sizeOfNull` が true の場合、null 入力に対して -1 を返します。それ以外の場合は、null 入力に対して null を返します。デフォルト設定では、関数は null 入力に対して null を返します。
concat(col1, col2, ..., colN)	col1、col2、...、colN の連結を返します。
element_at(array, index)	指定された（1 ベースの）インデックスの配列の要素を返します。インデックスが 0 の場合、Spark はエラーを発生させます。インデックスが負の場合、末尾から先頭への要素にアクセスします。`spark.sql.ansi.enabled` が false に設定されている場合、インデックスが配列の長さを超えると関数は NULL を返します。`spark.sql.ansi.enabled` が true に設定されている場合、無効なインデックスに対して ArrayIndexOutOfBoundsException がスローされます。
element_at(map, key)	指定されたキーに対する値を返します。キーがマップに含まれていない場合、関数は NULL を返します。
exists(expr, pred)	配列内の 1 つ以上の要素に対して述語が成り立つかどうかをテストします。
filter(expr, func)	指定された述語を使用して入力配列をフィルタリングします。
forall(expr, pred)	配列内のすべての要素に対して述語が成り立つかどうかをテストします。
map_filter(expr, func)	関数を使用してマップのエントリをフィルタリングします。
map_zip_with(map1, map2, function)	同じキーを持つ値のペアに関数を適用することにより、2 つの指定されたマップを 1 つのマップにマージします。一方のマップにのみ存在するキーの場合、欠落しているキーの値として NULL が渡されます。入力マップに重複するキーが含まれている場合、重複するキーの最初のエントリのみがラムダ関数に渡されます。
reduce(expr, start, merge, finish)	初期状態と配列内のすべての要素に二項演算子を適用し、これを単一の状態に削減します。最終状態は、finish 関数を適用することによって最終結果に変換されます。
reverse(array)	反転された文字列または逆順の要素を持つ配列を返します。
size(expr)	配列またはマップのサイズを返します。この関数は、`spark.sql.ansi.enabled` が false で `spark.sql.legacy.sizeOfNull` が true の場合、null 入力に対して -1 を返します。それ以外の場合は、null 入力に対して null を返します。デフォルト設定では、関数は null 入力に対して null を返します。
transform(expr, func)	関数を使用して配列の要素を変換します。
transform_keys(expr, func)	関数を使用してマップの要素を変換します。
transform_values(expr, func)	関数を使用してマップの値を変換します。
try_element_at(array, index)	指定された（1 ベースの）インデックスの配列の要素を返します。インデックスが 0 の場合、Spark はエラーを発生させます。インデックスが負の場合、末尾から先頭への要素にアクセスします。インデックスが配列の長さを超えると、関数は常に NULL を返します。
try_element_at(map, key)	指定されたキーに対する値を返します。キーがマップに含まれていない場合、関数は常に NULL を返します。
zip_with(left, right, func)	関数を使用して、2 つの指定された配列を要素ごとに 1 つの配列にマージします。一方の配列が短い場合、関数を適用する前に、長い方の配列の長さに合わせるために末尾に null が追加されます。

例

-- aggregate
SELECT aggregate(array(1, 2, 3), 0, (acc, x) -> acc + x);
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|aggregate(array(1, 2, 3), 0, lambdafunction((namedlambdavariable() + namedlambdavariable()), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))|
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                                                                        6|
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT aggregate(array(1, 2, 3), 0, (acc, x) -> acc + x, acc -> acc * 10);
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|aggregate(array(1, 2, 3), 0, lambdafunction((namedlambdavariable() + namedlambdavariable()), namedlambdavariable(), namedlambdavariable()), lambdafunction((namedlambdavariable() * 10), namedlambdavariable()))|
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                                                                              60|
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

-- array_sort
SELECT array_sort(array(5, 6, 1), (left, right) -> case when left < right then -1 when left > right then 1 else 0 end);
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|array_sort(array(5, 6, 1), lambdafunction(CASE WHEN (namedlambdavariable() < namedlambdavariable()) THEN -1 WHEN (namedlambdavariable() > namedlambdavariable()) THEN 1 ELSE 0 END, namedlambdavariable(), namedlambdavariable()))|
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                                                                                         [1, 5, 6]|
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT array_sort(array('bc', 'ab', 'dc'), (left, right) -> case when left is null and right is null then 0 when left is null then -1 when right is null then 1 when left < right then 1 when left > right then -1 else 0 end);
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|array_sort(array(bc, ab, dc), lambdafunction(CASE WHEN ((namedlambdavariable() IS NULL) AND (namedlambdavariable() IS NULL)) THEN 0 WHEN (namedlambdavariable() IS NULL) THEN -1 WHEN (namedlambdavariable() IS NULL) THEN 1 WHEN (namedlambdavariable() < namedlambdavariable()) THEN 1 WHEN (namedlambdavariable() > namedlambdavariable()) THEN -1 ELSE 0 END, namedlambdavariable(), namedlambdavariable()))|
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                                                                                                                                                                                                                                                                    [dc, bc, ab]|
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT array_sort(array('b', 'd', null, 'c', 'a'));
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|array_sort(array(b, d, NULL, c, a), lambdafunction((IF(((namedlambdavariable() IS NULL) AND (namedlambdavariable() IS NULL)), 0, (IF((namedlambdavariable() IS NULL), 1, (IF((namedlambdavariable() IS NULL), -1, (IF((namedlambdavariable() < namedlambdavariable()), -1, (IF((namedlambdavariable() > namedlambdavariable()), 1, 0)))))))))), namedlambdavariable(), namedlambdavariable()))|
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                                                                                                                                                                                                                                            [a, b, c, d, NULL]|
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

-- cardinality
SELECT cardinality(array('b', 'd', 'c', 'a'));
+------------------------------+
|cardinality(array(b, d, c, a))|
+------------------------------+
|                             4|
+------------------------------+

SELECT cardinality(map('a', 1, 'b', 2));
+----------------------------+
|cardinality(map(a, 1, b, 2))|
+----------------------------+
|                           2|
+----------------------------+

-- 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]|
+---------------------------------------------+

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

SELECT element_at(map(1, 'a', 2, 'b'), 2);
+------------------------------+
|element_at(map(1, a, 2, b), 2)|
+------------------------------+
|                             b|
+------------------------------+

-- exists
SELECT exists(array(1, 2, 3), x -> x % 2 == 0);
+------------------------------------------------------------------------------------------------+
|exists(array(1, 2, 3), lambdafunction(((namedlambdavariable() % 2) = 0), namedlambdavariable()))|
+------------------------------------------------------------------------------------------------+
|                                                                                            true|
+------------------------------------------------------------------------------------------------+

SELECT exists(array(1, 2, 3), x -> x % 2 == 10);
+-------------------------------------------------------------------------------------------------+
|exists(array(1, 2, 3), lambdafunction(((namedlambdavariable() % 2) = 10), namedlambdavariable()))|
+-------------------------------------------------------------------------------------------------+
|                                                                                            false|
+-------------------------------------------------------------------------------------------------+

SELECT exists(array(1, null, 3), x -> x % 2 == 0);
+---------------------------------------------------------------------------------------------------+
|exists(array(1, NULL, 3), lambdafunction(((namedlambdavariable() % 2) = 0), namedlambdavariable()))|
+---------------------------------------------------------------------------------------------------+
|                                                                                               NULL|
+---------------------------------------------------------------------------------------------------+

SELECT exists(array(0, null, 2, 3, null), x -> x IS NULL);
+----------------------------------------------------------------------------------------------------------+
|exists(array(0, NULL, 2, 3, NULL), lambdafunction((namedlambdavariable() IS NULL), namedlambdavariable()))|
+----------------------------------------------------------------------------------------------------------+
|                                                                                                      true|
+----------------------------------------------------------------------------------------------------------+

SELECT exists(array(1, 2, 3), x -> x IS NULL);
+----------------------------------------------------------------------------------------------+
|exists(array(1, 2, 3), lambdafunction((namedlambdavariable() IS NULL), namedlambdavariable()))|
+----------------------------------------------------------------------------------------------+
|                                                                                         false|
+----------------------------------------------------------------------------------------------+

-- filter
SELECT filter(array(1, 2, 3), x -> x % 2 == 1);
+------------------------------------------------------------------------------------------------+
|filter(array(1, 2, 3), lambdafunction(((namedlambdavariable() % 2) = 1), namedlambdavariable()))|
+------------------------------------------------------------------------------------------------+
|                                                                                          [1, 3]|
+------------------------------------------------------------------------------------------------+

SELECT filter(array(0, 2, 3), (x, i) -> x > i);
+-------------------------------------------------------------------------------------------------------------------------------------+
|filter(array(0, 2, 3), lambdafunction((namedlambdavariable() > namedlambdavariable()), namedlambdavariable(), namedlambdavariable()))|
+-------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                               [2, 3]|
+-------------------------------------------------------------------------------------------------------------------------------------+

SELECT filter(array(0, null, 2, 3, null), x -> x IS NOT NULL);
+--------------------------------------------------------------------------------------------------------------+
|filter(array(0, NULL, 2, 3, NULL), lambdafunction((namedlambdavariable() IS NOT NULL), namedlambdavariable()))|
+--------------------------------------------------------------------------------------------------------------+
|                                                                                                     [0, 2, 3]|
+--------------------------------------------------------------------------------------------------------------+

-- forall
SELECT forall(array(1, 2, 3), x -> x % 2 == 0);
+------------------------------------------------------------------------------------------------+
|forall(array(1, 2, 3), lambdafunction(((namedlambdavariable() % 2) = 0), namedlambdavariable()))|
+------------------------------------------------------------------------------------------------+
|                                                                                           false|
+------------------------------------------------------------------------------------------------+

SELECT forall(array(2, 4, 8), x -> x % 2 == 0);
+------------------------------------------------------------------------------------------------+
|forall(array(2, 4, 8), lambdafunction(((namedlambdavariable() % 2) = 0), namedlambdavariable()))|
+------------------------------------------------------------------------------------------------+
|                                                                                            true|
+------------------------------------------------------------------------------------------------+

SELECT forall(array(1, null, 3), x -> x % 2 == 0);
+---------------------------------------------------------------------------------------------------+
|forall(array(1, NULL, 3), lambdafunction(((namedlambdavariable() % 2) = 0), namedlambdavariable()))|
+---------------------------------------------------------------------------------------------------+
|                                                                                              false|
+---------------------------------------------------------------------------------------------------+

SELECT forall(array(2, null, 8), x -> x % 2 == 0);
+---------------------------------------------------------------------------------------------------+
|forall(array(2, NULL, 8), lambdafunction(((namedlambdavariable() % 2) = 0), namedlambdavariable()))|
+---------------------------------------------------------------------------------------------------+
|                                                                                               NULL|
+---------------------------------------------------------------------------------------------------+

-- map_filter
SELECT map_filter(map(1, 0, 2, 2, 3, -1), (k, v) -> k > v);
+-------------------------------------------------------------------------------------------------------------------------------------------------+
|map_filter(map(1, 0, 2, 2, 3, -1), lambdafunction((namedlambdavariable() > namedlambdavariable()), namedlambdavariable(), namedlambdavariable()))|
+-------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                {1 -> 0, 3 -> -1}|
+-------------------------------------------------------------------------------------------------------------------------------------------------+

-- map_zip_with
SELECT map_zip_with(map(1, 'a', 2, 'b'), map(1, 'x', 2, 'y'), (k, v1, v2) -> concat(v1, v2));
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|map_zip_with(map(1, a, 2, b), map(1, x, 2, y), lambdafunction(concat(namedlambdavariable(), namedlambdavariable()), namedlambdavariable(), namedlambdavariable(), namedlambdavariable()))|
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                                       {1 -> ax, 2 -> by}|
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT map_zip_with(map('a', 1, 'b', 2), map('b', 3, 'c', 4), (k, v1, v2) -> coalesce(v1, 0) + coalesce(v2, 0));
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|map_zip_with(map(a, 1, b, 2), map(b, 3, c, 4), lambdafunction((coalesce(namedlambdavariable(), 0) + coalesce(namedlambdavariable(), 0)), namedlambdavariable(), namedlambdavariable(), namedlambdavariable()))|
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                                                          {a -> 1, b -> 5, ...|
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

-- reduce
SELECT reduce(array(1, 2, 3), 0, (acc, x) -> acc + x);
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|reduce(array(1, 2, 3), 0, lambdafunction((namedlambdavariable() + namedlambdavariable()), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))|
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                                                                     6|
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT reduce(array(1, 2, 3), 0, (acc, x) -> acc + x, acc -> acc * 10);
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|reduce(array(1, 2, 3), 0, lambdafunction((namedlambdavariable() + namedlambdavariable()), namedlambdavariable(), namedlambdavariable()), lambdafunction((namedlambdavariable() * 10), namedlambdavariable()))|
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                                                                           60|
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

-- 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]|
+--------------------------+

-- size
SELECT size(array('b', 'd', 'c', 'a'));
+-----------------------+
|size(array(b, d, c, a))|
+-----------------------+
|                      4|
+-----------------------+

SELECT size(map('a', 1, 'b', 2));
+---------------------+
|size(map(a, 1, b, 2))|
+---------------------+
|                    2|
+---------------------+

-- transform
SELECT transform(array(1, 2, 3), x -> x + 1);
+---------------------------------------------------------------------------------------------+
|transform(array(1, 2, 3), lambdafunction((namedlambdavariable() + 1), namedlambdavariable()))|
+---------------------------------------------------------------------------------------------+
|                                                                                    [2, 3, 4]|
+---------------------------------------------------------------------------------------------+

SELECT transform(array(1, 2, 3), (x, i) -> x + i);
+----------------------------------------------------------------------------------------------------------------------------------------+
|transform(array(1, 2, 3), lambdafunction((namedlambdavariable() + namedlambdavariable()), namedlambdavariable(), namedlambdavariable()))|
+----------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                               [1, 3, 5]|
+----------------------------------------------------------------------------------------------------------------------------------------+

-- transform_keys
SELECT transform_keys(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), (k, v) -> k + 1);
+----------------------------------------------------------------------------------------------------------------------------------------------------------+
|transform_keys(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), lambdafunction((namedlambdavariable() + 1), namedlambdavariable(), namedlambdavariable()))|
+----------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                      {2 -> 1, 3 -> 2, ...|
+----------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT transform_keys(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), (k, v) -> k + v);
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|transform_keys(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), lambdafunction((namedlambdavariable() + namedlambdavariable()), namedlambdavariable(), namedlambdavariable()))|
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                          {2 -> 1, 4 -> 2, ...|
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

-- transform_values
SELECT transform_values(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), (k, v) -> v + 1);
+------------------------------------------------------------------------------------------------------------------------------------------------------------+
|transform_values(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), lambdafunction((namedlambdavariable() + 1), namedlambdavariable(), namedlambdavariable()))|
+------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                        {1 -> 2, 2 -> 3, ...|
+------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT transform_values(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), (k, v) -> k + v);
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|transform_values(map_from_arrays(array(1, 2, 3), array(1, 2, 3)), lambdafunction((namedlambdavariable() + namedlambdavariable()), namedlambdavariable(), namedlambdavariable()))|
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                            {1 -> 2, 2 -> 4, ...|
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

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

SELECT try_element_at(map(1, 'a', 2, 'b'), 2);
+----------------------------------+
|try_element_at(map(1, a, 2, b), 2)|
+----------------------------------+
|                                 b|
+----------------------------------+

-- zip_with
SELECT zip_with(array(1, 2, 3), array('a', 'b', 'c'), (x, y) -> (y, x));
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|zip_with(array(1, 2, 3), array(a, b, c), lambdafunction(named_struct(y, namedlambdavariable(), x, namedlambdavariable()), namedlambdavariable(), namedlambdavariable()))|
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                    [{a, 1}, {b, 2}, ...|
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT zip_with(array(1, 2), array(3, 4), (x, y) -> x + y);
+-------------------------------------------------------------------------------------------------------------------------------------------------+
|zip_with(array(1, 2), array(3, 4), lambdafunction((namedlambdavariable() + namedlambdavariable()), namedlambdavariable(), namedlambdavariable()))|
+-------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                           [4, 6]|
+-------------------------------------------------------------------------------------------------------------------------------------------------+

SELECT zip_with(array('a', 'b', 'c'), array('d', 'e', 'f'), (x, y) -> concat(x, y));
+------------------------------------------------------------------------------------------------------------------------------------------------------------+
|zip_with(array(a, b, c), array(d, e, f), lambdafunction(concat(namedlambdavariable(), namedlambdavariable()), namedlambdavariable(), namedlambdavariable()))|
+------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                                [ad, be, cf]|
+------------------------------------------------------------------------------------------------------------------------------------------------------------+

構造体関数

関数	説明
named_struct(name1, val1, name2, val2, ...)	指定されたフィールド名と値を持つ構造体を作成します。
struct(col1, col2, col3, ...)	指定されたフィールド値を持つ構造体を作成します。

例

-- named_struct
SELECT named_struct("a", 1, "b", 2, "c", 3);
+------------------------------+
|named_struct(a, 1, b, 2, c, 3)|
+------------------------------+
|                     {1, 2, 3}|
+------------------------------+

-- struct
SELECT struct(1, 2, 3);
+---------------+
|struct(1, 2, 3)|
+---------------+
|      {1, 2, 3}|
+---------------+

マップ関数

関数	説明
map(key0, value0, key1, value1, ...)	指定されたキー/値ペアを持つマップを作成します。
map_concat(map, ...)	指定されたすべてのマップの和集合を返します。
map_contains_key(map, key)	マップにキーが含まれている場合は true を返します。
map_entries(map)	指定されたマップのすべてのエントリの順序付けされていない配列を返します。
map_from_arrays(keys, values)	指定されたキー/値配列のペアを持つマップを作成します。keys のすべての要素は null であってはなりません。
map_from_entries(arrayOfEntries)	指定されたエントリ配列から作成されたマップを返します。
map_keys(map)	マップのキーを含む順序付けされていない配列を返します。
map_values(map)	マップの値を含む順序付けされていない配列を返します。
str_to_map(text[, pairDelim[, keyValueDelim]])	区切り文字を使用してテキストをキー/値ペアに分割した後、マップを作成します。デフォルトの区切り文字は `pairDelim` では ','、`keyValueDelim` では ':' です。`pairDelim` と `keyValueDelim` は両方とも正規表現として扱われます。

例

-- map
SELECT map(1.0, '2', 3.0, '4');
+--------------------+
| map(1.0, 2, 3.0, 4)|
+--------------------+
|{1.0 -> 2, 3.0 -> 4}|
+--------------------+

-- 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_contains_key
SELECT map_contains_key(map(1, 'a', 2, 'b'), 1);
+------------------------------------+
|map_contains_key(map(1, a, 2, b), 1)|
+------------------------------------+
|                                true|
+------------------------------------+

SELECT map_contains_key(map(1, 'a', 2, 'b'), 3);
+------------------------------------+
|map_contains_key(map(1, a, 2, b), 3)|
+------------------------------------+
|                               false|
+------------------------------------+

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

-- map_from_arrays
SELECT map_from_arrays(array(1.0, 3.0), array('2', '4'));
+---------------------------------------------+
|map_from_arrays(array(1.0, 3.0), array(2, 4))|
+---------------------------------------------+
|                         {1.0 -> 2, 3.0 -> 4}|
+---------------------------------------------+

-- 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]|
+---------------------------+

-- str_to_map
SELECT str_to_map('a:1,b:2,c:3', ',', ':');
+-----------------------------+
|str_to_map(a:1,b:2,c:3, ,, :)|
+-----------------------------+
|         {a -> 1, b -> 2, ...|
+-----------------------------+

SELECT str_to_map('a');
+-------------------+
|str_to_map(a, ,, :)|
+-------------------+
|        {a -> NULL}|
+-------------------+

日付とタイムスタンプ関数

関数	説明
add_months(start_date, num_months)	`start_date` から `num_months` 後ろの日付を返します。
convert_timezone([sourceTz, ]targetTz, sourceTs)	タイムゾーンなしのタイムスタンプ `sourceTs` を `sourceTz` タイムゾーンから `targetTz` に変換します。
curdate()	クエリ評価の開始時点での現在の日付を返します。同じクエリ内のすべての curdate の呼び出しは同じ値を返します。
current_date()	クエリ評価の開始時点での現在の日付を返します。同じクエリ内のすべての current_date の呼び出しは同じ値を返します。
current_date	クエリ評価の開始時点での現在の日付を返します。
current_timestamp()	クエリ評価の開始時点での現在のタイムスタンプを返します。同じクエリ内のすべての current_timestamp の呼び出しは同じ値を返します。
current_timestamp	クエリ評価の開始時点での現在のタイムスタンプを返します。
current_timezone()	現在のセッションローカルタイムゾーンを返します。
date_add(start_date, num_days)	`start_date` から `num_days` 後ろの日付を返します。
date_diff(endDate, startDate)	`startDate` から `endDate` までの日数間を返します。
date_format(timestamp, fmt)	指定された日付フォーマット `fmt` で `timestamp` を文字列値に変換します。
date_from_unix_date(days)	1970-01-01 からの日数から日付を作成します。
date_part(field, source)	日付/タイムスタンプまたは間隔ソースの一部を抽出します。
date_sub(start_date, num_days)	`start_date` から `num_days` 前の日付を返します。
date_trunc(fmt, ts)	フォーマットモデル `fmt` で指定された単位に切り捨てられたタイムスタンプ `ts` を返します。
dateadd(start_date, num_days)	`start_date` から `num_days` 後ろの日付を返します。
datediff(endDate, startDate)	`startDate` から `endDate` までの日数間を返します。
datepart(field, source)	日付/タイムスタンプまたは間隔ソースの一部を抽出します。
day(date)	日付/タイムスタンプの月の日を返します。
dayname(date)	指定された日付から 3 文字の略語の曜日名を返します。
dayofmonth(date)	日付/タイムスタンプの月の日を返します。
dayofweek(date)	日付/タイムスタンプの曜日を返します（1 = 日曜日、2 = 月曜日、...、7 = 土曜日）。
dayofyear(date)	日付/タイムスタンプの年の日を返します。
extract(field FROM source)	日付/タイムスタンプまたは間隔ソースの一部を抽出します。
from_unixtime(unix_time[, fmt])	指定された `fmt` で `unix_time` を返します。
from_utc_timestamp(timestamp, timezone)	'2017-07-14 02:40:00.0' のようなタイムスタンプを指定されたタイムゾーンで解釈し、その時刻を指定されたタイムゾーンのタイムスタンプとしてレンダリングします。たとえば、'GMT+1' は '2017-07-14 03:40:00.0' を生成します。
hour(timestamp)	文字列/タイムスタンプの時コンポーネントを返します。
last_day(date)	日付が属する月の最終日を返します。
localtimestamp()	クエリ評価の開始時点でのタイムゾーンなしの現在のタイムスタンプを返します。同じクエリ内のすべての localtimestamp の呼び出しは同じ値を返します。
localtimestamp	クエリ評価の開始時点でのセッションタイムゾーンにおける現在のローカル日時を返します。
make_date(year, month, day)	年、月、日のフィールドから日付を作成します。設定 `spark.sql.ansi.enabled` が false の場合、関数は無効な入力に対して NULL を返します。それ以外の場合は、エラーをスローします。
make_dt_interval([days[, hours[, mins[, secs]]]])	日数、時間、分、秒から DayTimeIntervalType の期間を作成します。
make_interval([years[, months[, weeks[, days[, hours[, mins[, secs]]]]]]])	年、月、週、日数、時間、分、秒から期間を作成します。
make_timestamp(year, month, day, hour, min, sec[, timezone])	年、月、日、時、分、秒、タイムゾーンのフィールドからタイムスタンプを作成します。結果のデータ型は、設定 `spark.sql.timestampType` の値と一貫しています。設定 `spark.sql.ansi.enabled` が false の場合、関数は無効な入力に対して NULL を返します。それ以外の場合は、エラーをスローします。
make_timestamp_ltz(year, month, day, hour, min, sec[, timezone])	年、月、日、時、分、秒、タイムゾーンのフィールドから、ローカルタイムゾーンを持つ現在のタイムスタンプを作成します。設定 `spark.sql.ansi.enabled` が false の場合、関数は無効な入力に対して NULL を返します。それ以外の場合は、エラーをスローします。
make_timestamp_ntz(year, month, day, hour, min, sec)	年、月、日、時、分、秒のフィールドからローカル日時を作成します。設定 `spark.sql.ansi.enabled` が false の場合、関数は無効な入力に対して NULL を返します。それ以外の場合は、エラーをスローします。
make_ym_interval([years[, months]])	年、月から年-月期間を作成します。
minute(timestamp)	文字列/タイムスタンプの分コンポーネントを返します。
month(date)	日付/タイムスタンプの月コンポーネントを返します。
monthname(date)	指定された日付から 3 文字の略語の月名を返します。
months_between(timestamp1, timestamp2[, roundOff])	`timestamp1` が `timestamp2` より後である場合、結果は正になります。`timestamp1` と `timestamp2` が月の同じ日であるか、両方が月末である場合、時刻は無視されます。それ以外の場合、差は 1 か月あたり 31 日に基づいて計算され、roundOff=false でない限り 8 桁に丸められます。
next_day(start_date, day_of_week)	`start_date` より後で指定された曜日を持つ最初の日付を返します。入力パラメータのいずれかが null の場合、関数は null を返します。両方の入力パラメータが null でなく、day_of_week が無効な入力の場合、`spark.sql.ansi.enabled` が true に設定されている場合は SparkIllegalArgumentException がスローされ、それ以外の場合は null がスローされます。
now()	クエリ評価の開始時点での現在のタイムスタンプを返します。
quarter(date)	日付の年の四半期を 1 から 4 の範囲で返します。
second(timestamp)	文字列/タイムスタンプの秒コンポーネントを返します。
session_window(time_column, gap_duration)	タイムスタンプ指定列とギャップ期間を指定してセッションウィンドウを生成します。Structured Streaming ガイドドキュメントの 'タイムウィンドウの種類' を参照して、詳細な説明と例を確認してください。
timestamp_micros(microseconds)	UTC エポックからのマイクロ秒数からタイムスタンプを作成します。
timestamp_millis(milliseconds)	UTC エポックからのミリ秒数からタイムスタンプを作成します。
timestamp_seconds(seconds)	UTC エポックからの秒数（小数部を含む）からタイムスタンプを作成します。
to_date(date_str[, fmt])	`date_str` 式を指定された `fmt` 式で解析して日付に変換します。無効な入力の場合は null を返します。デフォルトでは、`fmt` が省略されている場合、日付へのキャスト規則に従います。
to_timestamp(timestamp_str[, fmt])	`timestamp_str` 式を指定された `fmt` 式で解析してタイムスタンプに変換します。無効な入力の場合は null を返します。デフォルトでは、`fmt` が省略されている場合、タイムスタンプへのキャスト規則に従います。結果のデータ型は、設定 `spark.sql.timestampType` の値と一貫しています。
to_timestamp_ltz(timestamp_str[, fmt])	`timestamp_str` 式を指定された `fmt` 式で解析して、ローカルタイムゾーンを持つタイムスタンプに変換します。無効な入力の場合は null を返します。デフォルトでは、`fmt` が省略されている場合、タイムスタンプへのキャスト規則に従います。
to_timestamp_ntz(timestamp_str[, fmt])	`timestamp_str` 式を指定された `fmt` 式で解析して、タイムゾーンなしのタイムスタンプに変換します。無効な入力の場合は null を返します。デフォルトでは、`fmt` が省略されている場合、タイムスタンプへのキャスト規則に従います。
to_unix_timestamp(timeExp[, fmt])	指定された時刻の UNIX タイムスタンプを返します。
to_utc_timestamp(timestamp, timezone)	'2017-07-14 02:40:00.0' のようなタイムスタンプを指定されたタイムゾーンで解釈し、その時刻を UTC のタイムスタンプとしてレンダリングします。たとえば、'GMT+1' は '2017-07-14 01:40:00.0' を生成します。
trunc(date, fmt)	フォーマットモデル `fmt` で指定された単位に時刻部分が切り捨てられた日付 `date` を返します。
try_make_interval([years[, months[, weeks[, days[, hours[, mins[, secs]]]]]]])	`make_interval` の特殊バージョンで、同じ操作を実行しますが、オーバーフローが発生した場合は NULL を返します。
try_make_timestamp(year, month, day, hour, min, sec[, timezone])	年、月、日、時、分、秒、タイムゾーンのフィールドからタイムスタンプを作成しようとします。結果のデータ型は、設定 `spark.sql.timestampType` の値と一貫しています。関数は無効な入力に対して NULL を返します。
try_make_timestamp_ltz(year, month, day, hour, min, sec[, timezone])	年、月、日、時、分、秒、タイムゾーンのフィールドから、ローカルタイムゾーンを持つ現在のタイムスタンプを作成しようとします。関数は無効な入力に対して NULL を返します。
try_make_timestamp_ntz(year, month, day, hour, min, sec)	年、月、日、時、分、秒のフィールドからローカル日時を作成しようとします。関数は無効な入力に対して NULL を返します。
try_to_timestamp(timestamp_str[, fmt])	`timestamp_str` 式を指定された `fmt` 式で解析してタイムスタンプに変換します。ANSI SQL モードが有効かどうかにかかわらず、無効な入力に対して関数は常に null を返します。デフォルトでは、`fmt` が省略されている場合、タイムスタンプへのキャスト規則に従います。結果のデータ型は、設定 `spark.sql.timestampType` の値と一貫しています。
unix_date(date)	1970-01-01 からの日数を返します。
unix_micros(timestamp)	1970-01-01 00:00:00 UTC からのマイクロ秒数を返します。
unix_millis(timestamp)	1970-01-01 00:00:00 UTC からのミリ秒数を返します。より高い精度のレベルは切り捨てられます。
unix_seconds(timestamp)	1970-01-01 00:00:00 UTC からの秒数（小数部を含む）を返します。より高い精度のレベルは切り捨てられます。
unix_timestamp([timeExp[, fmt]])	現在または指定された時刻の UNIX タイムスタンプを返します。
weekday(date)	日付/タイムスタンプの曜日を返します（0 = 月曜日、1 = 火曜日、...、6 = 日曜日）。
weekofyear(date)	指定された日付の年の週を返します。週は月曜日から始まり、週 1 は 3 日を超える最初の週です。
window(time_column, window_duration[, slide_duration[, start_time]])	タイムスタンプ指定列を与えられた行を 1 つ以上の時間ウィンドウにバケット化します。ウィンドウの開始は含まれますが、ウィンドウの終了は含まれません。例: 12:05 はウィンドウ [12:05, 12:10) に含まれますが、[12:00, 12:05) には含まれません。ウィンドウはマイクロ秒の精度をサポートできます。月単位のウィンドウはサポートされていません。Structured Streaming ガイドドキュメントの 'イベントタイムのウィンドウ操作' を参照して、詳細な説明と例を確認してください。
window_time(window_column)	時間/セッションウィンドウ列から時間値を抽出し、ウィンドウのイベントタイム値として使用できます。抽出された時間は (window.end - 1) であり、集計ウィンドウが排他的な上限 [start, end) を持つという事実を反映しています。Structured Streaming ガイドドキュメントの 'イベントタイムのウィンドウ操作' を参照して、詳細な説明と例を確認してください。
year(date)	日付/タイムスタンプの年コンポーネントを返します。

例

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

-- convert_timezone
SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00');
+-------------------------------------------------------------------------------------------+
|convert_timezone(Europe/Brussels, America/Los_Angeles, TIMESTAMP_NTZ '2021-12-06 00:00:00')|
+-------------------------------------------------------------------------------------------+
|                                                                        2021-12-05 15:00:00|
+-------------------------------------------------------------------------------------------+

SELECT convert_timezone('Europe/Brussels', timestamp_ntz'2021-12-05 15:00:00');
+------------------------------------------------------------------------------------------+
|convert_timezone(current_timezone(), Europe/Brussels, TIMESTAMP_NTZ '2021-12-05 15:00:00')|
+------------------------------------------------------------------------------------------+
|                                                                       2021-12-05 16:00:00|
+------------------------------------------------------------------------------------------+

-- curdate
SELECT curdate();
+--------------+
|current_date()|
+--------------+
|    2025-05-19|
+--------------+

-- current_date
SELECT current_date();
+--------------+
|current_date()|
+--------------+
|    2025-05-19|
+--------------+

SELECT current_date;
+--------------+
|current_date()|
+--------------+
|    2025-05-19|
+--------------+

-- current_timestamp
SELECT current_timestamp();
+--------------------+
| current_timestamp()|
+--------------------+
|2025-05-19 09:07:...|
+--------------------+

SELECT current_timestamp;
+--------------------+
| current_timestamp()|
+--------------------+
|2025-05-19 09:07:...|
+--------------------+

-- current_timezone
SELECT current_timezone();
+------------------+
|current_timezone()|
+------------------+
|           Etc/UTC|
+------------------+

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

-- date_diff
SELECT date_diff('2009-07-31', '2009-07-30');
+---------------------------------+
|date_diff(2009-07-31, 2009-07-30)|
+---------------------------------+
|                                1|
+---------------------------------+

SELECT date_diff('2009-07-30', '2009-07-31');
+---------------------------------+
|date_diff(2009-07-30, 2009-07-31)|
+---------------------------------+
|                               -1|
+---------------------------------+

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

-- date_from_unix_date
SELECT date_from_unix_date(1);
+----------------------+
|date_from_unix_date(1)|
+----------------------+
|            1970-01-02|
+----------------------+

-- 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 5 days 3 hours 7 minutes);
+-------------------------------------------------+
|date_part(days, INTERVAL '5 03:07' DAY TO MINUTE)|
+-------------------------------------------------+
|                                                5|
+-------------------------------------------------+

SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+-------------------------------------------------------------+
|date_part(seconds, INTERVAL '05:00:30.001001' HOUR TO SECOND)|
+-------------------------------------------------------------+
|                                                    30.001001|
+-------------------------------------------------------------+

SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH);
+--------------------------------------------------+
|date_part(MONTH, INTERVAL '2021-11' YEAR TO MONTH)|
+--------------------------------------------------+
|                                                11|
+--------------------------------------------------+

SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);
+---------------------------------------------------------------+
|date_part(MINUTE, INTERVAL '123 23:55:59.002001' DAY TO SECOND)|
+---------------------------------------------------------------+
|                                                             55|
+---------------------------------------------------------------+

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

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

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

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

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

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

-- dateadd
SELECT dateadd('2016-07-30', 1);
+-----------------------+
|date_add(2016-07-30, 1)|
+-----------------------+
|             2016-07-31|
+-----------------------+

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

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

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

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

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

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

SELECT datepart('days', interval 5 days 3 hours 7 minutes);
+----------------------------------------------------+
|datepart(days FROM INTERVAL '5 03:07' DAY TO MINUTE)|
+----------------------------------------------------+
|                                                   5|
+----------------------------------------------------+

SELECT datepart('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+----------------------------------------------------------------+
|datepart(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)|
+----------------------------------------------------------------+
|                                                       30.001001|
+----------------------------------------------------------------+

SELECT datepart('MONTH', INTERVAL '2021-11' YEAR TO MONTH);
+-----------------------------------------------------+
|datepart(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)|
+-----------------------------------------------------+
|                                                   11|
+-----------------------------------------------------+

SELECT datepart('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);
+------------------------------------------------------------------+
|datepart(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)|
+------------------------------------------------------------------+
|                                                                55|
+------------------------------------------------------------------+

-- day
SELECT day('2009-07-30');
+---------------+
|day(2009-07-30)|
+---------------+
|             30|
+---------------+

-- dayname
SELECT dayname(DATE('2008-02-20'));
+-------------------+
|dayname(2008-02-20)|
+-------------------+
|                Wed|
+-------------------+

-- dayofmonth
SELECT dayofmonth('2009-07-30');
+----------------------+
|dayofmonth(2009-07-30)|
+----------------------+
|                    30|
+----------------------+

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

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

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

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

SELECT extract(doy FROM DATE'2019-08-12');
+-----------------------------------+
|extract(doy FROM DATE '2019-08-12')|
+-----------------------------------+
|                                224|
+-----------------------------------+

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

SELECT extract(days FROM interval 5 days 3 hours 7 minutes);
+---------------------------------------------------+
|extract(days FROM INTERVAL '5 03:07' DAY TO MINUTE)|
+---------------------------------------------------+
|                                                  5|
+---------------------------------------------------+

SELECT extract(seconds FROM interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+---------------------------------------------------------------+
|extract(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)|
+---------------------------------------------------------------+
|                                                      30.001001|
+---------------------------------------------------------------+

SELECT extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH);
+----------------------------------------------------+
|extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)|
+----------------------------------------------------+
|                                                  11|
+----------------------------------------------------+

SELECT extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND);
+-----------------------------------------------------------------+
|extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)|
+-----------------------------------------------------------------+
|                                                               55|
+-----------------------------------------------------------------+

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

SELECT from_unixtime(0);
+-------------------------------------+
|from_unixtime(0, 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(2016-08-31, Asia/Seoul)|
+------------------------------------------+
|                       2016-08-31 09:00:00|
+------------------------------------------+

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

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

-- localtimestamp
SELECT localtimestamp();
+--------------------+
|    localtimestamp()|
+--------------------+
|2025-05-19 09:07:...|
+--------------------+

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

SELECT make_date(2019, 7, NULL);
+------------------------+
|make_date(2019, 7, NULL)|
+------------------------+
|                    NULL|
+------------------------+

-- make_dt_interval
SELECT make_dt_interval(1, 12, 30, 01.001001);
+-------------------------------------+
|make_dt_interval(1, 12, 30, 1.001001)|
+-------------------------------------+
|                 INTERVAL '1 12:30...|
+-------------------------------------+

SELECT make_dt_interval(2);
+-----------------------------------+
|make_dt_interval(2, 0, 0, 0.000000)|
+-----------------------------------+
|               INTERVAL '2 00:00...|
+-----------------------------------+

SELECT make_dt_interval(100, null, 3);
+----------------------------------------+
|make_dt_interval(100, NULL, 3, 0.000000)|
+----------------------------------------+
|                                    NULL|
+----------------------------------------+

-- make_interval
SELECT make_interval(100, 11, 1, 1, 12, 30, 01.001001);
+----------------------------------------------+
|make_interval(100, 11, 1, 1, 12, 30, 1.001001)|
+----------------------------------------------+
|                          100 years 11 mont...|
+----------------------------------------------+

SELECT make_interval(100, null, 3);
+----------------------------------------------+
|make_interval(100, NULL, 3, 0, 0, 0, 0.000000)|
+----------------------------------------------+
|                                          NULL|
+----------------------------------------------+

SELECT make_interval(0, 1, 0, 1, 0, 0, 100.000001);
+-------------------------------------------+
|make_interval(0, 1, 0, 1, 0, 0, 100.000001)|
+-------------------------------------------+
|                       1 months 1 days 1...|
+-------------------------------------------+

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

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

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

SELECT make_timestamp(2019, 6, 30, 23, 59, 1);
+--------------------------------------+
|make_timestamp(2019, 6, 30, 23, 59, 1)|
+--------------------------------------+
|                   2019-06-30 23:59:01|
+--------------------------------------+

SELECT make_timestamp(null, 7, 22, 15, 30, 0);
+--------------------------------------+
|make_timestamp(NULL, 7, 22, 15, 30, 0)|
+--------------------------------------+
|                                  NULL|
+--------------------------------------+

-- make_timestamp_ltz
SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887);
+-----------------------------------------------+
|make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887)|
+-----------------------------------------------+
|                           2014-12-28 06:30:...|
+-----------------------------------------------+

SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, 'CET');
+----------------------------------------------------+
|make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, CET)|
+----------------------------------------------------+
|                                2014-12-28 05:30:...|
+----------------------------------------------------+

SELECT make_timestamp_ltz(2019, 6, 30, 23, 59, 60);
+-------------------------------------------+
|make_timestamp_ltz(2019, 6, 30, 23, 59, 60)|
+-------------------------------------------+
|                        2019-07-01 00:00:00|
+-------------------------------------------+

SELECT make_timestamp_ltz(null, 7, 22, 15, 30, 0);
+------------------------------------------+
|make_timestamp_ltz(NULL, 7, 22, 15, 30, 0)|
+------------------------------------------+
|                                      NULL|
+------------------------------------------+

-- make_timestamp_ntz
SELECT make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887);
+-----------------------------------------------+
|make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887)|
+-----------------------------------------------+
|                           2014-12-28 06:30:...|
+-----------------------------------------------+

SELECT make_timestamp_ntz(2019, 6, 30, 23, 59, 60);
+-------------------------------------------+
|make_timestamp_ntz(2019, 6, 30, 23, 59, 60)|
+-------------------------------------------+
|                        2019-07-01 00:00:00|
+-------------------------------------------+

SELECT make_timestamp_ntz(null, 7, 22, 15, 30, 0);
+------------------------------------------+
|make_timestamp_ntz(NULL, 7, 22, 15, 30, 0)|
+------------------------------------------+
|                                      NULL|
+------------------------------------------+

-- make_ym_interval
SELECT make_ym_interval(1, 2);
+----------------------+
|make_ym_interval(1, 2)|
+----------------------+
|  INTERVAL '1-2' YE...|
+----------------------+

SELECT make_ym_interval(1, 0);
+----------------------+
|make_ym_interval(1, 0)|
+----------------------+
|  INTERVAL '1-0' YE...|
+----------------------+

SELECT make_ym_interval(-1, 1);
+-----------------------+
|make_ym_interval(-1, 1)|
+-----------------------+
|   INTERVAL '-0-11' ...|
+-----------------------+

SELECT make_ym_interval(2);
+----------------------+
|make_ym_interval(2, 0)|
+----------------------+
|  INTERVAL '2-0' YE...|
+----------------------+

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

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

-- monthname
SELECT monthname('2008-02-20');
+---------------------+
|monthname(2008-02-20)|
+---------------------+
|                  Feb|
+---------------------+

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

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

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

-- now
SELECT now();
+--------------------+
|               now()|
+--------------------+
|2025-05-19 09:07:...|
+--------------------+

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

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

-- session_window
SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, session_window(b, '5 minutes') ORDER BY a, start;
+---+-------------------+-------------------+---+
|  a|              start|                end|cnt|
+---+-------------------+-------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:09:30|  2|
| A1|2021-01-01 00:10:00|2021-01-01 00:15:00|  1|
| A2|2021-01-01 00:01:00|2021-01-01 00:06:00|  1|
+---+-------------------+-------------------+---+

SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00'), ('A2', '2021-01-01 00:04:30') AS tab(a, b) GROUP by a, session_window(b, CASE WHEN a = 'A1' THEN '5 minutes' WHEN a = 'A2' THEN '1 minute' ELSE '10 minutes' END) ORDER BY a, start;
+---+-------------------+-------------------+---+
|  a|              start|                end|cnt|
+---+-------------------+-------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:09:30|  2|
| A1|2021-01-01 00:10:00|2021-01-01 00:15:00|  1|
| A2|2021-01-01 00:01:00|2021-01-01 00:02:00|  1|
| A2|2021-01-01 00:04:30|2021-01-01 00:05:30|  1|
+---+-------------------+-------------------+---+

-- timestamp_micros
SELECT timestamp_micros(1230219000123123);
+----------------------------------+
|timestamp_micros(1230219000123123)|
+----------------------------------+
|              2008-12-25 15:30:...|
+----------------------------------+

-- timestamp_millis
SELECT timestamp_millis(1230219000123);
+-------------------------------+
|timestamp_millis(1230219000123)|
+-------------------------------+
|           2008-12-25 15:30:...|
+-------------------------------+

-- timestamp_seconds
SELECT timestamp_seconds(1230219000);
+-----------------------------+
|timestamp_seconds(1230219000)|
+-----------------------------+
|          2008-12-25 15:30:00|
+-----------------------------+

SELECT timestamp_seconds(1230219000.123);
+---------------------------------+
|timestamp_seconds(1230219000.123)|
+---------------------------------+
|             2008-12-25 15:30:...|
+---------------------------------+

-- 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_timestamp_ltz
SELECT to_timestamp_ltz('2016-12-31 00:12:00');
+-------------------------------------+
|to_timestamp_ltz(2016-12-31 00:12:00)|
+-------------------------------------+
|                  2016-12-31 00:12:00|
+-------------------------------------+

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

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

SELECT to_timestamp_ntz('2016-12-31', 'yyyy-MM-dd');
+----------------------------------------+
|to_timestamp_ntz(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(2016-08-31, Asia/Seoul)|
+----------------------------------------+
|                     2016-08-30 15:00:00|
+----------------------------------------+

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

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

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

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

-- try_make_interval
SELECT try_make_interval(100, 11, 1, 1, 12, 30, 01.001001);
+--------------------------------------------------+
|try_make_interval(100, 11, 1, 1, 12, 30, 1.001001)|
+--------------------------------------------------+
|                              100 years 11 mont...|
+--------------------------------------------------+

SELECT try_make_interval(100, null, 3);
+--------------------------------------------------+
|try_make_interval(100, NULL, 3, 0, 0, 0, 0.000000)|
+--------------------------------------------------+
|                                              NULL|
+--------------------------------------------------+

SELECT try_make_interval(0, 1, 0, 1, 0, 0, 100.000001);
+-----------------------------------------------+
|try_make_interval(0, 1, 0, 1, 0, 0, 100.000001)|
+-----------------------------------------------+
|                           1 months 1 days 1...|
+-----------------------------------------------+

SELECT try_make_interval(2147483647);
+------------------------------------------------------+
|try_make_interval(2147483647, 0, 0, 0, 0, 0, 0.000000)|
+------------------------------------------------------+
|                                                  NULL|
+------------------------------------------------------+

-- try_make_timestamp
SELECT try_make_timestamp(2014, 12, 28, 6, 30, 45.887);
+-----------------------------------------------+
|try_make_timestamp(2014, 12, 28, 6, 30, 45.887)|
+-----------------------------------------------+
|                           2014-12-28 06:30:...|
+-----------------------------------------------+

SELECT try_make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET');
+-----------------------------------------------+
|try_make_timestamp(2014, 12, 28, 6, 30, 45.887)|
+-----------------------------------------------+
|                           2014-12-28 05:30:...|
+-----------------------------------------------+

SELECT try_make_timestamp(2019, 6, 30, 23, 59, 60);
+-------------------------------------------+
|try_make_timestamp(2019, 6, 30, 23, 59, 60)|
+-------------------------------------------+
|                        2019-07-01 00:00:00|
+-------------------------------------------+

SELECT try_make_timestamp(2019, 6, 30, 23, 59, 1);
+------------------------------------------+
|try_make_timestamp(2019, 6, 30, 23, 59, 1)|
+------------------------------------------+
|                       2019-06-30 23:59:01|
+------------------------------------------+

SELECT try_make_timestamp(null, 7, 22, 15, 30, 0);
+------------------------------------------+
|try_make_timestamp(NULL, 7, 22, 15, 30, 0)|
+------------------------------------------+
|                                      NULL|
+------------------------------------------+

SELECT try_make_timestamp(2024, 13, 22, 15, 30, 0);
+-------------------------------------------+
|try_make_timestamp(2024, 13, 22, 15, 30, 0)|
+-------------------------------------------+
|                                       NULL|
+-------------------------------------------+

-- try_make_timestamp_ltz
SELECT try_make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887);
+---------------------------------------------------+
|try_make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887)|
+---------------------------------------------------+
|                               2014-12-28 06:30:...|
+---------------------------------------------------+

SELECT try_make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, 'CET');
+--------------------------------------------------------+
|try_make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, CET)|
+--------------------------------------------------------+
|                                    2014-12-28 05:30:...|
+--------------------------------------------------------+

SELECT try_make_timestamp_ltz(2019, 6, 30, 23, 59, 60);
+-----------------------------------------------+
|try_make_timestamp_ltz(2019, 6, 30, 23, 59, 60)|
+-----------------------------------------------+
|                            2019-07-01 00:00:00|
+-----------------------------------------------+

SELECT try_make_timestamp_ltz(null, 7, 22, 15, 30, 0);
+----------------------------------------------+
|try_make_timestamp_ltz(NULL, 7, 22, 15, 30, 0)|
+----------------------------------------------+
|                                          NULL|
+----------------------------------------------+

SELECT try_make_timestamp_ltz(2024, 13, 22, 15, 30, 0);
+-----------------------------------------------+
|try_make_timestamp_ltz(2024, 13, 22, 15, 30, 0)|
+-----------------------------------------------+
|                                           NULL|
+-----------------------------------------------+

-- try_make_timestamp_ntz
SELECT try_make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887);
+---------------------------------------------------+
|try_make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887)|
+---------------------------------------------------+
|                               2014-12-28 06:30:...|
+---------------------------------------------------+

SELECT try_make_timestamp_ntz(2019, 6, 30, 23, 59, 60);
+-----------------------------------------------+
|try_make_timestamp_ntz(2019, 6, 30, 23, 59, 60)|
+-----------------------------------------------+
|                            2019-07-01 00:00:00|
+-----------------------------------------------+

SELECT try_make_timestamp_ntz(null, 7, 22, 15, 30, 0);
+----------------------------------------------+
|try_make_timestamp_ntz(NULL, 7, 22, 15, 30, 0)|
+----------------------------------------------+
|                                          NULL|
+----------------------------------------------+

SELECT try_make_timestamp_ntz(2024, 13, 22, 15, 30, 0);
+-----------------------------------------------+
|try_make_timestamp_ntz(2024, 13, 22, 15, 30, 0)|
+-----------------------------------------------+
|                                           NULL|
+-----------------------------------------------+

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

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

SELECT try_to_timestamp('foo', 'yyyy-MM-dd');
+---------------------------------+
|try_to_timestamp(foo, yyyy-MM-dd)|
+---------------------------------+
|                             NULL|
+---------------------------------+

-- unix_date
SELECT unix_date(DATE("1970-01-02"));
+---------------------+
|unix_date(1970-01-02)|
+---------------------+
|                    1|
+---------------------+

-- unix_micros
SELECT unix_micros(TIMESTAMP('1970-01-01 00:00:01Z'));
+---------------------------------+
|unix_micros(1970-01-01 00:00:01Z)|
+---------------------------------+
|                          1000000|
+---------------------------------+

-- unix_millis
SELECT unix_millis(TIMESTAMP('1970-01-01 00:00:01Z'));
+---------------------------------+
|unix_millis(1970-01-01 00:00:01Z)|
+---------------------------------+
|                             1000|
+---------------------------------+

-- unix_seconds
SELECT unix_seconds(TIMESTAMP('1970-01-01 00:00:01Z'));
+----------------------------------+
|unix_seconds(1970-01-01 00:00:01Z)|
+----------------------------------+
|                                 1|
+----------------------------------+

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

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(2009-07-30)|
+-------------------+
|                  3|
+-------------------+

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

-- window
SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, start;
+---+-------------------+-------------------+---+
|  a|              start|                end|cnt|
+---+-------------------+-------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:05:00|  2|
| A1|2021-01-01 00:05:00|2021-01-01 00:10:00|  1|
| A2|2021-01-01 00:00:00|2021-01-01 00:05:00|  1|
+---+-------------------+-------------------+---+

SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '10 minutes', '5 minutes') ORDER BY a, start;
+---+-------------------+-------------------+---+
|  a|              start|                end|cnt|
+---+-------------------+-------------------+---+
| A1|2020-12-31 23:55:00|2021-01-01 00:05:00|  2|
| A1|2021-01-01 00:00:00|2021-01-01 00:10:00|  3|
| A1|2021-01-01 00:05:00|2021-01-01 00:15:00|  1|
| A2|2020-12-31 23:55:00|2021-01-01 00:05:00|  1|
| A2|2021-01-01 00:00:00|2021-01-01 00:10:00|  1|
+---+-------------------+-------------------+---+

-- window_time
SELECT a, window.start as start, window.end as end, window_time(window), cnt FROM (SELECT a, window, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, window.start);
+---+-------------------+-------------------+--------------------+---+
|  a|              start|                end| window_time(window)|cnt|
+---+-------------------+-------------------+--------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...|  2|
| A1|2021-01-01 00:05:00|2021-01-01 00:10:00|2021-01-01 00:09:...|  1|
| A2|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...|  1|
+---+-------------------+-------------------+--------------------+---+

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

数学関数

関数	説明
expr1 % expr2, または mod(expr1, expr2)	`expr1` を `expr2` で割った余りを返します。
expr1 * expr2	`expr1`*`expr2` を返します。
expr1 + expr2	`expr1`+`expr2` を返します。
expr1 - expr2	`expr1`-`expr2` を返します。
expr1 / expr2	`expr1`/`expr2` を返します。常に浮動小数点除算を実行します。
abs(expr)	数値または間隔値の絶対値を返します。
acos(expr)	`expr` の逆余弦（別名アークコサイン）を返します。`java.lang.Math.acos` で計算される場合と同様です。
acosh(expr)	`expr` の逆双曲線余弦を返します。
asin(expr)	`expr` の逆正弦（別名アークサイン）を返します。`java.lang.Math.asin` で計算される場合と同様です。
asinh(expr)	`expr` の逆双曲線正弦を返します。
atan(expr)	`expr` の逆正接（別名アークタンジェント）を返します。`java.lang.Math.atan` で計算される場合と同様です。
atan2(exprY, exprX)	平面上の点 (`exprX`, `exprY`) と正の x 軸との間の角度（ラジアン）を返します。`java.lang.Math.atan2` で計算される場合と同様です。
atanh(expr)	`expr` の逆双曲線正接を返します。
bin(expr)	long 値 `expr` のバイナリ表現を文字列として返します。
bround(expr, d)	HALF_EVEN 丸めモードを使用して、`expr` を `d` 桁に丸めた値を返します。
cbrt(expr)	`expr` の立方根を返します。
ceil(expr[, scale])	`expr` 以上で最小の切り上げられた数値を返します。オプションの `scale` パラメータを指定して、丸め動作を制御できます。
ceiling(expr[, scale])	`expr` 以上で最小の切り上げられた数値を返します。オプションの `scale` パラメータを指定して、丸め動作を制御できます。
conv(num, from_base, to_base)	`num` を `from_base` から `to_base` に変換します。
cos(expr)	`expr` の余弦を返します。`java.lang.Math.cos` で計算される場合と同様です。
cosh(expr)	`expr` の双曲線余弦を返します。`java.lang.Math.cosh` で計算される場合と同様です。
cot(expr)	`expr` の余接を返します。`1/java.lang.Math.tan` で計算される場合と同様です。
csc(expr)	`expr` の余割を返します。`1/java.lang.Math.sin` で計算される場合と同様です。
degrees(expr)	ラジアンを度に変換します。
expr1 div expr2	`expr1` を `expr2` で割ります。オペランドが null または `expr2` が 0 の場合は NULL を返します。結果は long にキャストされます。
e()	オイラー数 e を返します。
exp(expr)	`expr` のべき乗 e を返します。
expm1(expr) - exp(`expr`) を返します	1.
factorial(expr)	`expr` の階乗を返します。`expr` は [0..20] です。それ以外の場合は null です。
floor(expr[, scale])	`expr` 以下で最大の切り捨てられた数値を返します。オプションの `scale` パラメータを指定して、丸め動作を制御できます。
greatest(expr, ...)	すべてのパラメータのうち最大の値を返します。null 値はスキップされます。
hex(expr)	`expr` を 16 進数に変換します。
hypot(expr1, expr2)	`sqrt(expr1`2 + `expr2`2)` を返します。
least(expr, ...)	すべてのパラメータのうち最小の値を返します。null 値はスキップされます。
ln(expr)	`expr` の自然対数（底 e）を返します。
log(base, expr)	`base` を底とする `expr` の対数を返します。
log10(expr)	底 10 の `expr` の対数を返します。
log1p(expr)	log(1 + `expr`) を返します。
log2(expr)	底 2 の `expr` の対数を返します。
expr1 % expr2, または mod(expr1, expr2)	`expr1` を `expr2` で割った余りを返します。
negative(expr)	`expr` の符号を反転した値を返します。
pi()	円周率 pi を返します。
pmod(expr1, expr2)	`expr1` mod `expr2` の正の値を返します。
positive(expr)	`expr` の値を返します。
pow(expr1, expr2)	`expr1` を `expr2` のべき乗にします。
power(expr1, expr2)	`expr1` を `expr2` のべき乗にします。
radians(expr)	度をラジアンに変換します。
rand([seed])	[0, 1) の範囲で独立かつ同一に分布した（i.i.d.）一様分布の乱数値を返します。乱数シードはオプションです。
randn([seed])	標準正規分布から抽出された、独立かつ同一に分布した（i.i.d.）乱数値を返します。乱数シードはオプションです。
random([seed])	[0, 1) の範囲で独立かつ同一に分布した（i.i.d.）一様分布の乱数値を返します。乱数シードはオプションです。
rint(expr)	引数に最も近い数学的整数値の double 値を返します。
round(expr, d)	HALF_UP 丸めモードを使用して、`expr` を `d` 桁に丸めた値を返します。
sec(expr)	`expr` の正割を返します。`1/java.lang.Math.cos` で計算される場合と同様です。
sign(expr)	`expr` が負、0、正の場合に、それぞれ -1.0、0.0、または 1.0 を返します。
signum(expr)	`expr` が負、0、正の場合に、それぞれ -1.0、0.0、または 1.0 を返します。
sin(expr)	`expr` の正弦を返します。`java.lang.Math.sin` で計算される場合と同様です。
sinh(expr)	`expr` の双曲線正弦を返します。`java.lang.Math.sinh` で計算される場合と同様です。
sqrt(expr)	`expr` の平方根を返します。
tan(expr)	`expr` の正接を返します。`java.lang.Math.tan` で計算される場合と同様です。
tanh(expr)	`expr` の双曲線正接を返します。`java.lang.Math.tanh` で計算される場合と同様です。
try_add(expr1, expr2)	`expr1` と `expr2` の合計を返します。オーバーフローが発生した場合は null を返します。受け入れ可能な入力型は、`+` 演算子と同じです。
try_divide(dividend, divisor)	`dividend`/`divisor` を返します。常に浮動小数点除算を実行します。`expr2` が 0 の場合は常に null を返します。`dividend` は数値または間隔である必要があります。`divisor` は数値である必要があります。
try_mod(dividend, divisor)	`expr1`/`expr2` の余りを返します。`dividend` は数値である必要があります。`divisor` は数値である必要があります。
try_multiply(expr1, expr2)	`expr1``expr2` を返します。オーバーフローが発生した場合は null を返します。受け入れ可能な入力型は、`` 演算子と同じです。
try_subtract(expr1, expr2)	`expr1`-`expr2` を返します。オーバーフローが発生した場合は null を返します。受け入れ可能な入力型は、`-` 演算子と同じです。
unhex(expr)	16 進数 `expr` をバイナリに変換します。
uniform(min, max[, seed])	指定された数値範囲で独立かつ同一に分布した（i.i.d.）乱数値を返します。乱数シードはオプションです。範囲の最小値と最大値を指定する数値は定数である必要があります。これらの数値が両方とも整数である場合、結果も整数になります。それ以外の場合、1 つ以上が浮動小数点数である場合、結果も浮動小数点数になります。
width_bucket(value, min_value, max_value, num_bucket)	`min_value` から `max_value` までの `num_bucket` 個のバケットを持つ等幅ヒストグラムに `value` が割り当てられるバケット番号を返します。

例

-- %
SELECT 2 % 1.8;
+---------+
|(2 % 1.8)|
+---------+
|      0.2|
+---------+

SELECT MOD(2, 1.8);
+-----------+
|mod(2, 1.8)|
+-----------+
|        0.2|
+-----------+

-- *
SELECT 2 * 3;
+-------+
|(2 * 3)|
+-------+
|      6|
+-------+

-- +
SELECT 1 + 2;
+-------+
|(1 + 2)|
+-------+
|      3|
+-------+

-- -
SELECT 2 - 1;
+-------+
|(2 - 1)|
+-------+
|      1|
+-------+

-- /
SELECT 3 / 2;
+-------+
|(3 / 2)|
+-------+
|    1.5|
+-------+

SELECT 2L / 2L;
+-------+
|(2 / 2)|
+-------+
|    1.0|
+-------+

-- abs
SELECT abs(-1);
+-------+
|abs(-1)|
+-------+
|      1|
+-------+

SELECT abs(INTERVAL -'1-1' YEAR TO MONTH);
+----------------------------------+
|abs(INTERVAL '-1-1' YEAR TO MONTH)|
+----------------------------------+
|              INTERVAL '1-1' YE...|
+----------------------------------+

-- acos
SELECT acos(1);
+-------+
|ACOS(1)|
+-------+
|    0.0|
+-------+

SELECT acos(2);
+-------+
|ACOS(2)|
+-------+
|    NaN|
+-------+

-- acosh
SELECT acosh(1);
+--------+
|ACOSH(1)|
+--------+
|     0.0|
+--------+

SELECT acosh(0);
+--------+
|ACOSH(0)|
+--------+
|     NaN|
+--------+

-- asin
SELECT asin(0);
+-------+
|ASIN(0)|
+-------+
|    0.0|
+-------+

SELECT asin(2);
+-------+
|ASIN(2)|
+-------+
|    NaN|
+-------+

-- asinh
SELECT asinh(0);
+--------+
|ASINH(0)|
+--------+
|     0.0|
+--------+

-- atan
SELECT atan(0);
+-------+
|ATAN(0)|
+-------+
|    0.0|
+-------+

-- atan2
SELECT atan2(0, 0);
+-----------+
|ATAN2(0, 0)|
+-----------+
|        0.0|
+-----------+

-- atanh
SELECT atanh(0);
+--------+
|ATANH(0)|
+--------+
|     0.0|
+--------+

SELECT atanh(2);
+--------+
|ATANH(2)|
+--------+
|     NaN|
+--------+

-- bin
SELECT bin(13);
+-------+
|bin(13)|
+-------+
|   1101|
+-------+

SELECT bin(-13);
+--------------------+
|            bin(-13)|
+--------------------+
|11111111111111111...|
+--------------------+

SELECT bin(13.3);
+---------+
|bin(13.3)|
+---------+
|     1101|
+---------+

-- bround
SELECT bround(2.5, 0);
+--------------+
|bround(2.5, 0)|
+--------------+
|             2|
+--------------+

SELECT bround(25, -1);
+--------------+
|bround(25, -1)|
+--------------+
|            20|
+--------------+

-- cbrt
SELECT cbrt(27.0);
+----------+
|CBRT(27.0)|
+----------+
|       3.0|
+----------+

-- ceil
SELECT ceil(-0.1);
+----------+
|CEIL(-0.1)|
+----------+
|         0|
+----------+

SELECT ceil(5);
+-------+
|CEIL(5)|
+-------+
|      5|
+-------+

SELECT ceil(3.1411, 3);
+---------------+
|ceil(3.1411, 3)|
+---------------+
|          3.142|
+---------------+

SELECT ceil(3.1411, -3);
+----------------+
|ceil(3.1411, -3)|
+----------------+
|            1000|
+----------------+

-- ceiling
SELECT ceiling(-0.1);
+-------------+
|ceiling(-0.1)|
+-------------+
|            0|
+-------------+

SELECT ceiling(5);
+----------+
|ceiling(5)|
+----------+
|         5|
+----------+

SELECT ceiling(3.1411, 3);
+------------------+
|ceiling(3.1411, 3)|
+------------------+
|             3.142|
+------------------+

SELECT ceiling(3.1411, -3);
+-------------------+
|ceiling(3.1411, -3)|
+-------------------+
|               1000|
+-------------------+

-- conv
SELECT conv('100', 2, 10);
+----------------+
|conv(100, 2, 10)|
+----------------+
|               4|
+----------------+

SELECT conv(-10, 16, -10);
+------------------+
|conv(-10, 16, -10)|
+------------------+
|               -16|
+------------------+

-- cos
SELECT cos(0);
+------+
|COS(0)|
+------+
|   1.0|
+------+

-- cosh
SELECT cosh(0);
+-------+
|COSH(0)|
+-------+
|    1.0|
+-------+

-- cot
SELECT cot(1);
+------------------+
|            COT(1)|
+------------------+
|0.6420926159343306|
+------------------+

-- csc
SELECT csc(1);
+------------------+
|            CSC(1)|
+------------------+
|1.1883951057781212|
+------------------+

-- degrees
SELECT degrees(3.141592653589793);
+--------------------------+
|DEGREES(3.141592653589793)|
+--------------------------+
|                     180.0|
+--------------------------+

-- div
SELECT 3 div 2;
+---------+
|(3 div 2)|
+---------+
|        1|
+---------+

SELECT INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH;
+------------------------------------------------------+
|(INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH)|
+------------------------------------------------------+
|                                                   -13|
+------------------------------------------------------+

-- e
SELECT e();
+-----------------+
|              E()|
+-----------------+
|2.718281828459045|
+-----------------+

-- exp
SELECT exp(0);
+------+
|EXP(0)|
+------+
|   1.0|
+------+

-- expm1
SELECT expm1(0);
+--------+
|EXPM1(0)|
+--------+
|     0.0|
+--------+

-- factorial
SELECT factorial(5);
+------------+
|factorial(5)|
+------------+
|         120|
+------------+

-- floor
SELECT floor(-0.1);
+-----------+
|FLOOR(-0.1)|
+-----------+
|         -1|
+-----------+

SELECT floor(5);
+--------+
|FLOOR(5)|
+--------+
|       5|
+--------+

SELECT floor(3.1411, 3);
+----------------+
|floor(3.1411, 3)|
+----------------+
|           3.141|
+----------------+

SELECT floor(3.1411, -3);
+-----------------+
|floor(3.1411, -3)|
+-----------------+
|                0|
+-----------------+

-- greatest
SELECT greatest(10, 9, 2, 4, 3);
+------------------------+
|greatest(10, 9, 2, 4, 3)|
+------------------------+
|                      10|
+------------------------+

-- hex
SELECT hex(17);
+-------+
|hex(17)|
+-------+
|     11|
+-------+

SELECT hex('Spark SQL');
+------------------+
|    hex(Spark SQL)|
+------------------+
|537061726B2053514C|
+------------------+

-- hypot
SELECT hypot(3, 4);
+-----------+
|HYPOT(3, 4)|
+-----------+
|        5.0|
+-----------+

-- least
SELECT least(10, 9, 2, 4, 3);
+---------------------+
|least(10, 9, 2, 4, 3)|
+---------------------+
|                    2|
+---------------------+

-- ln
SELECT ln(1);
+-----+
|ln(1)|
+-----+
|  0.0|
+-----+

-- log
SELECT log(10, 100);
+------------+
|LOG(10, 100)|
+------------+
|         2.0|
+------------+

-- log10
SELECT log10(10);
+---------+
|LOG10(10)|
+---------+
|      1.0|
+---------+

-- log1p
SELECT log1p(0);
+--------+
|LOG1P(0)|
+--------+
|     0.0|
+--------+

-- log2
SELECT log2(2);
+-------+
|LOG2(2)|
+-------+
|    1.0|
+-------+

-- mod
SELECT 2 % 1.8;
+---------+
|(2 % 1.8)|
+---------+
|      0.2|
+---------+

SELECT MOD(2, 1.8);
+-----------+
|mod(2, 1.8)|
+-----------+
|        0.2|
+-----------+

-- negative
SELECT negative(1);
+-----------+
|negative(1)|
+-----------+
|         -1|
+-----------+

-- pi
SELECT pi();
+-----------------+
|             PI()|
+-----------------+
|3.141592653589793|
+-----------------+

-- pmod
SELECT pmod(10, 3);
+-----------+
|pmod(10, 3)|
+-----------+
|          1|
+-----------+

SELECT pmod(-10, 3);
+------------+
|pmod(-10, 3)|
+------------+
|           2|
+------------+

-- positive
SELECT positive(1);
+-----+
|(+ 1)|
+-----+
|    1|
+-----+

-- pow
SELECT pow(2, 3);
+---------+
|pow(2, 3)|
+---------+
|      8.0|
+---------+

-- power
SELECT power(2, 3);
+-----------+
|POWER(2, 3)|
+-----------+
|        8.0|
+-----------+

-- radians
SELECT radians(180);
+-----------------+
|     RADIANS(180)|
+-----------------+
|3.141592653589793|
+-----------------+

-- rand
SELECT rand();
+-------------------+
|             rand()|
+-------------------+
|0.41940687541824373|
+-------------------+

SELECT rand(0);
+------------------+
|           rand(0)|
+------------------+
|0.7604953758285915|
+------------------+

SELECT rand(null);
+------------------+
|        rand(NULL)|
+------------------+
|0.7604953758285915|
+------------------+

-- randn
SELECT randn();
+------------------+
|           randn()|
+------------------+
|0.8646964843291269|
+------------------+

SELECT randn(0);
+------------------+
|          randn(0)|
+------------------+
|1.6034991609278433|
+------------------+

SELECT randn(null);
+------------------+
|       randn(NULL)|
+------------------+
|1.6034991609278433|
+------------------+

-- random
SELECT random();
+-----------------+
|           rand()|
+-----------------+
|0.927036862897507|
+-----------------+

SELECT random(0);
+------------------+
|           rand(0)|
+------------------+
|0.7604953758285915|
+------------------+

SELECT random(null);
+------------------+
|        rand(NULL)|
+------------------+
|0.7604953758285915|
+------------------+

-- rint
SELECT rint(12.3456);
+-------------+
|rint(12.3456)|
+-------------+
|         12.0|
+-------------+

-- round
SELECT round(2.5, 0);
+-------------+
|round(2.5, 0)|
+-------------+
|            3|
+-------------+

-- sec
SELECT sec(0);
+------+
|SEC(0)|
+------+
|   1.0|
+------+

-- sign
SELECT sign(40);
+--------+
|sign(40)|
+--------+
|     1.0|
+--------+

SELECT sign(INTERVAL -'100' YEAR);
+--------------------------+
|sign(INTERVAL '-100' YEAR)|
+--------------------------+
|                      -1.0|
+--------------------------+

-- signum
SELECT signum(40);
+----------+
|SIGNUM(40)|
+----------+
|       1.0|
+----------+

SELECT signum(INTERVAL -'100' YEAR);
+----------------------------+
|SIGNUM(INTERVAL '-100' YEAR)|
+----------------------------+
|                        -1.0|
+----------------------------+

-- sin
SELECT sin(0);
+------+
|SIN(0)|
+------+
|   0.0|
+------+

-- sinh
SELECT sinh(0);
+-------+
|SINH(0)|
+-------+
|    0.0|
+-------+

-- sqrt
SELECT sqrt(4);
+-------+
|SQRT(4)|
+-------+
|    2.0|
+-------+

-- tan
SELECT tan(0);
+------+
|TAN(0)|
+------+
|   0.0|
+------+

-- tanh
SELECT tanh(0);
+-------+
|TANH(0)|
+-------+
|    0.0|
+-------+

-- try_add
SELECT try_add(1, 2);
+-------------+
|try_add(1, 2)|
+-------------+
|            3|
+-------------+

SELECT try_add(2147483647, 1);
+----------------------+
|try_add(2147483647, 1)|
+----------------------+
|                  NULL|
+----------------------+

SELECT try_add(date'2021-01-01', 1);
+-----------------------------+
|try_add(DATE '2021-01-01', 1)|
+-----------------------------+
|                   2021-01-02|
+-----------------------------+

SELECT try_add(date'2021-01-01', interval 1 year);
+---------------------------------------------+
|try_add(DATE '2021-01-01', INTERVAL '1' YEAR)|
+---------------------------------------------+
|                                   2022-01-01|
+---------------------------------------------+

SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day);
+----------------------------------------------------------+
|try_add(TIMESTAMP '2021-01-01 00:00:00', INTERVAL '1' DAY)|
+----------------------------------------------------------+
|                                       2021-01-02 00:00:00|
+----------------------------------------------------------+

SELECT try_add(interval 1 year, interval 2 year);
+---------------------------------------------+
|try_add(INTERVAL '1' YEAR, INTERVAL '2' YEAR)|
+---------------------------------------------+
|                            INTERVAL '3' YEAR|
+---------------------------------------------+

-- try_divide
SELECT try_divide(3, 2);
+----------------+
|try_divide(3, 2)|
+----------------+
|             1.5|
+----------------+

SELECT try_divide(2L, 2L);
+----------------+
|try_divide(2, 2)|
+----------------+
|             1.0|
+----------------+

SELECT try_divide(1, 0);
+----------------+
|try_divide(1, 0)|
+----------------+
|            NULL|
+----------------+

SELECT try_divide(interval 2 month, 2);
+---------------------------------+
|try_divide(INTERVAL '2' MONTH, 2)|
+---------------------------------+
|             INTERVAL '0-1' YE...|
+---------------------------------+

SELECT try_divide(interval 2 month, 0);
+---------------------------------+
|try_divide(INTERVAL '2' MONTH, 0)|
+---------------------------------+
|                             NULL|
+---------------------------------+

-- try_mod
SELECT try_mod(3, 2);
+-------------+
|try_mod(3, 2)|
+-------------+
|            1|
+-------------+

SELECT try_mod(2L, 2L);
+-------------+
|try_mod(2, 2)|
+-------------+
|            0|
+-------------+

SELECT try_mod(3.0, 2.0);
+-----------------+
|try_mod(3.0, 2.0)|
+-----------------+
|              1.0|
+-----------------+

SELECT try_mod(1, 0);
+-------------+
|try_mod(1, 0)|
+-------------+
|         NULL|
+-------------+

-- try_multiply
SELECT try_multiply(2, 3);
+------------------+
|try_multiply(2, 3)|
+------------------+
|                 6|
+------------------+

SELECT try_multiply(-2147483648, 10);
+-----------------------------+
|try_multiply(-2147483648, 10)|
+-----------------------------+
|                         NULL|
+-----------------------------+

SELECT try_multiply(interval 2 year, 3);
+----------------------------------+
|try_multiply(INTERVAL '2' YEAR, 3)|
+----------------------------------+
|              INTERVAL '6-0' YE...|
+----------------------------------+

-- try_subtract
SELECT try_subtract(2, 1);
+------------------+
|try_subtract(2, 1)|
+------------------+
|                 1|
+------------------+

SELECT try_subtract(-2147483648, 1);
+----------------------------+
|try_subtract(-2147483648, 1)|
+----------------------------+
|                        NULL|
+----------------------------+

SELECT try_subtract(date'2021-01-02', 1);
+----------------------------------+
|try_subtract(DATE '2021-01-02', 1)|
+----------------------------------+
|                        2021-01-01|
+----------------------------------+

SELECT try_subtract(date'2021-01-01', interval 1 year);
+--------------------------------------------------+
|try_subtract(DATE '2021-01-01', INTERVAL '1' YEAR)|
+--------------------------------------------------+
|                                        2020-01-01|
+--------------------------------------------------+

SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day);
+---------------------------------------------------------------+
|try_subtract(TIMESTAMP '2021-01-02 00:00:00', INTERVAL '1' DAY)|
+---------------------------------------------------------------+
|                                            2021-01-01 00:00:00|
+---------------------------------------------------------------+

SELECT try_subtract(interval 2 year, interval 1 year);
+--------------------------------------------------+
|try_subtract(INTERVAL '2' YEAR, INTERVAL '1' YEAR)|
+--------------------------------------------------+
|                                 INTERVAL '1' YEAR|
+--------------------------------------------------+

-- unhex
SELECT decode(unhex('537061726B2053514C'), 'UTF-8');
+----------------------------------------+
|decode(unhex(537061726B2053514C), UTF-8)|
+----------------------------------------+
|                               Spark SQL|
+----------------------------------------+

-- uniform
SELECT uniform(10, 20, 0) > 0 AS result;
+------+
|result|
+------+
|  true|
+------+

-- width_bucket
SELECT width_bucket(5.3, 0.2, 10.6, 5);
+-------------------------------+
|width_bucket(5.3, 0.2, 10.6, 5)|
+-------------------------------+
|                              3|
+-------------------------------+

SELECT width_bucket(-2.1, 1.3, 3.4, 3);
+-------------------------------+
|width_bucket(-2.1, 1.3, 3.4, 3)|
+-------------------------------+
|                              0|
+-------------------------------+

SELECT width_bucket(8.1, 0.0, 5.7, 4);
+------------------------------+
|width_bucket(8.1, 0.0, 5.7, 4)|
+------------------------------+
|                             5|
+------------------------------+

SELECT width_bucket(-0.9, 5.2, 0.5, 2);
+-------------------------------+
|width_bucket(-0.9, 5.2, 0.5, 2)|
+-------------------------------+
|                              3|
+-------------------------------+

SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
+--------------------------------------------------------------------------+
|width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)|
+--------------------------------------------------------------------------+
|                                                                         1|
+--------------------------------------------------------------------------+

SELECT width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
+--------------------------------------------------------------------------+
|width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)|
+--------------------------------------------------------------------------+
|                                                                         2|
+--------------------------------------------------------------------------+

SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
+-----------------------------------------------------------------------+
|width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)|
+-----------------------------------------------------------------------+
|                                                                      1|
+-----------------------------------------------------------------------+

SELECT width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
+-----------------------------------------------------------------------+
|width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)|
+-----------------------------------------------------------------------+
|                                                                      2|
+-----------------------------------------------------------------------+

文字列関数

関数	説明
ascii(str)	`str` の最初の文字の数値（ASCII コード）を返します。
base64(bin)	引数 `bin` を base 64 文字列に変換します。
bit_length(expr)	文字列データのビット長またはバイナリデータのビット数を返します。
btrim(str)	`str` の先頭および末尾のスペース文字を削除します。
btrim(str, trimStr)	`trimStr` の先頭および末尾の文字を `str` から削除します。
char(expr)	`expr` のバイナリ等価な ASCII 文字を返します。n が 256 より大きい場合、結果は chr(n % 256) と同等です。
char_length(expr)	文字列データの文字長またはバイナリデータのバイト数を返します。文字列データの長さには末尾のスペースが含まれます。バイナリデータの長さにはバイナリゼロが含まれます。
character_length(expr)	文字列データの文字長またはバイナリデータのバイト数を返します。文字列データの長さには末尾のスペースが含まれます。バイナリデータの長さにはバイナリゼロが含まれます。
chr(expr)	`expr` のバイナリ等価な ASCII 文字を返します。n が 256 より大きい場合、結果は chr(n % 256) と同等です。
collate(expr, collationName)	指定された照合順序で式にマークを付けます。
collation(expr)	指定された式の照合順序名を返します。
concat_ws(sep[, str \| array(str)]+)	`sep` で区切られた文字列の連結を返します。null 値はスキップされます。
contains(left, right)	ブール値を返します。right が left の中に見つかった場合は True を返します。いずれかの入力式が null の場合は NULL を返します。それ以外の場合は False を返します。left と right は両方とも STRING または BINARY 型である必要があります。
decode(bin, charset)	最初の引数を 2 番目の引数である文字セットを使用してデコードします。いずれかの引数が null の場合、結果も null になります。
decode(expr, search, result [, search, result ] ... [, default])	expr を各 search 値と順に比較します。expr が search 値のいずれかと等しい場合、decode は対応する result を返します。一致が見つからない場合、default を返します。default が省略されている場合、null を返します。
elt(n, input1, input2, ...)	`n` 番目の入力を返します。たとえば、`n` が 2 の場合に `input2` を返します。`spark.sql.ansi.enabled` が false に設定されている場合、インデックスが配列の長さを超えると関数は NULL を返します。`spark.sql.ansi.enabled` が true に設定されている場合、無効なインデックスに対して ArrayIndexOutOfBoundsException がスローされます。
encode(str, charset)	最初の引数を 2 番目の引数である文字セットを使用してエンコードします。いずれかの引数が null の場合、結果も null になります。
endswith(left, right)	ブール値を返します。left が right で終わる場合は True を返します。いずれかの入力式が null の場合は NULL を返します。それ以外の場合は False を返します。left と right は両方とも STRING または BINARY 型である必要があります。
find_in_set(str, str_array)	コンマ区切りのリスト (`str_array`) 内の指定された文字列 (`str`) のインデックス（1 ベース）を返します。文字列が見つからない場合、または指定された文字列 (`str`) にコンマが含まれている場合は 0 を返します。
format_number(expr1, expr2)	数値 `expr1` を '#,###,###.##' のようにフォーマットし、`expr2` 桁に丸めます。`expr2` が 0 の場合、結果には小数点または小数部分がありません。`expr2` はユーザー指定のフォーマットも受け入れます。これは MySQL の FORMAT と同様に機能すると想定されています。
format_string(strfmt, obj, ...)	printf スタイルのフォーマット文字列からフォーマットされた文字列を返します。
initcap(str)	`str` の各単語の最初の文字を大文字にして返します。他のすべての文字は小文字になります。単語は空白文字で区切られます。
instr(str, substr)	`str` 内で `substr` が最初に現れる位置（1 ベース）を返します。
is_valid_utf8(str)	`str` が有効な UTF-8 文字列の場合は true を返します。それ以外の場合は false を返します。
lcase(str)	すべての文字を小文字に変更した `str` を返します。
left(str, len)	文字列 `str` から左側の `len` 文字（`len` は文字列型でも可）を返します。`len` が 0 以下の場合、結果は空文字列になります。
len(expr)	文字列データの文字長またはバイナリデータのバイト数を返します。文字列データの長さには末尾のスペースが含まれます。バイナリデータの長さにはバイナリゼロが含まれます。
length(expr)	文字列データの文字長またはバイナリデータのバイト数を返します。文字列データの長さには末尾のスペースが含まれます。バイナリデータの長さにはバイナリゼロが含まれます。
levenshtein(str1, str2[, threshold])	2 つの指定された文字列間のレーベンシュタイン距離を返します。threshold が設定されており、距離がそれより大きい場合、-1 を返します。
locate(substr, str[, pos])	位置 `pos` より後の `str` 内で `substr` が最初に現れる位置を返します。指定された `pos` および返り値は 1 ベースです。
lower(str)	すべての文字を小文字に変更した `str` を返します。
lpad(str, len[, pad])	`pad` で `len` の長さになるように `str` を左パディングした結果を返します。`str` が `len` より長い場合、返り値は `len` 文字またはバイトに短縮されます。`pad` が指定されていない場合、`str` が文字列表 String の場合はスペース文字で、バイトシーケンスの場合はゼロで左パディングされます。
ltrim(str)	`str` の先頭のスペース文字を削除します。
luhn_check(str )	Luhn アルゴリズムに従って、数字の文字列が有効であることをチェックします。このチェックサム関数は、クレジットカード番号や政府発行の識別番号に広く適用され、無効な番号と間違って入力された番号を区別します。
make_valid_utf8(str)	`str` が有効な UTF-8 文字列の場合は元の文字列を返します。それ以外の場合は、無効な UTF8 バイトシーケンスが UNICODE 置換文字 U+FFFD を使用して置換された新しい文字列を返します。
mask(input[, upperChar, lowerChar, digitChar, otherChar])	指定された文字列値をマスクします。関数は、文字を 'X' または 'x' に、数字を 'n' に置き換えます。これは、機密情報が削除されたテーブルのコピーを作成するのに役立ちます。
octet_length(expr)	文字列データのバイト長またはバイナリデータのバイト数を返します。
overlay(input, replace, pos[, len])	`pos` から開始し、長さ `len` の `replace` を使用して `input` を置き換えます。
position(substr, str[, pos])	位置 `pos` より後の `str` 内で `substr` が最初に現れる位置を返します。指定された `pos` および返り値は 1 ベースです。
printf(strfmt, obj, ...)	printf スタイルのフォーマット文字列からフォーマットされた文字列を返します。
randstr(length[, seed])	次の文字プールから一様にランダムに選択された指定された長さの文字列を返します：0-9、a-z、A-Z。乱数シードはオプションです。文字列長は、定数の 2 バイトまたは 4 バイト整数（それぞれ SMALLINT または INT）である必要があります。
regexp_count(str, regexp)	文字列 `str` で正規表現パターン `regexp` が一致する回数を返します。
regexp_extract(str, regexp[, idx])	`str` 内で `regexp` 式に一致し、正規表現グループインデックスに対応する最初の文字列を抽出します。
regexp_extract_all(str, regexp[, idx])	`str` 内で `regexp` 式に一致し、正規表現グループインデックスに対応するすべての文字列を抽出します。
regexp_instr(str, regexp)	文字列を正規表現で検索し、一致した部分文字列の開始位置を示す整数を返します。位置は 1 ベースであり、0 ベースではありません。一致が見つからない場合は 0 を返します。
regexp_replace(str, regexp, rep[, position])	`regexp` に一致する `str` のすべての一致部分文字列を `rep` に置き換えます。
regexp_substr(str, regexp)	文字列 `str` 内で正規表現 `regexp` に一致する部分文字列を返します。正規表現が見つからない場合、結果は null です。
repeat(str, n)	指定された文字列値を n 回繰り返す文字列を返します。
replace(str, search[, replace])	`search` のすべての一致を `replace` に置き換えます。
right(str, len)	文字列 `str` から右側の `len` 文字（`len` は文字列型でも可）を返します。`len` が 0 以下の場合、結果は空文字列になります。
rpad(str, len[, pad])	`pad` で `len` の長さになるように `str` を右パディングした結果を返します。`str` が `len` より長い場合、返り値は `len` 文字に短縮されます。`pad` が指定されていない場合、`str` が文字列表 String の場合はスペース文字で、バイナリ文字列の場合はゼロで右パディングされます。
rtrim(str)	`str` の末尾のスペース文字を削除します。
sentences(str[, lang[, country]])	`str` を単語の配列の配列に分割します。
soundex(str)	文字列の Soundex コードを返します。
space(n)	n 個のスペースで構成される文字列を返します。
split(str, regex, limit)	`str` を `regex` に一致する出現箇所で分割し、最大 `limit` の長さの配列を返します。
split_part(str, delimiter, partNum)	`str` を区切り文字で分割し、指定された部分（1 ベース）を返します。いずれかの入力が null の場合、null を返します。`partNum` が分割部分の範囲外の場合、空文字列を返します。`partNum` が 0 の場合、エラーが発生します。`partNum` が負の場合、部分文字列は文字列の末尾から逆順にカウントされます。`delimiter` が空文字列の場合、`str` は分割されません。
startswith(left, right)	ブール値を返します。left が right で始まる場合は True を返します。いずれかの入力式が null の場合は NULL を返します。それ以外の場合は False を返します。left と right は両方とも STRING または BINARY 型である必要があります。
substr(str, pos[, len])	`pos` から開始し、長さ `len` の `str` の部分文字列、または `pos` から開始し、長さ `len` のバイト配列のスライスを返します。
substr(str FROM pos[ FOR len]])	`pos` から開始し、長さ `len` の `str` の部分文字列、または `pos` から開始し、長さ `len` のバイト配列のスライスを返します。
substring(str, pos[, len])	`pos` から開始し、長さ `len` の `str` の部分文字列、または `pos` から開始し、長さ `len` のバイト配列のスライスを返します。
substring(str FROM pos[ FOR len]])	`pos` から開始し、長さ `len` の `str` の部分文字列、または `pos` から開始し、長さ `len` のバイト配列のスライスを返します。
substring_index(str, delim, count)	区切り文字 `delim` の `count` 回出現する前の `str` からの部分文字列を返します。`count` が正の場合、最後の区切り文字（左から数えて）の左側にあるすべてが返されます。`count` が負の場合、最後の区切り文字（右から数えて）の右側にあるすべてが返されます。substring_index 関数は、`delim` を検索する際に大文字と小文字を区別します。
to_binary(str[, fmt])	指定された `fmt` に基づいて、入力 `str` をバイナリ値に変換します。`fmt` は "hex"、"utf-8"、"utf8"、または "base64" の大文字小文字を区別しない文字列リテラルにできます。デフォルトでは、`fmt` が省略されている場合、バイナリフォーマットは "hex" です。関数は、少なくとも 1 つの入力パラメータが null の場合、NULL を返します。
to_char(expr, format)	`expr` を `format` に基づいて文字列に変換します。変換に失敗した場合は例外をスローします。フォーマットは、次の文字（大文字小文字を区別しない）で構成されます：'0' または '9'：0 から 9 までの期待される桁を指定します。フォーマット文字列内の 0 または 9 のシーケンスは、入力値の桁のシーケンスと一致し、フォーマット文字列の対応するシーケンスと同じ長さの結果文字列を生成します。結果文字列は、0/9 シーケンスが小数点の前の、10 進値の対応部分よりも多くの桁を含む場合、ゼロで左パディングされます。それ以外の場合はスペースでパディングされます。'.' または 'D'：小数点（オプション、一度のみ許可）の位置を指定します。',' または 'G'：グループ化（千単位）区切り文字（,）の位置を指定します。各グループ化区切り文字の左側と右側には、0 または 9 が必要です。'$'：'$' 通貨記号の位置を指定します。この文字は一度だけ指定できます。'S' または 'MI'：'-' または '+' 記号の位置を指定します（オプション、フォーマット文字列の先頭または末尾に一度だけ許可）。'S' は正の値に '+' を表示しますが、'MI' はスペースを表示することに注意してください。'PR'：フォーマット文字列の末尾でのみ許可されます。入力値が負の場合、結果文字列が山括弧で囲まれることを指定します。（'<1>'）。`expr` が日付/時刻の場合、`format` は有効な日付/時刻パターンである必要があります。 Datetime Patterns を参照してください。`expr` がバイナリの場合、次のいずれかの形式の文字列に変換されます：「base64」：base 64 文字列。「hex」：16 進形式の文字列。「utf-8」：入力バイナリは UTF-8 文字列にデコードされます。
to_number(expr, fmt)	文字列 `expr` を文字列フォーマット `fmt` に基づいて数値に変換します。変換に失敗した場合は例外をスローします。フォーマットは、次の文字（大文字小文字を区別しない）で構成されます：'0' または '9'：0 から 9 までの期待される桁を指定します。フォーマット文字列内の 0 または 9 のシーケンスは、入力文字列の桁のシーケンスと一致します。0/9 シーケンスが 0 で始まり、小数点の前にある場合、同じサイズの桁シーケンスのみと一致できます。それ以外の場合、シーケンスが 9 で始まるか、小数点の後にある場合、同じサイズまたはそれ以下のサイズの桁シーケンスと一致できます。'.' または 'D'：小数点（オプション、一度のみ許可）の位置を指定します。',' または 'G'：グループ化（千単位）区切り文字（,）の位置を指定します。各グループ化区切り文字の左側と右側には、0 または 9 が必要です。`expr` は、数値のサイズに関連するグループ化区切り文字と一致する必要があります。'$'：'$' 通貨記号の位置を指定します。この文字は一度だけ指定できます。'S' または 'MI'：'-' または '+' 記号の位置を指定します（オプション、フォーマット文字列の先頭または末尾に一度だけ許可）。'S' は '-' を許可しますが、'MI' は許可しません。'PR'：フォーマット文字列の末尾でのみ許可されます。`expr` が山括弧で囲まれた負の数であることを指定します。（'<1>'）。
to_varchar(expr, format)	`expr` を `format` に基づいて文字列に変換します。変換に失敗した場合は例外をスローします。フォーマットは、次の文字（大文字小文字を区別しない）で構成されます：'0' または '9'：0 から 9 までの期待される桁を指定します。フォーマット文字列内の 0 または 9 のシーケンスは、入力値の桁のシーケンスと一致し、フォーマット文字列の対応するシーケンスと同じ長さの結果文字列を生成します。結果文字列は、0/9 シーケンスが小数点の前の、10 進値の対応部分よりも多くの桁を含む場合、ゼロで左パディングされます。それ以外の場合はスペースでパディングされます。'.' または 'D'：小数点（オプション、一度のみ許可）の位置を指定します。',' または 'G'：グループ化（千単位）区切り文字（,）の位置を指定します。各グループ化区切り文字の左側と右側には、0 または 9 が必要です。'$'：'$' 通貨記号の位置を指定します。この文字は一度だけ指定できます。'S' または 'MI'：'-' または '+' 記号の位置を指定します（オプション、フォーマット文字列の先頭または末尾に一度だけ許可）。'S' は正の値に '+' を表示しますが、'MI' はスペースを表示することに注意してください。'PR'：フォーマット文字列の末尾でのみ許可されます。入力値が負の場合、結果文字列が山括弧で囲まれることを指定します。（'<1>'）。`expr` が日付/時刻の場合、`format` は有効な日付/時刻パターンである必要があります。 Datetime Patterns を参照してください。`expr` がバイナリの場合、次のいずれかの形式の文字列に変換されます：「base64」：base 64 文字列。「hex」：16 進形式の文字列。「utf-8」：入力バイナリは UTF-8 文字列にデコードされます。
translate(input, from, to)	`from` 文字列に含まれる文字を `to` 文字列の対応する文字で置き換えることにより、`input` 文字列を変換します。
trim(str)	`str` の先頭および末尾のスペース文字を削除します。
trim(BOTH FROM str)	`str` の先頭および末尾のスペース文字を削除します。
trim(LEADING FROM str)	`str` の先頭のスペース文字を削除します。
trim(TRAILING FROM str)	`str` の末尾のスペース文字を削除します。
trim(trimStr FROM str)	`trimStr` の先頭および末尾の文字を `str` から削除します。
trim(BOTH trimStr FROM str)	`trimStr` の先頭および末尾の文字を `str` から削除します。
trim(LEADING trimStr FROM str)	`str` から先頭の `trimStr` 文字を削除します。
trim(TRAILING trimStr FROM str)	`str` から末尾の `trimStr` 文字を削除します。
try_to_binary(str[, fmt])	`to_binary` の特殊バージョンで、同じ操作を実行しますが、変換が実行できない場合にエラーをスローする代わりに NULL 値を返します。
try_to_number(expr, fmt)	文字列 `expr` を文字列フォーマット `fmt` に基づいて数値に変換します。文字列 `expr` が期待されるフォーマットと一致しない場合、NULL を返します。フォーマットは to_number 関数と同じセマンティクスに従います。
try_validate_utf8(str)	`str` が有効な UTF-8 文字列の場合は元の文字列を返します。それ以外の場合は NULL を返します。
ucase(str)	すべての文字を大文字に変更した `str` を返します。
unbase64(str)	引数から base 64 文字列 `str` をバイナリに変換します。
upper(str)	すべての文字を大文字に変更した `str` を返します。
validate_utf8(str)	`str` が有効な UTF-8 文字列の場合は元の文字列を返します。それ以外の場合は例外をスローします。

例

-- ascii
SELECT ascii('222');
+----------+
|ascii(222)|
+----------+
|        50|
+----------+

SELECT ascii(2);
+--------+
|ascii(2)|
+--------+
|      50|
+--------+

-- base64
SELECT base64('Spark SQL');
+-----------------+
|base64(Spark SQL)|
+-----------------+
|     U3BhcmsgU1FM|
+-----------------+

SELECT base64(x'537061726b2053514c');
+-----------------------------+
|base64(X'537061726B2053514C')|
+-----------------------------+
|                 U3BhcmsgU1FM|
+-----------------------------+

-- bit_length
SELECT bit_length('Spark SQL');
+---------------------+
|bit_length(Spark SQL)|
+---------------------+
|                   72|
+---------------------+

SELECT bit_length(x'537061726b2053514c');
+---------------------------------+
|bit_length(X'537061726B2053514C')|
+---------------------------------+
|                               72|
+---------------------------------+

-- btrim
SELECT btrim('    SparkSQL   ');
+----------------------+
|btrim(    SparkSQL   )|
+----------------------+
|              SparkSQL|
+----------------------+

SELECT btrim(encode('    SparkSQL   ', 'utf-8'));
+-------------------------------------+
|btrim(encode(    SparkSQL   , utf-8))|
+-------------------------------------+
|                             SparkSQL|
+-------------------------------------+

SELECT btrim('SSparkSQLS', 'SL');
+---------------------+
|btrim(SSparkSQLS, SL)|
+---------------------+
|               parkSQ|
+---------------------+

SELECT btrim(encode('SSparkSQLS', 'utf-8'), encode('SL', 'utf-8'));
+---------------------------------------------------+
|btrim(encode(SSparkSQLS, utf-8), encode(SL, utf-8))|
+---------------------------------------------------+
|                                             parkSQ|
+---------------------------------------------------+

-- char
SELECT char(65);
+--------+
|char(65)|
+--------+
|       A|
+--------+

-- char_length
SELECT char_length('Spark SQL ');
+-----------------------+
|char_length(Spark SQL )|
+-----------------------+
|                     10|
+-----------------------+

SELECT char_length(x'537061726b2053514c');
+----------------------------------+
|char_length(X'537061726B2053514C')|
+----------------------------------+
|                                 9|
+----------------------------------+

SELECT CHAR_LENGTH('Spark SQL ');
+-----------------------+
|char_length(Spark SQL )|
+-----------------------+
|                     10|
+-----------------------+

SELECT CHARACTER_LENGTH('Spark SQL ');
+----------------------------+
|character_length(Spark SQL )|
+----------------------------+
|                          10|
+----------------------------+

-- character_length
SELECT character_length('Spark SQL ');
+----------------------------+
|character_length(Spark SQL )|
+----------------------------+
|                          10|
+----------------------------+

SELECT character_length(x'537061726b2053514c');
+---------------------------------------+
|character_length(X'537061726B2053514C')|
+---------------------------------------+
|                                      9|
+---------------------------------------+

SELECT CHAR_LENGTH('Spark SQL ');
+-----------------------+
|char_length(Spark SQL )|
+-----------------------+
|                     10|
+-----------------------+

SELECT CHARACTER_LENGTH('Spark SQL ');
+----------------------------+
|character_length(Spark SQL )|
+----------------------------+
|                          10|
+----------------------------+

-- chr
SELECT chr(65);
+-------+
|chr(65)|
+-------+
|      A|
+-------+

-- collate
SELECT COLLATION('Spark SQL' collate UTF8_LCASE);
+-----------------------------------------+
|collation(collate(Spark SQL, UTF8_LCASE))|
+-----------------------------------------+
|                     SYSTEM.BUILTIN.UT...|
+-----------------------------------------+

-- collation
SELECT collation('Spark SQL');
+--------------------+
|collation(Spark SQL)|
+--------------------+
|SYSTEM.BUILTIN.UT...|
+--------------------+

-- concat_ws
SELECT concat_ws(' ', 'Spark', 'SQL');
+------------------------+
|concat_ws( , Spark, SQL)|
+------------------------+
|               Spark SQL|
+------------------------+

SELECT concat_ws('s');
+------------+
|concat_ws(s)|
+------------+
|            |
+------------+

SELECT concat_ws('/', 'foo', null, 'bar');
+----------------------------+
|concat_ws(/, foo, NULL, bar)|
+----------------------------+
|                     foo/bar|
+----------------------------+

SELECT concat_ws(null, 'Spark', 'SQL');
+---------------------------+
|concat_ws(NULL, Spark, SQL)|
+---------------------------+
|                       NULL|
+---------------------------+

-- contains
SELECT contains('Spark SQL', 'Spark');
+--------------------------+
|contains(Spark SQL, Spark)|
+--------------------------+
|                      true|
+--------------------------+

SELECT contains('Spark SQL', 'SPARK');
+--------------------------+
|contains(Spark SQL, SPARK)|
+--------------------------+
|                     false|
+--------------------------+

SELECT contains('Spark SQL', null);
+-------------------------+
|contains(Spark SQL, NULL)|
+-------------------------+
|                     NULL|
+-------------------------+

SELECT contains(x'537061726b2053514c', x'537061726b');
+----------------------------------------------+
|contains(X'537061726B2053514C', X'537061726B')|
+----------------------------------------------+
|                                          true|
+----------------------------------------------+

-- decode
SELECT decode(encode('abc', 'utf-8'), 'utf-8');
+---------------------------------+
|decode(encode(abc, utf-8), utf-8)|
+---------------------------------+
|                              abc|
+---------------------------------+

SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
+----------------------------------------------------------------------------------+
|decode(2, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)|
+----------------------------------------------------------------------------------+
|                                                                     San Francisco|
+----------------------------------------------------------------------------------+

SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
+----------------------------------------------------------------------------------+
|decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)|
+----------------------------------------------------------------------------------+
|                                                                      Non domestic|
+----------------------------------------------------------------------------------+

SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle');
+--------------------------------------------------------------------+
|decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle)|
+--------------------------------------------------------------------+
|                                                                NULL|
+--------------------------------------------------------------------+

SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, 'rocks');
+-------------------------------------------+
|decode(NULL, 6, Spark, NULL, SQL, 4, rocks)|
+-------------------------------------------+
|                                        SQL|
+-------------------------------------------+

-- elt
SELECT elt(1, 'scala', 'java');
+-------------------+
|elt(1, scala, java)|
+-------------------+
|              scala|
+-------------------+

SELECT elt(2, 'a', 1);
+------------+
|elt(2, a, 1)|
+------------+
|           1|
+------------+

-- encode
SELECT encode('abc', 'utf-8');
+------------------+
|encode(abc, utf-8)|
+------------------+
|        [61 62 63]|
+------------------+

-- endswith
SELECT endswith('Spark SQL', 'SQL');
+------------------------+
|endswith(Spark SQL, SQL)|
+------------------------+
|                    true|
+------------------------+

SELECT endswith('Spark SQL', 'Spark');
+--------------------------+
|endswith(Spark SQL, Spark)|
+--------------------------+
|                     false|
+--------------------------+

SELECT endswith('Spark SQL', null);
+-------------------------+
|endswith(Spark SQL, NULL)|
+-------------------------+
|                     NULL|
+-------------------------+

SELECT endswith(x'537061726b2053514c', x'537061726b');
+----------------------------------------------+
|endswith(X'537061726B2053514C', X'537061726B')|
+----------------------------------------------+
|                                         false|
+----------------------------------------------+

SELECT endswith(x'537061726b2053514c', x'53514c');
+------------------------------------------+
|endswith(X'537061726B2053514C', X'53514C')|
+------------------------------------------+
|                                      true|
+------------------------------------------+

-- find_in_set
SELECT find_in_set('ab','abc,b,ab,c,def');
+-------------------------------+
|find_in_set(ab, abc,b,ab,c,def)|
+-------------------------------+
|                              3|
+-------------------------------+

-- format_number
SELECT format_number(12332.123456, 4);
+------------------------------+
|format_number(12332.123456, 4)|
+------------------------------+
|                   12,332.1235|
+------------------------------+

SELECT format_number(12332.123456, '##################.###');
+---------------------------------------------------+
|format_number(12332.123456, ##################.###)|
+---------------------------------------------------+
|                                          12332.123|
+---------------------------------------------------+

-- format_string
SELECT format_string("Hello World %d %s", 100, "days");
+-------------------------------------------+
|format_string(Hello World %d %s, 100, days)|
+-------------------------------------------+
|                       Hello World 100 days|
+-------------------------------------------+

-- initcap
SELECT initcap('sPark sql');
+------------------+
|initcap(sPark sql)|
+------------------+
|         Spark Sql|
+------------------+

-- instr
SELECT instr('SparkSQL', 'SQL');
+--------------------+
|instr(SparkSQL, SQL)|
+--------------------+
|                   6|
+--------------------+

-- is_valid_utf8
SELECT is_valid_utf8('Spark');
+--------------------+
|is_valid_utf8(Spark)|
+--------------------+
|                true|
+--------------------+

SELECT is_valid_utf8(x'61');
+--------------------+
|is_valid_utf8(X'61')|
+--------------------+
|                true|
+--------------------+

SELECT is_valid_utf8(x'80');
+--------------------+
|is_valid_utf8(X'80')|
+--------------------+
|               false|
+--------------------+

SELECT is_valid_utf8(x'61C262');
+------------------------+
|is_valid_utf8(X'61C262')|
+------------------------+
|                   false|
+------------------------+

-- lcase
SELECT lcase('SparkSql');
+---------------+
|lcase(SparkSql)|
+---------------+
|       sparksql|
+---------------+

-- left
SELECT left('Spark SQL', 3);
+------------------+
|left(Spark SQL, 3)|
+------------------+
|               Spa|
+------------------+

SELECT left(encode('Spark SQL', 'utf-8'), 3);
+---------------------------------+
|left(encode(Spark SQL, utf-8), 3)|
+---------------------------------+
|                       [53 70 61]|
+---------------------------------+

-- len
SELECT len('Spark SQL ');
+---------------+
|len(Spark SQL )|
+---------------+
|             10|
+---------------+

SELECT len(x'537061726b2053514c');
+--------------------------+
|len(X'537061726B2053514C')|
+--------------------------+
|                         9|
+--------------------------+

SELECT CHAR_LENGTH('Spark SQL ');
+-----------------------+
|char_length(Spark SQL )|
+-----------------------+
|                     10|
+-----------------------+

SELECT CHARACTER_LENGTH('Spark SQL ');
+----------------------------+
|character_length(Spark SQL )|
+----------------------------+
|                          10|
+----------------------------+

-- length
SELECT length('Spark SQL ');
+------------------+
|length(Spark SQL )|
+------------------+
|                10|
+------------------+

SELECT length(x'537061726b2053514c');
+-----------------------------+
|length(X'537061726B2053514C')|
+-----------------------------+
|                            9|
+-----------------------------+

SELECT CHAR_LENGTH('Spark SQL ');
+-----------------------+
|char_length(Spark SQL )|
+-----------------------+
|                     10|
+-----------------------+

SELECT CHARACTER_LENGTH('Spark SQL ');
+----------------------------+
|character_length(Spark SQL )|
+----------------------------+
|                          10|
+----------------------------+

-- levenshtein
SELECT levenshtein('kitten', 'sitting');
+----------------------------+
|levenshtein(kitten, sitting)|
+----------------------------+
|                           3|
+----------------------------+

SELECT levenshtein('kitten', 'sitting', 2);
+-------------------------------+
|levenshtein(kitten, sitting, 2)|
+-------------------------------+
|                             -1|
+-------------------------------+

-- locate
SELECT locate('bar', 'foobarbar');
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
|                        4|
+-------------------------+

SELECT locate('bar', 'foobarbar', 5);
+-------------------------+
|locate(bar, foobarbar, 5)|
+-------------------------+
|                        7|
+-------------------------+

SELECT POSITION('bar' IN 'foobarbar');
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
|                        4|
+-------------------------+

-- lower
SELECT lower('SparkSql');
+---------------+
|lower(SparkSql)|
+---------------+
|       sparksql|
+---------------+

-- lpad
SELECT lpad('hi', 5, '??');
+---------------+
|lpad(hi, 5, ??)|
+---------------+
|          ???hi|
+---------------+

SELECT lpad('hi', 1, '??');
+---------------+
|lpad(hi, 1, ??)|
+---------------+
|              h|
+---------------+

SELECT lpad('hi', 5);
+--------------+
|lpad(hi, 5,  )|
+--------------+
|            hi|
+--------------+

SELECT hex(lpad(unhex('aabb'), 5));
+--------------------------------+
|hex(lpad(unhex(aabb), 5, X'00'))|
+--------------------------------+
|                      000000AABB|
+--------------------------------+

SELECT hex(lpad(unhex('aabb'), 5, unhex('1122')));
+--------------------------------------+
|hex(lpad(unhex(aabb), 5, unhex(1122)))|
+--------------------------------------+
|                            112211AABB|
+--------------------------------------+

-- ltrim
SELECT ltrim('    SparkSQL   ');
+----------------------+
|ltrim(    SparkSQL   )|
+----------------------+
|           SparkSQL   |
+----------------------+

-- luhn_check
SELECT luhn_check('8112189876');
+----------------------+
|luhn_check(8112189876)|
+----------------------+
|                  true|
+----------------------+

SELECT luhn_check('79927398713');
+-----------------------+
|luhn_check(79927398713)|
+-----------------------+
|                   true|
+-----------------------+

SELECT luhn_check('79927398714');
+-----------------------+
|luhn_check(79927398714)|
+-----------------------+
|                  false|
+-----------------------+

-- make_valid_utf8
SELECT make_valid_utf8('Spark');
+----------------------+
|make_valid_utf8(Spark)|
+----------------------+
|                 Spark|
+----------------------+

SELECT make_valid_utf8(x'61');
+----------------------+
|make_valid_utf8(X'61')|
+----------------------+
|                     a|
+----------------------+

SELECT make_valid_utf8(x'80');
+----------------------+
|make_valid_utf8(X'80')|
+----------------------+
|                     �|
+----------------------+

SELECT make_valid_utf8(x'61C262');
+--------------------------+
|make_valid_utf8(X'61C262')|
+--------------------------+
|                       a�b|
+--------------------------+

-- mask
SELECT mask('abcd-EFGH-8765-4321');
+----------------------------------------+
|mask(abcd-EFGH-8765-4321, X, x, n, NULL)|
+----------------------------------------+
|                     xxxx-XXXX-nnnn-nnnn|
+----------------------------------------+

SELECT mask('abcd-EFGH-8765-4321', 'Q');
+----------------------------------------+
|mask(abcd-EFGH-8765-4321, Q, x, n, NULL)|
+----------------------------------------+
|                     xxxx-QQQQ-nnnn-nnnn|
+----------------------------------------+

SELECT mask('AbCD123-@$#', 'Q', 'q');
+--------------------------------+
|mask(AbCD123-@$#, Q, q, n, NULL)|
+--------------------------------+
|                     QqQQnnn-@$#|
+--------------------------------+

SELECT mask('AbCD123-@$#');
+--------------------------------+
|mask(AbCD123-@$#, X, x, n, NULL)|
+--------------------------------+
|                     XxXXnnn-@$#|
+--------------------------------+

SELECT mask('AbCD123-@$#', 'Q');
+--------------------------------+
|mask(AbCD123-@$#, Q, x, n, NULL)|
+--------------------------------+
|                     QxQQnnn-@$#|
+--------------------------------+

SELECT mask('AbCD123-@$#', 'Q', 'q');
+--------------------------------+
|mask(AbCD123-@$#, Q, q, n, NULL)|
+--------------------------------+
|                     QqQQnnn-@$#|
+--------------------------------+

SELECT mask('AbCD123-@$#', 'Q', 'q', 'd');
+--------------------------------+
|mask(AbCD123-@$#, Q, q, d, NULL)|
+--------------------------------+
|                     QqQQddd-@$#|
+--------------------------------+

SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o');
+-----------------------------+
|mask(AbCD123-@$#, Q, q, d, o)|
+-----------------------------+
|                  QqQQdddoooo|
+-----------------------------+

SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o');
+--------------------------------+
|mask(AbCD123-@$#, NULL, q, d, o)|
+--------------------------------+
|                     AqCDdddoooo|
+--------------------------------+

SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o');
+-----------------------------------+
|mask(AbCD123-@$#, NULL, NULL, d, o)|
+-----------------------------------+
|                        AbCDdddoooo|
+-----------------------------------+

SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o');
+--------------------------------------+
|mask(AbCD123-@$#, NULL, NULL, NULL, o)|
+--------------------------------------+
|                           AbCD123oooo|
+--------------------------------------+

SELECT mask(NULL, NULL, NULL, NULL, 'o');
+-------------------------------+
|mask(NULL, NULL, NULL, NULL, o)|
+-------------------------------+
|                           NULL|
+-------------------------------+

SELECT mask(NULL);
+-------------------------+
|mask(NULL, X, x, n, NULL)|
+-------------------------+
|                     NULL|
+-------------------------+

SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL);
+-----------------------------------------+
|mask(AbCD123-@$#, NULL, NULL, NULL, NULL)|
+-----------------------------------------+
|                              AbCD123-@$#|
+-----------------------------------------+

-- octet_length
SELECT octet_length('Spark SQL');
+-----------------------+
|octet_length(Spark SQL)|
+-----------------------+
|                      9|
+-----------------------+

SELECT octet_length(x'537061726b2053514c');
+-----------------------------------+
|octet_length(X'537061726B2053514C')|
+-----------------------------------+
|                                  9|
+-----------------------------------+

-- overlay
SELECT overlay('Spark SQL' PLACING '_' FROM 6);
+----------------------------+
|overlay(Spark SQL, _, 6, -1)|
+----------------------------+
|                   Spark_SQL|
+----------------------------+

SELECT overlay('Spark SQL' PLACING 'CORE' FROM 7);
+-------------------------------+
|overlay(Spark SQL, CORE, 7, -1)|
+-------------------------------+
|                     Spark CORE|
+-------------------------------+

SELECT overlay('Spark SQL' PLACING 'ANSI ' FROM 7 FOR 0);
+-------------------------------+
|overlay(Spark SQL, ANSI , 7, 0)|
+-------------------------------+
|                 Spark ANSI SQL|
+-------------------------------+

SELECT overlay('Spark SQL' PLACING 'tructured' FROM 2 FOR 4);
+-----------------------------------+
|overlay(Spark SQL, tructured, 2, 4)|
+-----------------------------------+
|                     Structured SQL|
+-----------------------------------+

SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('_', 'utf-8') FROM 6);
+----------------------------------------------------------+
|overlay(encode(Spark SQL, utf-8), encode(_, utf-8), 6, -1)|
+----------------------------------------------------------+
|                                      [53 70 61 72 6B 5...|
+----------------------------------------------------------+

SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('CORE', 'utf-8') FROM 7);
+-------------------------------------------------------------+
|overlay(encode(Spark SQL, utf-8), encode(CORE, utf-8), 7, -1)|
+-------------------------------------------------------------+
|                                         [53 70 61 72 6B 2...|
+-------------------------------------------------------------+

SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('ANSI ', 'utf-8') FROM 7 FOR 0);
+-------------------------------------------------------------+
|overlay(encode(Spark SQL, utf-8), encode(ANSI , utf-8), 7, 0)|
+-------------------------------------------------------------+
|                                         [53 70 61 72 6B 2...|
+-------------------------------------------------------------+

SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('tructured', 'utf-8') FROM 2 FOR 4);
+-----------------------------------------------------------------+
|overlay(encode(Spark SQL, utf-8), encode(tructured, utf-8), 2, 4)|
+-----------------------------------------------------------------+
|                                             [53 74 72 75 63 7...|
+-----------------------------------------------------------------+

-- position
SELECT position('bar', 'foobarbar');
+---------------------------+
|position(bar, foobarbar, 1)|
+---------------------------+
|                          4|
+---------------------------+

SELECT position('bar', 'foobarbar', 5);
+---------------------------+
|position(bar, foobarbar, 5)|
+---------------------------+
|                          7|
+---------------------------+

SELECT POSITION('bar' IN 'foobarbar');
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
|                        4|
+-------------------------+

-- printf
SELECT printf("Hello World %d %s", 100, "days");
+------------------------------------+
|printf(Hello World %d %s, 100, days)|
+------------------------------------+
|                Hello World 100 days|
+------------------------------------+

-- randstr
SELECT randstr(3, 0) AS result;
+------+
|result|
+------+
|   ceV|
+------+

-- regexp_count
SELECT regexp_count('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');
+------------------------------------------------------------------------------+
|regexp_count(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)|
+------------------------------------------------------------------------------+
|                                                                             2|
+------------------------------------------------------------------------------+

SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------------------------------------------+
|regexp_count(abcdefghijklmnopqrstuvwxyz, [a-z]{3})|
+--------------------------------------------------+
|                                                 8|
+--------------------------------------------------+

-- regexp_extract
SELECT regexp_extract('100-200', '(\\d+)-(\\d+)', 1);
+---------------------------------------+
|regexp_extract(100-200, (\d+)-(\d+), 1)|
+---------------------------------------+
|                                    100|
+---------------------------------------+

SELECT regexp_extract('100-200', r'(\d+)-(\d+)', 1);
+---------------------------------------+
|regexp_extract(100-200, (\d+)-(\d+), 1)|
+---------------------------------------+
|                                    100|
+---------------------------------------+

-- regexp_extract_all
SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)', 1);
+----------------------------------------------------+
|regexp_extract_all(100-200, 300-400, (\d+)-(\d+), 1)|
+----------------------------------------------------+
|                                          [100, 300]|
+----------------------------------------------------+

SELECT regexp_extract_all('100-200, 300-400', r'(\d+)-(\d+)', 1);
+----------------------------------------------------+
|regexp_extract_all(100-200, 300-400, (\d+)-(\d+), 1)|
+----------------------------------------------------+
|                                          [100, 300]|
+----------------------------------------------------+

-- regexp_instr
SELECT regexp_instr(r"\abc", r"^\\abc$");
+------------------------------+
|regexp_instr(\abc, ^\\abc$, 0)|
+------------------------------+
|                             1|
+------------------------------+

SELECT regexp_instr('user@spark.apache.org', '@[^.]*');
+----------------------------------------------+
|regexp_instr(user@spark.apache.org, @[^.]*, 0)|
+----------------------------------------------+
|                                             5|
+----------------------------------------------+

-- regexp_replace
SELECT regexp_replace('100-200', '(\\d+)', 'num');
+--------------------------------------+
|regexp_replace(100-200, (\d+), num, 1)|
+--------------------------------------+
|                               num-num|
+--------------------------------------+

SELECT regexp_replace('100-200', r'(\d+)', 'num');
+--------------------------------------+
|regexp_replace(100-200, (\d+), num, 1)|
+--------------------------------------+
|                               num-num|
+--------------------------------------+

-- regexp_substr
SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');
+-------------------------------------------------------------------------------+
|regexp_substr(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)|
+-------------------------------------------------------------------------------+
|                                                                         Steven|
+-------------------------------------------------------------------------------+

SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Jeck');
+------------------------------------------------------------------------+
|regexp_substr(Steven Jones and Stephen Smith are the best players, Jeck)|
+------------------------------------------------------------------------+
|                                                                    NULL|
+------------------------------------------------------------------------+

-- repeat
SELECT repeat('123', 2);
+--------------+
|repeat(123, 2)|
+--------------+
|        123123|
+--------------+

-- replace
SELECT replace('ABCabc', 'abc', 'DEF');
+-------------------------+
|replace(ABCabc, abc, DEF)|
+-------------------------+
|                   ABCDEF|
+-------------------------+

-- right
SELECT right('Spark SQL', 3);
+-------------------+
|right(Spark SQL, 3)|
+-------------------+
|                SQL|
+-------------------+

-- rpad
SELECT rpad('hi', 5, '??');
+---------------+
|rpad(hi, 5, ??)|
+---------------+
|          hi???|
+---------------+

SELECT rpad('hi', 1, '??');
+---------------+
|rpad(hi, 1, ??)|
+---------------+
|              h|
+---------------+

SELECT rpad('hi', 5);
+--------------+
|rpad(hi, 5,  )|
+--------------+
|         hi   |
+--------------+

SELECT hex(rpad(unhex('aabb'), 5));
+--------------------------------+
|hex(rpad(unhex(aabb), 5, X'00'))|
+--------------------------------+
|                      AABB000000|
+--------------------------------+

SELECT hex(rpad(unhex('aabb'), 5, unhex('1122')));
+--------------------------------------+
|hex(rpad(unhex(aabb), 5, unhex(1122)))|
+--------------------------------------+
|                            AABB112211|
+--------------------------------------+

-- rtrim
SELECT rtrim('    SparkSQL   ');
+----------------------+
|rtrim(    SparkSQL   )|
+----------------------+
|              SparkSQL|
+----------------------+

-- sentences
SELECT sentences('Hi there! Good morning.');
+--------------------------------------+
|sentences(Hi there! Good morning., , )|
+--------------------------------------+
|                  [[Hi, there], [Go...|
+--------------------------------------+

SELECT sentences('Hi there! Good morning.', 'en');
+----------------------------------------+
|sentences(Hi there! Good morning., en, )|
+----------------------------------------+
|                    [[Hi, there], [Go...|
+----------------------------------------+

SELECT sentences('Hi there! Good morning.', 'en', 'US');
+------------------------------------------+
|sentences(Hi there! Good morning., en, US)|
+------------------------------------------+
|                      [[Hi, there], [Go...|
+------------------------------------------+

-- soundex
SELECT soundex('Miller');
+---------------+
|soundex(Miller)|
+---------------+
|           M460|
+---------------+

-- space
SELECT concat(space(2), '1');
+-------------------+
|concat(space(2), 1)|
+-------------------+
|                  1|
+-------------------+

-- split
SELECT split('oneAtwoBthreeC', '[ABC]');
+--------------------------------+
|split(oneAtwoBthreeC, [ABC], -1)|
+--------------------------------+
|             [one, two, three, ]|
+--------------------------------+

SELECT split('oneAtwoBthreeC', '[ABC]', -1);
+--------------------------------+
|split(oneAtwoBthreeC, [ABC], -1)|
+--------------------------------+
|             [one, two, three, ]|
+--------------------------------+

SELECT split('oneAtwoBthreeC', '[ABC]', 2);
+-------------------------------+
|split(oneAtwoBthreeC, [ABC], 2)|
+-------------------------------+
|              [one, twoBthreeC]|
+-------------------------------+

-- split_part
SELECT split_part('11.12.13', '.', 3);
+--------------------------+
|split_part(11.12.13, ., 3)|
+--------------------------+
|                        13|
+--------------------------+

-- startswith
SELECT startswith('Spark SQL', 'Spark');
+----------------------------+
|startswith(Spark SQL, Spark)|
+----------------------------+
|                        true|
+----------------------------+

SELECT startswith('Spark SQL', 'SQL');
+--------------------------+
|startswith(Spark SQL, SQL)|
+--------------------------+
|                     false|
+--------------------------+

SELECT startswith('Spark SQL', null);
+---------------------------+
|startswith(Spark SQL, NULL)|
+---------------------------+
|                       NULL|
+---------------------------+

SELECT startswith(x'537061726b2053514c', x'537061726b');
+------------------------------------------------+
|startswith(X'537061726B2053514C', X'537061726B')|
+------------------------------------------------+
|                                            true|
+------------------------------------------------+

SELECT startswith(x'537061726b2053514c', x'53514c');
+--------------------------------------------+
|startswith(X'537061726B2053514C', X'53514C')|
+--------------------------------------------+
|                                       false|
+--------------------------------------------+

-- substr
SELECT substr('Spark SQL', 5);
+--------------------------------+
|substr(Spark SQL, 5, 2147483647)|
+--------------------------------+
|                           k SQL|
+--------------------------------+

SELECT substr('Spark SQL', -3);
+---------------------------------+
|substr(Spark SQL, -3, 2147483647)|
+---------------------------------+
|                              SQL|
+---------------------------------+

SELECT substr('Spark SQL', 5, 1);
+-----------------------+
|substr(Spark SQL, 5, 1)|
+-----------------------+
|                      k|
+-----------------------+

SELECT substr('Spark SQL' FROM 5);
+-----------------------------------+
|substring(Spark SQL, 5, 2147483647)|
+-----------------------------------+
|                              k SQL|
+-----------------------------------+

SELECT substr('Spark SQL' FROM -3);
+------------------------------------+
|substring(Spark SQL, -3, 2147483647)|
+------------------------------------+
|                                 SQL|
+------------------------------------+

SELECT substr('Spark SQL' FROM 5 FOR 1);
+--------------------------+
|substring(Spark SQL, 5, 1)|
+--------------------------+
|                         k|
+--------------------------+

SELECT substr(encode('Spark SQL', 'utf-8'), 5);
+-----------------------------------------------+
|substr(encode(Spark SQL, utf-8), 5, 2147483647)|
+-----------------------------------------------+
|                               [6B 20 53 51 4C]|
+-----------------------------------------------+

-- substring
SELECT substring('Spark SQL', 5);
+-----------------------------------+
|substring(Spark SQL, 5, 2147483647)|
+-----------------------------------+
|                              k SQL|
+-----------------------------------+

SELECT substring('Spark SQL', -3);
+------------------------------------+
|substring(Spark SQL, -3, 2147483647)|
+------------------------------------+
|                                 SQL|
+------------------------------------+

SELECT substring('Spark SQL', 5, 1);
+--------------------------+
|substring(Spark SQL, 5, 1)|
+--------------------------+
|                         k|
+--------------------------+

SELECT substring('Spark SQL' FROM 5);
+-----------------------------------+
|substring(Spark SQL, 5, 2147483647)|
+-----------------------------------+
|                              k SQL|
+-----------------------------------+

SELECT substring('Spark SQL' FROM -3);
+------------------------------------+
|substring(Spark SQL, -3, 2147483647)|
+------------------------------------+
|                                 SQL|
+------------------------------------+

SELECT substring('Spark SQL' FROM 5 FOR 1);
+--------------------------+
|substring(Spark SQL, 5, 1)|
+--------------------------+
|                         k|
+--------------------------+

SELECT substring(encode('Spark SQL', 'utf-8'), 5);
+--------------------------------------------------+
|substring(encode(Spark SQL, utf-8), 5, 2147483647)|
+--------------------------------------------------+
|                                  [6B 20 53 51 4C]|
+--------------------------------------------------+

-- substring_index
SELECT substring_index('www.apache.org', '.', 2);
+-------------------------------------+
|substring_index(www.apache.org, ., 2)|
+-------------------------------------+
|                           www.apache|
+-------------------------------------+

-- to_binary
SELECT to_binary('abc', 'utf-8');
+---------------------+
|to_binary(abc, utf-8)|
+---------------------+
|           [61 62 63]|
+---------------------+

-- to_char
SELECT to_char(454, '999');
+-----------------+
|to_char(454, 999)|
+-----------------+
|              454|
+-----------------+

SELECT to_char(454.00, '000D00');
+-----------------------+
|to_char(454.00, 000D00)|
+-----------------------+
|                 454.00|
+-----------------------+

SELECT to_char(12454, '99G999');
+----------------------+
|to_char(12454, 99G999)|
+----------------------+
|                12,454|
+----------------------+

SELECT to_char(78.12, '$99.99');
+----------------------+
|to_char(78.12, $99.99)|
+----------------------+
|                $78.12|
+----------------------+

SELECT to_char(-12454.8, '99G999D9S');
+----------------------------+
|to_char(-12454.8, 99G999D9S)|
+----------------------------+
|                   12,454.8-|
+----------------------------+

SELECT to_char(date'2016-04-08', 'y');
+---------------------------------+
|date_format(DATE '2016-04-08', y)|
+---------------------------------+
|                             2016|
+---------------------------------+

SELECT to_char(x'537061726b2053514c', 'base64');
+-----------------------------+
|base64(X'537061726B2053514C')|
+-----------------------------+
|                 U3BhcmsgU1FM|
+-----------------------------+

SELECT to_char(x'537061726b2053514c', 'hex');
+--------------------------+
|hex(X'537061726B2053514C')|
+--------------------------+
|        537061726B2053514C|
+--------------------------+

SELECT to_char(encode('abc', 'utf-8'), 'utf-8');
+---------------------------------+
|decode(encode(abc, utf-8), utf-8)|
+---------------------------------+
|                              abc|
+---------------------------------+

-- to_number
SELECT to_number('454', '999');
+-------------------+
|to_number(454, 999)|
+-------------------+
|                454|
+-------------------+

SELECT to_number('454.00', '000.00');
+-------------------------+
|to_number(454.00, 000.00)|
+-------------------------+
|                   454.00|
+-------------------------+

SELECT to_number('12,454', '99,999');
+-------------------------+
|to_number(12,454, 99,999)|
+-------------------------+
|                    12454|
+-------------------------+

SELECT to_number('$78.12', '$99.99');
+-------------------------+
|to_number($78.12, $99.99)|
+-------------------------+
|                    78.12|
+-------------------------+

SELECT to_number('12,454.8-', '99,999.9S');
+-------------------------------+
|to_number(12,454.8-, 99,999.9S)|
+-------------------------------+
|                       -12454.8|
+-------------------------------+

-- to_varchar
SELECT to_varchar(454, '999');
+-----------------+
|to_char(454, 999)|
+-----------------+
|              454|
+-----------------+

SELECT to_varchar(454.00, '000D00');
+-----------------------+
|to_char(454.00, 000D00)|
+-----------------------+
|                 454.00|
+-----------------------+

SELECT to_varchar(12454, '99G999');
+----------------------+
|to_char(12454, 99G999)|
+----------------------+
|                12,454|
+----------------------+

SELECT to_varchar(78.12, '$99.99');
+----------------------+
|to_char(78.12, $99.99)|
+----------------------+
|                $78.12|
+----------------------+

SELECT to_varchar(-12454.8, '99G999D9S');
+----------------------------+
|to_char(-12454.8, 99G999D9S)|
+----------------------------+
|                   12,454.8-|
+----------------------------+

SELECT to_varchar(date'2016-04-08', 'y');
+---------------------------------+
|date_format(DATE '2016-04-08', y)|
+---------------------------------+
|                             2016|
+---------------------------------+

SELECT to_varchar(x'537061726b2053514c', 'base64');
+---------------------------------+
|to_varchar(X'537061726B2053514C')|
+---------------------------------+
|                     U3BhcmsgU1FM|
+---------------------------------+

SELECT to_varchar(x'537061726b2053514c', 'hex');
+---------------------------------+
|to_varchar(X'537061726B2053514C')|
+---------------------------------+
|               537061726B2053514C|
+---------------------------------+

SELECT to_varchar(encode('abc', 'utf-8'), 'utf-8');
+-------------------------------------+
|to_varchar(encode(abc, utf-8), utf-8)|
+-------------------------------------+
|                                  abc|
+-------------------------------------+

-- translate
SELECT translate('AaBbCc', 'abc', '123');
+---------------------------+
|translate(AaBbCc, abc, 123)|
+---------------------------+
|                     A1B2C3|
+---------------------------+

-- trim
SELECT trim('    SparkSQL   ');
+---------------------+
|trim(    SparkSQL   )|
+---------------------+
|             SparkSQL|
+---------------------+

SELECT trim(BOTH FROM '    SparkSQL   ');
+---------------------+
|trim(    SparkSQL   )|
+---------------------+
|             SparkSQL|
+---------------------+

SELECT trim(LEADING FROM '    SparkSQL   ');
+----------------------+
|ltrim(    SparkSQL   )|
+----------------------+
|           SparkSQL   |
+----------------------+

SELECT trim(TRAILING FROM '    SparkSQL   ');
+----------------------+
|rtrim(    SparkSQL   )|
+----------------------+
|              SparkSQL|
+----------------------+

SELECT trim('SL' FROM 'SSparkSQLS');
+-----------------------------+
|TRIM(BOTH SL FROM SSparkSQLS)|
+-----------------------------+
|                       parkSQ|
+-----------------------------+

SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');
+-----------------------------+
|TRIM(BOTH SL FROM SSparkSQLS)|
+-----------------------------+
|                       parkSQ|
+-----------------------------+

SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');
+--------------------------------+
|TRIM(LEADING SL FROM SSparkSQLS)|
+--------------------------------+
|                        parkSQLS|
+--------------------------------+

SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');
+---------------------------------+
|TRIM(TRAILING SL FROM SSparkSQLS)|
+---------------------------------+
|                         SSparkSQ|
+---------------------------------+

-- try_to_binary
SELECT try_to_binary('abc', 'utf-8');
+-------------------------+
|try_to_binary(abc, utf-8)|
+-------------------------+
|               [61 62 63]|
+-------------------------+

select try_to_binary('a!', 'base64');
+-------------------------+
|try_to_binary(a!, base64)|
+-------------------------+
|                     NULL|
+-------------------------+

select try_to_binary('abc', 'invalidFormat');
+---------------------------------+
|try_to_binary(abc, invalidFormat)|
+---------------------------------+
|                             NULL|
+---------------------------------+

-- try_to_number
SELECT try_to_number('454', '999');
+-----------------------+
|try_to_number(454, 999)|
+-----------------------+
|                    454|
+-----------------------+

SELECT try_to_number('454.00', '000.00');
+-----------------------------+
|try_to_number(454.00, 000.00)|
+-----------------------------+
|                       454.00|
+-----------------------------+

SELECT try_to_number('12,454', '99,999');
+-----------------------------+
|try_to_number(12,454, 99,999)|
+-----------------------------+
|                        12454|
+-----------------------------+

SELECT try_to_number('$78.12', '$99.99');
+-----------------------------+
|try_to_number($78.12, $99.99)|
+-----------------------------+
|                        78.12|
+-----------------------------+

SELECT try_to_number('12,454.8-', '99,999.9S');
+-----------------------------------+
|try_to_number(12,454.8-, 99,999.9S)|
+-----------------------------------+
|                           -12454.8|
+-----------------------------------+

-- try_validate_utf8
SELECT try_validate_utf8('Spark');
+------------------------+
|try_validate_utf8(Spark)|
+------------------------+
|                   Spark|
+------------------------+

SELECT try_validate_utf8(x'61');
+------------------------+
|try_validate_utf8(X'61')|
+------------------------+
|                       a|
+------------------------+

SELECT try_validate_utf8(x'80');
+------------------------+
|try_validate_utf8(X'80')|
+------------------------+
|                    NULL|
+------------------------+

SELECT try_validate_utf8(x'61C262');
+----------------------------+
|try_validate_utf8(X'61C262')|
+----------------------------+
|                        NULL|
+----------------------------+

-- ucase
SELECT ucase('SparkSql');
+---------------+
|ucase(SparkSql)|
+---------------+
|       SPARKSQL|
+---------------+

-- unbase64
SELECT unbase64('U3BhcmsgU1FM');
+----------------------+
|unbase64(U3BhcmsgU1FM)|
+----------------------+
|  [53 70 61 72 6B 2...|
+----------------------+

-- upper
SELECT upper('SparkSql');
+---------------+
|upper(SparkSql)|
+---------------+
|       SPARKSQL|
+---------------+

-- validate_utf8
SELECT validate_utf8('Spark');
+--------------------+
|validate_utf8(Spark)|
+--------------------+
|               Spark|
+--------------------+

SELECT validate_utf8(x'61');
+--------------------+
|validate_utf8(X'61')|
+--------------------+
|                   a|
+--------------------+

条件関数

関数	説明
input [NOT] between lower AND upper	`input` が `lower` と `upper` の間に（含まない）あるかどうかを評価します。
coalesce(expr1, expr2, ...)	最初の null でない引数を返します。存在しない場合は null を返します。
if(expr1, expr2, expr3)	`expr1` が true と評価される場合は `expr2` を返します。それ以外の場合は `expr3` を返します。
ifnull(expr1, expr2)	`expr1` が null の場合は `expr2` を返します。それ以外の場合は `expr1` を返します。
nanvl(expr1, expr2)	`expr1` が NaN でない場合は `expr1` を返します。それ以外の場合は `expr2` を返します。
nullif(expr1, expr2)	`expr1` が `expr2` と等しい場合は null を返します。それ以外の場合は `expr1` を返します。
nullifzero(expr)	`expr` がゼロに等しい場合は null を返します。それ以外の場合は `expr` を返します。
nvl(expr1, expr2)	`expr1` が null の場合は `expr2` を返します。それ以外の場合は `expr1` を返します。
nvl2(expr1, expr2, expr3)	`expr1` が null でない場合は `expr2` を返します。それ以外の場合は `expr3` を返します。
CASE WHEN expr1 THEN expr2 [WHEN expr3 THEN expr4]* [ELSE expr5] END	`expr1` = true の場合は `expr2` を返します。それ以外の場合、`expr3` = true の場合は `expr4` を返します。それ以外の場合は `expr5` を返します。
zeroifnull(expr)	`expr` が null の場合はゼロを返します。それ以外の場合は `expr` を返します。

例

-- between
SELECT 0.5 between 0.1 AND 1.0;
+----------------------+
|between(0.5, 0.1, 1.0)|
+----------------------+
|                  true|
+----------------------+

-- coalesce
SELECT coalesce(NULL, 1, NULL);
+-----------------------+
|coalesce(NULL, 1, NULL)|
+-----------------------+
|                      1|
+-----------------------+

-- if
SELECT if(1 < 2, 'a', 'b');
+-------------------+
|(IF((1 < 2), a, b))|
+-------------------+
|                  a|
+-------------------+

-- ifnull
SELECT ifnull(NULL, array('2'));
+----------------------+
|ifnull(NULL, array(2))|
+----------------------+
|                   [2]|
+----------------------+

-- nanvl
SELECT nanvl(cast('NaN' as double), 123);
+-------------------------------+
|nanvl(CAST(NaN AS DOUBLE), 123)|
+-------------------------------+
|                          123.0|
+-------------------------------+

-- nullif
SELECT nullif(2, 2);
+------------+
|nullif(2, 2)|
+------------+
|        NULL|
+------------+

-- nullifzero
SELECT nullifzero(0);
+-------------+
|nullifzero(0)|
+-------------+
|         NULL|
+-------------+

SELECT nullifzero(2);
+-------------+
|nullifzero(2)|
+-------------+
|            2|
+-------------+

-- nvl
SELECT nvl(NULL, array('2'));
+-------------------+
|nvl(NULL, array(2))|
+-------------------+
|                [2]|
+-------------------+

-- nvl2
SELECT nvl2(NULL, 2, 1);
+----------------+
|nvl2(NULL, 2, 1)|
+----------------+
|               1|
+----------------+

-- when
SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
+-----------------------------------------------------------+
|CASE WHEN (1 > 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END|
+-----------------------------------------------------------+
|                                                        1.0|
+-----------------------------------------------------------+

SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
+-----------------------------------------------------------+
|CASE WHEN (1 < 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END|
+-----------------------------------------------------------+
|                                                        2.0|
+-----------------------------------------------------------+

SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END;
+--------------------------------------------------+
|CASE WHEN (1 < 0) THEN 1 WHEN (2 < 0) THEN 2.0 END|
+--------------------------------------------------+
|                                              NULL|
+--------------------------------------------------+

-- zeroifnull
SELECT zeroifnull(NULL);
+----------------+
|zeroifnull(NULL)|
+----------------+
|               0|
+----------------+

SELECT zeroifnull(2);
+-------------+
|zeroifnull(2)|
+-------------+
|            2|
+-------------+

ハッシュ関数

関数	説明
crc32(expr)	`expr` の巡回冗長検査値を bigint として返します。
hash(expr1, expr2, ...)	引数のハッシュ値を返します。
md5(expr)	`expr` の MD5 128 ビットチェックサムを 16 進数文字列として返します。
sha(expr)	`expr` の sha1 ハッシュ値を 16 進数文字列として返します。
sha1(expr)	`expr` の sha1 ハッシュ値を 16 進数文字列として返します。
sha2(expr, bitLength)	`expr` の SHA-2 ファミリのチェックサムを 16 進数文字列として返します。SHA-224、SHA-256、SHA-384、SHA-512 がサポートされています。ビット長 0 は 256 と同等です。
xxhash64(expr1, expr2, ...)	引数の 64 ビットハッシュ値を返します。ハッシュシードは 42 です。

例

-- crc32
SELECT crc32('Spark');
+------------+
|crc32(Spark)|
+------------+
|  1557323817|
+------------+

-- hash
SELECT hash('Spark', array(123), 2);
+--------------------------+
|hash(Spark, array(123), 2)|
+--------------------------+
|               -1321691492|
+--------------------------+

-- md5
SELECT md5('Spark');
+--------------------+
|          md5(Spark)|
+--------------------+
|8cde774d6f7333752...|
+--------------------+

-- sha
SELECT sha('Spark');
+--------------------+
|          sha(Spark)|
+--------------------+
|85f5955f4b27a9a4c...|
+--------------------+

-- sha1
SELECT sha1('Spark');
+--------------------+
|         sha1(Spark)|
+--------------------+
|85f5955f4b27a9a4c...|
+--------------------+

-- sha2
SELECT sha2('Spark', 256);
+--------------------+
|    sha2(Spark, 256)|
+--------------------+
|529bc3b07127ecb7e...|
+--------------------+

-- xxhash64
SELECT xxhash64('Spark', array(123), 2);
+------------------------------+
|xxhash64(Spark, array(123), 2)|
+------------------------------+
|           5602566077635097486|
+------------------------------+

CSV 関数

関数	説明
from_csv(csvStr, schema[, options])	指定された `csvStr` と `schema` を持つ構造体値を返します。
schema_of_csv(csv[, options])	CSV 文字列の DDL 形式のスキーマを返します。
to_csv(expr[, options])	指定された構造体値を持つ CSV 文字列を返します。

例

-- from_csv
SELECT from_csv('1, 0.8', 'a INT, b DOUBLE');
+----------------+
|from_csv(1, 0.8)|
+----------------+
|        {1, 0.8}|
+----------------+

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

-- schema_of_csv
SELECT schema_of_csv('1,abc');
+--------------------+
|schema_of_csv(1,abc)|
+--------------------+
|STRUCT<_c0: INT, ...|
+--------------------+

-- to_csv
SELECT to_csv(named_struct('a', 1, 'b', 2));
+--------------------------------+
|to_csv(named_struct(a, 1, b, 2))|
+--------------------------------+
|                             1,2|
+--------------------------------+

SELECT to_csv(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
+----------------------------------------------------------------+
|to_csv(named_struct(time, to_timestamp(2015-08-26, yyyy-MM-dd)))|
+----------------------------------------------------------------+
|                                                      26/08/2015|
+----------------------------------------------------------------+

JSON 関数

関数	説明
from_json(jsonStr, schema[, options])	指定された `jsonStr` と `schema` を持つ構造体値を返します。
get_json_object(json_txt, path)	`path` から JSON オブジェクトを抽出します。
json_array_length(jsonArray)	最も外側の JSON 配列の要素数を返します。
json_object_keys(json_object)	最も外側の JSON オブジェクトのすべてのキーを配列として返します。
json_tuple(jsonStr, p1, p2, ..., pn)	get_json_object 関数と同様のタプルを返しますが、複数の名前を受け取ります。すべての入力パラメータと出力列の型は文字列です。
schema_of_json(json[, options])	JSON 文字列の DDL 形式のスキーマを返します。
to_json(expr[, options])	指定された構造体値を持つ JSON 文字列を返します。

例

-- 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...|
+--------------------------------+

SELECT from_json('{"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}', 'STRUCT<teacher: STRING, student: ARRAY<STRUCT<name: STRING, rank: INT>>>');
+--------------------------------------------------------------------------------------------------------+
|from_json({"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]})|
+--------------------------------------------------------------------------------------------------------+
|                                                                                    {Alice, [{Bob, 1}...|
+--------------------------------------------------------------------------------------------------------+

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

-- json_array_length
SELECT json_array_length('[1,2,3,4]');
+----------------------------+
|json_array_length([1,2,3,4])|
+----------------------------+
|                           4|
+----------------------------+

SELECT json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]');
+------------------------------------------------+
|json_array_length([1,2,3,{"f1":1,"f2":[5,6]},4])|
+------------------------------------------------+
|                                               5|
+------------------------------------------------+

SELECT json_array_length('[1,2');
+-----------------------+
|json_array_length([1,2)|
+-----------------------+
|                   NULL|
+-----------------------+

-- json_object_keys
SELECT json_object_keys('{}');
+--------------------+
|json_object_keys({})|
+--------------------+
|                  []|
+--------------------+

SELECT json_object_keys('{"key": "value"}');
+----------------------------------+
|json_object_keys({"key": "value"})|
+----------------------------------+
|                             [key]|
+----------------------------------+

SELECT json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}');
+--------------------------------------------------------+
|json_object_keys({"f1":"abc","f2":{"f3":"a", "f4":"b"}})|
+--------------------------------------------------------+
|                                                [f1, f2]|
+--------------------------------------------------------+

-- 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}]|
+-------------------------+

XML 関数

関数	説明
from_xml(xmlStr, schema[, options])	指定された `xmlStr` と `schema` を持つ構造体値を返します。
schema_of_xml(xml[, options])	XML 文字列の DDL 形式のスキーマを返します。
to_xml(expr[, options])	指定された構造体値を持つ XML 文字列を返します。
xpath(xml, xpath)	XPath 式に一致する XML 内の値の文字列配列を返します。
xpath_boolean(xml, xpath)	XPath 式が true と評価される場合、または一致するノードが見つかった場合は true を返します。
xpath_double(xml, xpath)	double 値を返します。一致が見つからない場合はゼロ、一致が見つかったが値が数値でない場合は NaN を返します。
xpath_float(xml, xpath)	float 値を返します。一致が見つからない場合はゼロ、一致が見つかったが値が数値でない場合は NaN を返します。
xpath_int(xml, xpath)	整数値を返します。一致が見つからない場合はゼロ、一致が見つかったが値が数値でない場合はゼロを返します。
xpath_long(xml, xpath)	long 整数値を返します。一致が見つからない場合はゼロ、一致が見つかったが値が数値でない場合はゼロを返します。
xpath_number(xml, xpath)	double 値を返します。一致が見つからない場合はゼロ、一致が見つかったが値が数値でない場合は NaN を返します。
xpath_short(xml, xpath)	short 整数値を返します。一致が見つからない場合はゼロ、一致が見つかったが値が数値でない場合はゼロを返します。
xpath_string(xml, xpath)	XPath 式に一致する最初の XML ノードのテキストコンテンツを返します。

例

-- from_xml
SELECT from_xml('<p><a>1</a><b>0.8</b></p>', 'a INT, b DOUBLE');
+-----------------------------------+
|from_xml(<p><a>1</a><b>0.8</b></p>)|
+-----------------------------------+
|                           {1, 0.8}|
+-----------------------------------+

SELECT from_xml('<p><time>26/08/2015</time></p>', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
+----------------------------------------+
|from_xml(<p><time>26/08/2015</time></p>)|
+----------------------------------------+
|                    {2015-08-26 00:00...|
+----------------------------------------+

SELECT from_xml('<p><teacher>Alice</teacher><student><name>Bob</name><rank>1</rank></student><student><name>Charlie</name><rank>2</rank></student></p>', 'STRUCT<teacher: STRING, student: ARRAY<STRUCT<name: STRING, rank: INT>>>');
+-----------------------------------------------------------------------------------------------------------------------------------------------+
|from_xml(<p><teacher>Alice</teacher><student><name>Bob</name><rank>1</rank></student><student><name>Charlie</name><rank>2</rank></student></p>)|
+-----------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                           {Alice, [{Bob, 1}...|
+-----------------------------------------------------------------------------------------------------------------------------------------------+

-- schema_of_xml
SELECT schema_of_xml('<p><a>1</a></p>');
+------------------------------+
|schema_of_xml(<p><a>1</a></p>)|
+------------------------------+
|             STRUCT<a: BIGINT>|
+------------------------------+

SELECT schema_of_xml('<p><a attr="2">1</a><a>3</a></p>', map('excludeAttribute', 'true'));
+-----------------------------------------------+
|schema_of_xml(<p><a attr="2">1</a><a>3</a></p>)|
+-----------------------------------------------+
|                           STRUCT<a: ARRAY<B...|
+-----------------------------------------------+

-- to_xml
SELECT to_xml(named_struct('a', 1, 'b', 2));
+--------------------------------+
|to_xml(named_struct(a, 1, b, 2))|
+--------------------------------+
|            <ROW>\n    <a>1</...|
+--------------------------------+

SELECT to_xml(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
+----------------------------------------------------------------+
|to_xml(named_struct(time, to_timestamp(2015-08-26, yyyy-MM-dd)))|
+----------------------------------------------------------------+
|                                            <ROW>\n    <time>...|
+----------------------------------------------------------------+

-- xpath
SELECT xpath('<a><b>b1</b><b>b2</b><b>b3</b><c>c1</c><c>c2</c></a>','a/b/text()');
+-----------------------------------------------------------------------+
|xpath(<a><b>b1</b><b>b2</b><b>b3</b><c>c1</c><c>c2</c></a>, a/b/text())|
+-----------------------------------------------------------------------+
|                                                           [b1, b2, b3]|
+-----------------------------------------------------------------------+

SELECT xpath('<a><b>b1</b><b>b2</b><b>b3</b><c>c1</c><c>c2</c></a>','a/b');
+----------------------------------------------------------------+
|xpath(<a><b>b1</b><b>b2</b><b>b3</b><c>c1</c><c>c2</c></a>, a/b)|
+----------------------------------------------------------------+
|                                              [NULL, NULL, NULL]|
+----------------------------------------------------------------+

-- xpath_boolean
SELECT xpath_boolean('<a><b>1</b></a>','a/b');
+-----------------------------------+
|xpath_boolean(<a><b>1</b></a>, a/b)|
+-----------------------------------+
|                               true|
+-----------------------------------+

-- xpath_double
SELECT xpath_double('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
+-----------------------------------------------+
|xpath_double(<a><b>1</b><b>2</b></a>, sum(a/b))|
+-----------------------------------------------+
|                                            3.0|
+-----------------------------------------------+

-- xpath_float
SELECT xpath_float('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
+----------------------------------------------+
|xpath_float(<a><b>1</b><b>2</b></a>, sum(a/b))|
+----------------------------------------------+
|                                           3.0|
+----------------------------------------------+

-- xpath_int
SELECT xpath_int('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
+--------------------------------------------+
|xpath_int(<a><b>1</b><b>2</b></a>, sum(a/b))|
+--------------------------------------------+
|                                           3|
+--------------------------------------------+

-- xpath_long
SELECT xpath_long('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
+---------------------------------------------+
|xpath_long(<a><b>1</b><b>2</b></a>, sum(a/b))|
+---------------------------------------------+
|                                            3|
+---------------------------------------------+

-- xpath_number
SELECT xpath_number('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
+-----------------------------------------------+
|xpath_number(<a><b>1</b><b>2</b></a>, sum(a/b))|
+-----------------------------------------------+
|                                            3.0|
+-----------------------------------------------+

-- xpath_short
SELECT xpath_short('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
+----------------------------------------------+
|xpath_short(<a><b>1</b><b>2</b></a>, sum(a/b))|
+----------------------------------------------+
|                                             3|
+----------------------------------------------+

-- xpath_string
SELECT xpath_string('<a><b>b</b><c>cc</c></a>','a/c');
+-------------------------------------------+
|xpath_string(<a><b>b</b><c>cc</c></a>, a/c)|
+-------------------------------------------+
|                                         cc|
+-------------------------------------------+

URL 関数

関数	説明
parse_url(url, partToExtract[, key])	URL から一部を抽出します。
try_parse_url(url, partToExtract[, key])	`parse_url` の特殊バージョンで、同じ操作を実行しますが、解析が実行できない場合にエラーをスローする代わりに NULL 値を返します。
try_url_decode(str)	`url_decode` の特殊バージョンで、同じ操作を実行しますが、デコードが実行できない場合にエラーをスローする代わりに NULL 値を返します。
url_decode(str)	指定されたエンコーディングスキームを使用して、'application/x-www-form-urlencoded' フォーマットの `str` をデコードします。
url_encode(str)	指定されたエンコーディングスキームを使用して、'application/x-www-form-urlencoded' フォーマットの文字列に変換します。

例

-- parse_url
SELECT parse_url('https://spark.dokyumento.jp/path?query=1', 'HOST');
+-----------------------------------------------------+
|parse_url(http://spark.apache.org/path?query=1, HOST)|
+-----------------------------------------------------+
|                                     spark.apache.org|
+-----------------------------------------------------+

SELECT parse_url('https://spark.dokyumento.jp/path?query=1', 'QUERY');
+------------------------------------------------------+
|parse_url(http://spark.apache.org/path?query=1, QUERY)|
+------------------------------------------------------+
|                                               query=1|
+------------------------------------------------------+

SELECT parse_url('https://spark.dokyumento.jp/path?query=1', 'QUERY', 'query');
+-------------------------------------------------------------+
|parse_url(http://spark.apache.org/path?query=1, QUERY, query)|
+-------------------------------------------------------------+
|                                                            1|
+-------------------------------------------------------------+

-- try_parse_url
SELECT try_parse_url('https://spark.dokyumento.jp/path?query=1', 'HOST');
+---------------------------------------------------------+
|try_parse_url(http://spark.apache.org/path?query=1, HOST)|
+---------------------------------------------------------+
|                                         spark.apache.org|
+---------------------------------------------------------+

SELECT try_parse_url('https://spark.dokyumento.jp/path?query=1', 'QUERY');
+----------------------------------------------------------+
|try_parse_url(http://spark.apache.org/path?query=1, QUERY)|
+----------------------------------------------------------+
|                                                   query=1|
+----------------------------------------------------------+

SELECT try_parse_url('inva lid://spark.dokyumento.jp/path?query=1', 'QUERY');
+--------------------------------------------------------------+
|try_parse_url(inva lid://spark.apache.org/path?query=1, QUERY)|
+--------------------------------------------------------------+
|                                                          NULL|
+--------------------------------------------------------------+

SELECT try_parse_url('https://spark.dokyumento.jp/path?query=1', 'QUERY', 'query');
+-----------------------------------------------------------------+
|try_parse_url(http://spark.apache.org/path?query=1, QUERY, query)|
+-----------------------------------------------------------------+
|                                                                1|
+-----------------------------------------------------------------+

-- try_url_decode
SELECT try_url_decode('https%3A%2F%2Fspark.apache.org');
+----------------------------------------------+
|try_url_decode(https%3A%2F%2Fspark.apache.org)|
+----------------------------------------------+
|                          https://spark.apa...|
+----------------------------------------------+

-- url_decode
SELECT url_decode('https%3A%2F%2Fspark.apache.org');
+------------------------------------------+
|url_decode(https%3A%2F%2Fspark.apache.org)|
+------------------------------------------+
|                      https://spark.apa...|
+------------------------------------------+

-- url_encode
SELECT url_encode('https://spark.dokyumento.jp');
+------------------------------------+
|url_encode(https://spark.apache.org)|
+------------------------------------+
|                https%3A%2F%2Fspa...|
+------------------------------------+

ビット演算関数

関数	説明
expr1 & expr2	`expr1` と `expr2` のビットごとの AND の結果を返します。
base << exp	ビットごとの左シフト。
base >> expr	ビットごとの（符号付き）右シフト。
base >>> expr	ビットごとの符号なし右シフト。
expr1 ^ expr2	`expr1` と `expr2` のビットごとの排他的 OR の結果を返します。
bit_count(expr)	引数 expr のセットされているビットの数を符号なし 64 ビット整数として返します。引数が null の場合は NULL を返します。
bit_get(expr, pos)	指定された位置のビット（0 または 1）の値を返します。位置は右から左へ、ゼロから数えられます。位置引数は負にできません。
getbit(expr, pos)	指定された位置のビット（0 または 1）の値を返します。位置は右から左へ、ゼロから数えられます。位置引数は負にできません。
base shiftleft exp	ビットごとの左シフト。
base shiftright expr	ビットごとの（符号付き）右シフト。
base shiftrightunsigned expr	ビットごとの符号なし右シフト。
expr1 \| expr2	`expr1` と `expr2` のビットごとの OR の結果を返します。
~ expr	`expr` のビットごとの NOT の結果を返します。

例

-- &
SELECT 3 & 5;
+-------+
|(3 & 5)|
+-------+
|      1|
+-------+

-- <<
SELECT shiftleft(2, 1);
+---------------+
|shiftleft(2, 1)|
+---------------+
|              4|
+---------------+

SELECT 2 << 1;
+--------+
|(2 << 1)|
+--------+
|       4|
+--------+

-- >>
SELECT shiftright(4, 1);
+----------------+
|shiftright(4, 1)|
+----------------+
|               2|
+----------------+

SELECT 4 >> 1;
+--------+
|(4 >> 1)|
+--------+
|       2|
+--------+

-- >>>
SELECT shiftrightunsigned(4, 1);
+------------------------+
|shiftrightunsigned(4, 1)|
+------------------------+
|                       2|
+------------------------+

SELECT 4 >>> 1;
+---------+
|(4 >>> 1)|
+---------+
|        2|
+---------+

-- ^
SELECT 3 ^ 5;
+-------+
|(3 ^ 5)|
+-------+
|      6|
+-------+

-- bit_count
SELECT bit_count(0);
+------------+
|bit_count(0)|
+------------+
|           0|
+------------+

-- bit_get
SELECT bit_get(11, 0);
+--------------+
|bit_get(11, 0)|
+--------------+
|             1|
+--------------+

SELECT bit_get(11, 2);
+--------------+
|bit_get(11, 2)|
+--------------+
|             0|
+--------------+

-- getbit
SELECT getbit(11, 0);
+-------------+
|getbit(11, 0)|
+-------------+
|            1|
+-------------+

SELECT getbit(11, 2);
+-------------+
|getbit(11, 2)|
+-------------+
|            0|
+-------------+

-- shiftleft
SELECT shiftleft(2, 1);
+---------------+
|shiftleft(2, 1)|
+---------------+
|              4|
+---------------+

SELECT 2 << 1;
+--------+
|(2 << 1)|
+--------+
|       4|
+--------+

-- shiftright
SELECT shiftright(4, 1);
+----------------+
|shiftright(4, 1)|
+----------------+
|               2|
+----------------+

SELECT 4 >> 1;
+--------+
|(4 >> 1)|
+--------+
|       2|
+--------+

-- shiftrightunsigned
SELECT shiftrightunsigned(4, 1);
+------------------------+
|shiftrightunsigned(4, 1)|
+------------------------+
|                       2|
+------------------------+

SELECT 4 >>> 1;
+---------+
|(4 >>> 1)|
+---------+
|        2|
+---------+

-- |
SELECT 3 | 5;
+-------+
|(3 | 5)|
+-------+
|      7|
+-------+

-- ~
SELECT ~ 0;
+---+
| ~0|
+---+
| -1|
+---+

変換関数

関数	説明
bigint(expr)	値 `expr` をターゲットデータ型 `bigint` にキャストします。
binary(expr)	値 `expr` をターゲットデータ型 `binary` にキャストします。
boolean(expr)	値 `expr` をターゲットデータ型 `boolean` にキャストします。
cast(expr AS type)	値 `expr` をターゲットデータ型 `type` にキャストします。`expr` :: `type` の代替キャスト構文もサポートされています。
date(expr)	値 `expr` をターゲットデータ型 `date` にキャストします。
decimal(expr)	値 `expr` をターゲットデータ型 `decimal` にキャストします。
double(expr)	値 `expr` をターゲットデータ型 `double` にキャストします。
float(expr)	値 `expr` をターゲットデータ型 `float` にキャストします。
int(expr)	値 `expr` をターゲットデータ型 `int` にキャストします。
smallint(expr)	値 `expr` をターゲットデータ型 `smallint` にキャストします。
string(expr)	値 `expr` をターゲットデータ型 `string` にキャストします。
timestamp(expr)	値 `expr` をターゲットデータ型 `timestamp` にキャストします。
tinyint(expr)	値 `expr` をターゲットデータ型 `tinyint` にキャストします。

例

-- cast
SELECT cast('10' as int);
+---------------+
|CAST(10 AS INT)|
+---------------+
|             10|
+---------------+

SELECT '10' :: int;
+---------------+
|CAST(10 AS INT)|
+---------------+
|             10|
+---------------+

述語関数

関数	説明
! expr	論理 NOT。
expr1 < expr2	`expr1` が `expr2` より小さい場合は true を返します。
expr1 <= expr2	`expr1` が `expr2` 以下である場合は true を返します。
expr1 <=> expr2	null でないオペランドの場合、EQUAL(=) 演算子と同じ結果を返しますが、両方が null の場合は true、一方のみが null の場合は false を返します。
expr1 = expr2	`expr1` が `expr2` と等しい場合は true を返します。それ以外の場合は false を返します。
expr1 == expr2	`expr1` が `expr2` と等しい場合は true を返します。それ以外の場合は false を返します。
expr1 > expr2	`expr1` が `expr2` より大きい場合は true を返します。
expr1 >= expr2	`expr1` が `expr2` 以上である場合は true を返します。
expr1 and expr2	論理 AND。
equal_null(expr1, expr2)	null でないオペランドの場合、EQUAL(=) 演算子と同じ結果を返しますが、両方が null の場合は true、一方のみが null の場合は false を返します。
str ilike pattern[ ESCAPE escape]	str が `pattern` に `escape` を使用して大文字小文字を区別せずに一致する場合 true を返します。いずれかの引数が null の場合は null、それ以外の場合は false を返します。
expr1 in(expr2, expr3, ...)	`expr` がいずれかの valN と等しい場合は true を返します。
isnan(expr)	`expr` が NaN である場合は true を返します。それ以外の場合は false を返します。
isnotnull(expr)	`expr` が null でない場合は true を返します。それ以外の場合は false を返します。
isnull(expr)	`expr` が null である場合は true を返します。それ以外の場合は false を返します。
str like pattern[ ESCAPE escape]	str が `pattern` に `escape` を使用して一致する場合 true を返します。いずれかの引数が null の場合は null、それ以外の場合は false を返します。
not expr	論理 NOT。
expr1 or expr2	論理 OR。
regexp(str, regexp)	`str` が `regexp` に一致する場合は true を返します。それ以外の場合は false を返します。
regexp_like(str, regexp)	`str` が `regexp` に一致する場合は true を返します。それ以外の場合は false を返します。
rlike(str, regexp)	`str` が `regexp` に一致する場合は true を返します。それ以外の場合は false を返します。

例

-- !
SELECT ! true;
+----------+
|(NOT true)|
+----------+
|     false|
+----------+

SELECT ! false;
+-----------+
|(NOT false)|
+-----------+
|       true|
+-----------+

SELECT ! NULL;
+----------+
|(NOT NULL)|
+----------+
|      NULL|
+----------+

-- <
SELECT 1 < 2;
+-------+
|(1 < 2)|
+-------+
|   true|
+-------+

SELECT 1.1 < '1';
+---------+
|(1.1 < 1)|
+---------+
|    false|
+---------+

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

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

SELECT 1 < NULL;
+----------+
|(1 < NULL)|
+----------+
|      NULL|
+----------+

-- <=
SELECT 2 <= 2;
+--------+
|(2 <= 2)|
+--------+
|    true|
+--------+

SELECT 1.0 <= '1';
+----------+
|(1.0 <= 1)|
+----------+
|      true|
+----------+

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

SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-08-01 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) <= to_date(2009-08-01 04:17:52))|
+--------------------------------------------------------------+
|                                                          true|
+--------------------------------------------------------------+

SELECT 1 <= NULL;
+-----------+
|(1 <= NULL)|
+-----------+
|       NULL|
+-----------+

-- <=>
SELECT 2 <=> 2;
+---------+
|(2 <=> 2)|
+---------+
|     true|
+---------+

SELECT 1 <=> '1';
+---------+
|(1 <=> 1)|
+---------+
|     true|
+---------+

SELECT true <=> NULL;
+---------------+
|(true <=> NULL)|
+---------------+
|          false|
+---------------+

SELECT NULL <=> NULL;
+---------------+
|(NULL <=> NULL)|
+---------------+
|           true|
+---------------+

-- =
SELECT 2 = 2;
+-------+
|(2 = 2)|
+-------+
|   true|
+-------+

SELECT 1 = '1';
+-------+
|(1 = 1)|
+-------+
|   true|
+-------+

SELECT true = NULL;
+-------------+
|(true = NULL)|
+-------------+
|         NULL|
+-------------+

SELECT NULL = NULL;
+-------------+
|(NULL = NULL)|
+-------------+
|         NULL|
+-------------+

-- ==
SELECT 2 == 2;
+-------+
|(2 = 2)|
+-------+
|   true|
+-------+

SELECT 1 == '1';
+-------+
|(1 = 1)|
+-------+
|   true|
+-------+

SELECT true == NULL;
+-------------+
|(true = NULL)|
+-------------+
|         NULL|
+-------------+

SELECT NULL == NULL;
+-------------+
|(NULL = NULL)|
+-------------+
|         NULL|
+-------------+

-- >
SELECT 2 > 1;
+-------+
|(2 > 1)|
+-------+
|   true|
+-------+

SELECT 2 > 1.1;
+-------+
|(2 > 1)|
+-------+
|   true|
+-------+

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

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

SELECT 1 > NULL;
+----------+
|(1 > NULL)|
+----------+
|      NULL|
+----------+

-- >=
SELECT 2 >= 1;
+--------+
|(2 >= 1)|
+--------+
|    true|
+--------+

SELECT 2.0 >= '2.1';
+------------+
|(2.0 >= 2.1)|
+------------+
|       false|
+------------+

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

SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-08-01 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) >= to_date(2009-08-01 04:17:52))|
+--------------------------------------------------------------+
|                                                         false|
+--------------------------------------------------------------+

SELECT 1 >= NULL;
+-----------+
|(1 >= NULL)|
+-----------+
|       NULL|
+-----------+

-- and
SELECT true and true;
+---------------+
|(true AND true)|
+---------------+
|           true|
+---------------+

SELECT true and false;
+----------------+
|(true AND false)|
+----------------+
|           false|
+----------------+

SELECT true and NULL;
+---------------+
|(true AND NULL)|
+---------------+
|           NULL|
+---------------+

SELECT false and NULL;
+----------------+
|(false AND NULL)|
+----------------+
|           false|
+----------------+

-- equal_null
SELECT equal_null(3, 3);
+----------------+
|equal_null(3, 3)|
+----------------+
|            true|
+----------------+

SELECT equal_null(1, '11');
+-----------------+
|equal_null(1, 11)|
+-----------------+
|            false|
+-----------------+

SELECT equal_null(true, NULL);
+----------------------+
|equal_null(true, NULL)|
+----------------------+
|                 false|
+----------------------+

SELECT equal_null(NULL, 'abc');
+---------------------+
|equal_null(NULL, abc)|
+---------------------+
|                false|
+---------------------+

SELECT equal_null(NULL, NULL);
+----------------------+
|equal_null(NULL, NULL)|
+----------------------+
|                  true|
+----------------------+

-- ilike
SELECT ilike('Spark', '_Park');
+-------------------+
|ilike(Spark, _Park)|
+-------------------+
|               true|
+-------------------+

SELECT '\\abc' AS S, S ilike r'\\abc', S ilike '\\\\abc';
+----+--------------------------------------+--------------------------------------+
|   S|ilike(lateralAliasReference(S), \\abc)|ilike(lateralAliasReference(S), \\abc)|
+----+--------------------------------------+--------------------------------------+
|\abc|                                  true|                                  true|
+----+--------------------------------------+--------------------------------------+

SET spark.sql.parser.escapedStringLiterals=true;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....| true|
+--------------------+-----+

SELECT '%SystemDrive%\Users\John' ilike '\%SystemDrive\%\\users%';
+--------------------------------------------------------+
|ilike(%SystemDrive%\Users\John, \%SystemDrive\%\\users%)|
+--------------------------------------------------------+
|                                                    true|
+--------------------------------------------------------+

SET spark.sql.parser.escapedStringLiterals=false;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....|false|
+--------------------+-----+

SELECT '%SystemDrive%\\USERS\\John' ilike r'%SystemDrive%\\Users%';
+------------------------------------------------------+
|ilike(%SystemDrive%\USERS\John, %SystemDrive%\\Users%)|
+------------------------------------------------------+
|                                                  true|
+------------------------------------------------------+

SELECT '%SystemDrive%/Users/John' ilike '/%SYSTEMDrive/%//Users%' ESCAPE '/';
+--------------------------------------------------------+
|ilike(%SystemDrive%/Users/John, /%SYSTEMDrive/%//Users%)|
+--------------------------------------------------------+
|                                                    true|
+--------------------------------------------------------+

-- in
SELECT 1 in(1, 2, 3);
+----------------+
|(1 IN (1, 2, 3))|
+----------------+
|            true|
+----------------+

SELECT 1 in(2, 3, 4);
+----------------+
|(1 IN (2, 3, 4))|
+----------------+
|           false|
+----------------+

SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 1), named_struct('a', 1, 'b', 3));
+----------------------------------------------------------------------------------+
|(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 1), named_struct(a, 1, b, 3)))|
+----------------------------------------------------------------------------------+
|                                                                             false|
+----------------------------------------------------------------------------------+

SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 3));
+----------------------------------------------------------------------------------+
|(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 2), named_struct(a, 1, b, 3)))|
+----------------------------------------------------------------------------------+
|                                                                              true|
+----------------------------------------------------------------------------------+

-- isnan
SELECT isnan(cast('NaN' as double));
+--------------------------+
|isnan(CAST(NaN AS DOUBLE))|
+--------------------------+
|                      true|
+--------------------------+

-- isnotnull
SELECT isnotnull(1);
+---------------+
|(1 IS NOT NULL)|
+---------------+
|           true|
+---------------+

-- isnull
SELECT isnull(1);
+-----------+
|(1 IS NULL)|
+-----------+
|      false|
+-----------+

-- like
SELECT like('Spark', '_park');
+----------------+
|Spark LIKE _park|
+----------------+
|            true|
+----------------+

SELECT '\\abc' AS S, S like r'\\abc', S like '\\\\abc';
+----+-----------------------------------+-----------------------------------+
|   S|lateralAliasReference(S) LIKE \\abc|lateralAliasReference(S) LIKE \\abc|
+----+-----------------------------------+-----------------------------------+
|\abc|                               true|                               true|
+----+-----------------------------------+-----------------------------------+

SET spark.sql.parser.escapedStringLiterals=true;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....| true|
+--------------------+-----+

SELECT '%SystemDrive%\Users\John' like '\%SystemDrive\%\\Users%';
+-----------------------------------------------------+
|%SystemDrive%\Users\John LIKE \%SystemDrive\%\\Users%|
+-----------------------------------------------------+
|                                                 true|
+-----------------------------------------------------+

SET spark.sql.parser.escapedStringLiterals=false;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....|false|
+--------------------+-----+

SELECT '%SystemDrive%\\Users\\John' like r'%SystemDrive%\\Users%';
+---------------------------------------------------+
|%SystemDrive%\Users\John LIKE %SystemDrive%\\Users%|
+---------------------------------------------------+
|                                               true|
+---------------------------------------------------+

SELECT '%SystemDrive%/Users/John' like '/%SystemDrive/%//Users%' ESCAPE '/';
+----------------------------------------------------------------+
|%SystemDrive%/Users/John LIKE /%SystemDrive/%//Users% ESCAPE '/'|
+----------------------------------------------------------------+
|                                                            true|
+----------------------------------------------------------------+

-- not
SELECT not true;
+----------+
|(NOT true)|
+----------+
|     false|
+----------+

SELECT not false;
+-----------+
|(NOT false)|
+-----------+
|       true|
+-----------+

SELECT not NULL;
+----------+
|(NOT NULL)|
+----------+
|      NULL|
+----------+

-- or
SELECT true or false;
+---------------+
|(true OR false)|
+---------------+
|           true|
+---------------+

SELECT false or false;
+----------------+
|(false OR false)|
+----------------+
|           false|
+----------------+

SELECT true or NULL;
+--------------+
|(true OR NULL)|
+--------------+
|          true|
+--------------+

SELECT false or NULL;
+---------------+
|(false OR NULL)|
+---------------+
|           NULL|
+---------------+

-- regexp
SET spark.sql.parser.escapedStringLiterals=true;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....| true|
+--------------------+-----+

SELECT regexp('%SystemDrive%\Users\John', '%SystemDrive%\\Users.*');
+--------------------------------------------------------+
|REGEXP(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+--------------------------------------------------------+
|                                                    true|
+--------------------------------------------------------+

SET spark.sql.parser.escapedStringLiterals=false;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....|false|
+--------------------+-----+

SELECT regexp('%SystemDrive%\\Users\\John', '%SystemDrive%\\\\Users.*');
+--------------------------------------------------------+
|REGEXP(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+--------------------------------------------------------+
|                                                    true|
+--------------------------------------------------------+

SELECT regexp('%SystemDrive%\\Users\\John', r'%SystemDrive%\\Users.*');
+--------------------------------------------------------+
|REGEXP(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+--------------------------------------------------------+
|                                                    true|
+--------------------------------------------------------+

-- regexp_like
SET spark.sql.parser.escapedStringLiterals=true;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....| true|
+--------------------+-----+

SELECT regexp_like('%SystemDrive%\Users\John', '%SystemDrive%\\Users.*');
+-------------------------------------------------------------+
|REGEXP_LIKE(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+-------------------------------------------------------------+
|                                                         true|
+-------------------------------------------------------------+

SET spark.sql.parser.escapedStringLiterals=false;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....|false|
+--------------------+-----+

SELECT regexp_like('%SystemDrive%\\Users\\John', '%SystemDrive%\\\\Users.*');
+-------------------------------------------------------------+
|REGEXP_LIKE(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+-------------------------------------------------------------+
|                                                         true|
+-------------------------------------------------------------+

SELECT regexp_like('%SystemDrive%\\Users\\John', r'%SystemDrive%\\Users.*');
+-------------------------------------------------------------+
|REGEXP_LIKE(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+-------------------------------------------------------------+
|                                                         true|
+-------------------------------------------------------------+

-- rlike
SET spark.sql.parser.escapedStringLiterals=true;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....| true|
+--------------------+-----+

SELECT rlike('%SystemDrive%\Users\John', '%SystemDrive%\\Users.*');
+-------------------------------------------------------+
|RLIKE(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+-------------------------------------------------------+
|                                                   true|
+-------------------------------------------------------+

SET spark.sql.parser.escapedStringLiterals=false;
+--------------------+-----+
|                 key|value|
+--------------------+-----+
|spark.sql.parser....|false|
+--------------------+-----+

SELECT rlike('%SystemDrive%\\Users\\John', '%SystemDrive%\\\\Users.*');
+-------------------------------------------------------+
|RLIKE(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+-------------------------------------------------------+
|                                                   true|
+-------------------------------------------------------+

SELECT rlike('%SystemDrive%\\Users\\John', r'%SystemDrive%\\Users.*');
+-------------------------------------------------------+
|RLIKE(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+-------------------------------------------------------+
|                                                   true|
+-------------------------------------------------------+

その他関数

関数	説明
aes_decrypt(expr, key[, mode[, padding[, aad]]])	`expr` の値を AES を使用して `mode` で `padding` で復号化して返します。キー長 16、24、32 ビットがサポートされています。サポートされている (`mode`, `padding`) の組み合わせは ('ECB', 'PKCS')、('GCM', 'NONE')、('CBC', 'PKCS') です。オプションの追加認証データ (AAD) は GCM のみにサポートされています。暗号化で提供された場合、復号化でも同一の AAD 値を提供する必要があります。デフォルトモードは GCM です。
aes_encrypt(expr, key[, mode[, padding[, iv[, aad]]]])	指定された `mode` で `padding` を使用して AES で `expr` の値を暗号化して返します。キー長 16、24、32 ビットがサポートされています。サポートされている (`mode`, `padding`) の組み合わせは ('ECB', 'PKCS')、('GCM', 'NONE')、('CBC', 'PKCS') です。オプションの初期化ベクトル (IV) は CBC および GCM モードでのみサポートされています。これらは CBC の場合は 16 バイト、GCM の場合は 12 バイトである必要があります。提供されない場合、ランダムなベクトルが生成され、出力の先頭に追加されます。オプションの追加認証データ (AAD) は GCM のみにサポートされています。暗号化で提供された場合、復号化でも同一の AAD 値を提供する必要があります。デフォルトモードは GCM です。
assert_true(expr [, message])	`expr` が true でない場合、例外をスローします。
bitmap_bit_position(child)	指定された入力子式に対するビット位置を返します。
bitmap_bucket_number(child)	指定された入力子式に対するバケット番号を返します。
bitmap_count(child)	子ビットマップ内のセットビット数を返します。
current_catalog()	現在のカタログを返します。
current_database()	現在のデータベースを返します。
current_schema()	現在のデータベースを返します。
current_user()	現在の実行コンテキストのユーザー名。
from_avro(child, jsonFormatSchema, options)	バイナリAvro値をCatalyst値に変換します。
from_protobuf(data, messageName, descFilePath, options)	バイナリProtobuf値をCatalyst値に変換します。
hll_sketch_estimate(expr)	Datasketches HllSketchのバイナリ表現が与えられた場合の、一意な値の推定数を返します。
hll_union(first, second, allowDifferentLgConfigK)	Datasketches Unionオブジェクトを使用して、2つのDatasketches HllSketchオブジェクトのバイナリ表現をマージします。異なるlgConfigK値を持つスキッチのユニオンを許可するには、allowDifferentLgConfigKをtrueに設定します（デフォルトはfalse）。
input_file_block_length()	読み取られているブロックの長さを返します。利用できない場合は-1を返します。
input_file_block_start()	読み取られているブロックの開始オフセットを返します。利用できない場合は-1を返します。
input_file_name()	読み取られているファイルの名前を返します。利用できない場合は空文字列を返します。
java_method(class, method[, arg1[, arg2 ..]])	リフレクションを使用してメソッドを呼び出します。
monotonically_increasing_id()	単調増加する64ビット整数を返します。生成されたIDは単調増加し、一意であることが保証されますが、連続しているわけではありません。現在の実装では、パーティションIDは上位31ビットに、各パーティション内のレコード番号は下位33ビットに格納されます。データフレームのパーティション数が10億未満で、各パーティションのレコード数が80億未満であると想定しています。この関数は、結果がパーティションIDに依存するため、決定論的ではありません。
reflect(class, method[, arg1[, arg2 ..]])	リフレクションを使用してメソッドを呼び出します。
schema_of_avro(jsonFormatSchema, options)	JSON文字列形式のAvroスキーマをDDL形式のスキーマで返します。
session_user()	現在の実行コンテキストのユーザー名。
spark_partition_id()	現在のパーティションIDを返します。
to_avro(child[, jsonFormatSchema])	Catalystバイナリ入力値を対応するAvro形式の結果に変換します。
to_protobuf(child, messageName, descFilePath, options)	Catalystバイナリ入力値を対応するProtobuf形式の結果に変換します。
try_aes_decrypt(expr, key[, mode[, padding[, aad]]])	`aes_decrypt`の特別なバージョンで、同じ操作を実行しますが、復号化が実行できない場合はエラーを発生させるのではなく、NULL値を返します。
try_reflect(class, method[, arg1[, arg2 ..]])	`reflect`の特別なバージョンで、同じ操作を実行しますが、メソッドの呼び出しで例外が発生した場合はエラーを発生させるのではなく、NULL値を返します。
typeof(expr)	入力のデータ型のDDL形式の型文字列を返します。
user()	現在の実行コンテキストのユーザー名。
uuid()	汎用的に一意な識別子（UUID）文字列を返します。値は、標準的な36文字のUUID文字列として返されます。
version()	Sparkのバージョンを返します。文字列には2つのフィールドが含まれ、最初のフィールドはリリースバージョン、2番目のフィールドはgitリビジョンです。

例

-- aes_decrypt
SELECT aes_decrypt(unhex('83F16B2AA704794132802D248E6BFD4E380078182D1544813898AC97E709B28A94'), '0000111122223333');
+------------------------------------------------------------------------------------------------------------------------+
|aes_decrypt(unhex(83F16B2AA704794132802D248E6BFD4E380078182D1544813898AC97E709B28A94), 0000111122223333, GCM, DEFAULT, )|
+------------------------------------------------------------------------------------------------------------------------+
|                                                                                                        [53 70 61 72 6B]|
+------------------------------------------------------------------------------------------------------------------------+

SELECT aes_decrypt(unhex('6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210'), '0000111122223333', 'GCM');
+--------------------------------------------------------------------------------------------------------------------------------+
|aes_decrypt(unhex(6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210), 0000111122223333, GCM, DEFAULT, )|
+--------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                            [53 70 61 72 6B 2...|
+--------------------------------------------------------------------------------------------------------------------------------+

SELECT aes_decrypt(unbase64('3lmwu+Mw0H3fi5NDvcu9lg=='), '1234567890abcdef', 'ECB', 'PKCS');
+------------------------------------------------------------------------------+
|aes_decrypt(unbase64(3lmwu+Mw0H3fi5NDvcu9lg==), 1234567890abcdef, ECB, PKCS, )|
+------------------------------------------------------------------------------+
|                                                          [53 70 61 72 6B 2...|
+------------------------------------------------------------------------------+

SELECT aes_decrypt(unbase64('2NYmDCjgXTbbxGA3/SnJEfFC/JQ7olk2VQWReIAAFKo='), '1234567890abcdef', 'CBC');
+-----------------------------------------------------------------------------------------------------+
|aes_decrypt(unbase64(2NYmDCjgXTbbxGA3/SnJEfFC/JQ7olk2VQWReIAAFKo=), 1234567890abcdef, CBC, DEFAULT, )|
+-----------------------------------------------------------------------------------------------------+
|                                                                                 [41 70 61 63 68 6...|
+-----------------------------------------------------------------------------------------------------+

SELECT aes_decrypt(unbase64('AAAAAAAAAAAAAAAAAAAAAPSd4mWyMZ5mhvjiAPQJnfg='), 'abcdefghijklmnop12345678ABCDEFGH', 'CBC', 'DEFAULT');
+---------------------------------------------------------------------------------------------------------------------+
|aes_decrypt(unbase64(AAAAAAAAAAAAAAAAAAAAAPSd4mWyMZ5mhvjiAPQJnfg=), abcdefghijklmnop12345678ABCDEFGH, CBC, DEFAULT, )|
+---------------------------------------------------------------------------------------------------------------------+
|                                                                                                     [53 70 61 72 6B]|
+---------------------------------------------------------------------------------------------------------------------+

SELECT aes_decrypt(unbase64('AAAAAAAAAAAAAAAAQiYi+sTLm7KD9UcZ2nlRdYDe/PX4'), 'abcdefghijklmnop12345678ABCDEFGH', 'GCM', 'DEFAULT', 'This is an AAD mixed into the input');
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
|aes_decrypt(unbase64(AAAAAAAAAAAAAAAAQiYi+sTLm7KD9UcZ2nlRdYDe/PX4), abcdefghijklmnop12345678ABCDEFGH, GCM, DEFAULT, This is an AAD mixed into the input)|
+--------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                        [53 70 61 72 6B]|
+--------------------------------------------------------------------------------------------------------------------------------------------------------+

-- aes_encrypt
SELECT hex(aes_encrypt('Spark', '0000111122223333'));
+-----------------------------------------------------------+
|hex(aes_encrypt(Spark, 0000111122223333, GCM, DEFAULT, , ))|
+-----------------------------------------------------------+
|                                       FA4BE3E7B9E3DD07F...|
+-----------------------------------------------------------+

SELECT hex(aes_encrypt('Spark SQL', '0000111122223333', 'GCM'));
+---------------------------------------------------------------+
|hex(aes_encrypt(Spark SQL, 0000111122223333, GCM, DEFAULT, , ))|
+---------------------------------------------------------------+
|                                           4C9835D33A48E4660...|
+---------------------------------------------------------------+

SELECT base64(aes_encrypt('Spark SQL', '1234567890abcdef', 'ECB', 'PKCS'));
+---------------------------------------------------------------+
|base64(aes_encrypt(Spark SQL, 1234567890abcdef, ECB, PKCS, , ))|
+---------------------------------------------------------------+
|                                           3lmwu+Mw0H3fi5NDv...|
+---------------------------------------------------------------+

SELECT base64(aes_encrypt('Apache Spark', '1234567890abcdef', 'CBC', 'DEFAULT'));
+---------------------------------------------------------------------+
|base64(aes_encrypt(Apache Spark, 1234567890abcdef, CBC, DEFAULT, , ))|
+---------------------------------------------------------------------+
|                                                 FD+zPF4ejYVMHmPGk...|
+---------------------------------------------------------------------+

SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop12345678ABCDEFGH', 'CBC', 'DEFAULT', unhex('00000000000000000000000000000000')));
+---------------------------------------------------------------------------------------------------------------------+
|base64(aes_encrypt(Spark, abcdefghijklmnop12345678ABCDEFGH, CBC, DEFAULT, unhex(00000000000000000000000000000000), ))|
+---------------------------------------------------------------------------------------------------------------------+
|                                                                                                 AAAAAAAAAAAAAAAAA...|
+---------------------------------------------------------------------------------------------------------------------+

SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop12345678ABCDEFGH', 'GCM', 'DEFAULT', unhex('000000000000000000000000'), 'This is an AAD mixed into the input'));
+------------------------------------------------------------------------------------------------------------------------------------------------+
|base64(aes_encrypt(Spark, abcdefghijklmnop12345678ABCDEFGH, GCM, DEFAULT, unhex(000000000000000000000000), This is an AAD mixed into the input))|
+------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                            AAAAAAAAAAAAAAAAQ...|
+------------------------------------------------------------------------------------------------------------------------------------------------+

-- assert_true
SELECT assert_true(0 < 1);
+--------------------------------------------+
|assert_true((0 < 1), '(0 < 1)' is not true!)|
+--------------------------------------------+
|                                        NULL|
+--------------------------------------------+

-- bitmap_bit_position
SELECT bitmap_bit_position(1);
+----------------------+
|bitmap_bit_position(1)|
+----------------------+
|                     0|
+----------------------+

SELECT bitmap_bit_position(123);
+------------------------+
|bitmap_bit_position(123)|
+------------------------+
|                     122|
+------------------------+

-- bitmap_bucket_number
SELECT bitmap_bucket_number(123);
+-------------------------+
|bitmap_bucket_number(123)|
+-------------------------+
|                        1|
+-------------------------+

SELECT bitmap_bucket_number(0);
+-----------------------+
|bitmap_bucket_number(0)|
+-----------------------+
|                      0|
+-----------------------+

-- bitmap_count
SELECT bitmap_count(X '1010');
+---------------------+
|bitmap_count(X'1010')|
+---------------------+
|                    2|
+---------------------+

SELECT bitmap_count(X 'FFFF');
+---------------------+
|bitmap_count(X'FFFF')|
+---------------------+
|                   16|
+---------------------+

SELECT bitmap_count(X '0');
+-------------------+
|bitmap_count(X'00')|
+-------------------+
|                  0|
+-------------------+

-- current_catalog
SELECT current_catalog();
+-----------------+
|current_catalog()|
+-----------------+
|    spark_catalog|
+-----------------+

-- current_database
SELECT current_database();
+----------------+
|current_schema()|
+----------------+
|         default|
+----------------+

-- current_schema
SELECT current_schema();
+----------------+
|current_schema()|
+----------------+
|         default|
+----------------+

-- current_user
SELECT current_user();
+--------------+
|current_user()|
+--------------+
|      spark-rm|
+--------------+

-- hll_sketch_estimate
SELECT hll_sketch_estimate(hll_sketch_agg(col)) FROM VALUES (1), (1), (2), (2), (3) tab(col);
+--------------------------------------------+
|hll_sketch_estimate(hll_sketch_agg(col, 12))|
+--------------------------------------------+
|                                           3|
+--------------------------------------------+

-- hll_union
SELECT hll_sketch_estimate(hll_union(hll_sketch_agg(col1), hll_sketch_agg(col2))) FROM VALUES (1, 4), (1, 4), (2, 5), (2, 5), (3, 6) tab(col1, col2);
+-----------------------------------------------------------------------------------------+
|hll_sketch_estimate(hll_union(hll_sketch_agg(col1, 12), hll_sketch_agg(col2, 12), false))|
+-----------------------------------------------------------------------------------------+
|                                                                                        6|
+-----------------------------------------------------------------------------------------+

-- input_file_block_length
SELECT input_file_block_length();
+-------------------------+
|input_file_block_length()|
+-------------------------+
|                       -1|
+-------------------------+

-- input_file_block_start
SELECT input_file_block_start();
+------------------------+
|input_file_block_start()|
+------------------------+
|                      -1|
+------------------------+

-- input_file_name
SELECT input_file_name();
+-----------------+
|input_file_name()|
+-----------------+
|                 |
+-----------------+

-- java_method
SELECT java_method('java.util.UUID', 'randomUUID');
+---------------------------------------+
|java_method(java.util.UUID, randomUUID)|
+---------------------------------------+
|                   f2c32f70-de25-4b7...|
+---------------------------------------+

SELECT java_method('java.util.UUID', 'fromString', 'a5cf6c42-0c85-418f-af6c-3e4e5b1328f2');
+-----------------------------------------------------------------------------+
|java_method(java.util.UUID, fromString, a5cf6c42-0c85-418f-af6c-3e4e5b1328f2)|
+-----------------------------------------------------------------------------+
|                                                         a5cf6c42-0c85-418...|
+-----------------------------------------------------------------------------+

-- monotonically_increasing_id
SELECT monotonically_increasing_id();
+-----------------------------+
|monotonically_increasing_id()|
+-----------------------------+
|                            0|
+-----------------------------+

-- reflect
SELECT reflect('java.util.UUID', 'randomUUID');
+-----------------------------------+
|reflect(java.util.UUID, randomUUID)|
+-----------------------------------+
|               4742f5b7-031a-4d7...|
+-----------------------------------+

SELECT reflect('java.util.UUID', 'fromString', 'a5cf6c42-0c85-418f-af6c-3e4e5b1328f2');
+-------------------------------------------------------------------------+
|reflect(java.util.UUID, fromString, a5cf6c42-0c85-418f-af6c-3e4e5b1328f2)|
+-------------------------------------------------------------------------+
|                                                     a5cf6c42-0c85-418...|
+-------------------------------------------------------------------------+

-- schema_of_avro
SELECT schema_of_avro('{"type": "record", "name": "struct", "fields": [{"name": "u", "type": ["int", "string"]}]}', map());
+-----------------------------------------------------------------------------------------------------------------+
|schema_of_avro({"type": "record", "name": "struct", "fields": [{"name": "u", "type": ["int", "string"]}]}, map())|
+-----------------------------------------------------------------------------------------------------------------+
|                                                                                             STRUCT<u: STRUCT<...|
+-----------------------------------------------------------------------------------------------------------------+

-- session_user
SELECT session_user();
+--------------+
|session_user()|
+--------------+
|      spark-rm|
+--------------+

-- spark_partition_id
SELECT spark_partition_id();
+--------------------+
|SPARK_PARTITION_ID()|
+--------------------+
|                   0|
+--------------------+

-- try_aes_decrypt
SELECT try_aes_decrypt(unhex('6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210'), '0000111122223333', 'GCM');
+------------------------------------------------------------------------------------------------------------------------------------+
|try_aes_decrypt(unhex(6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210), 0000111122223333, GCM, DEFAULT, )|
+------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                [53 70 61 72 6B 2...|
+------------------------------------------------------------------------------------------------------------------------------------+

SELECT try_aes_decrypt(unhex('----------468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210'), '0000111122223333', 'GCM');
+------------------------------------------------------------------------------------------------------------------------------------+
|try_aes_decrypt(unhex(----------468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210), 0000111122223333, GCM, DEFAULT, )|
+------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                NULL|
+------------------------------------------------------------------------------------------------------------------------------------+

-- try_reflect
SELECT try_reflect('java.util.UUID', 'randomUUID');
+---------------------------------------+
|try_reflect(java.util.UUID, randomUUID)|
+---------------------------------------+
|                   d20850cd-f747-4a9...|
+---------------------------------------+

SELECT try_reflect('java.util.UUID', 'fromString', 'a5cf6c42-0c85-418f-af6c-3e4e5b1328f2');
+-----------------------------------------------------------------------------+
|try_reflect(java.util.UUID, fromString, a5cf6c42-0c85-418f-af6c-3e4e5b1328f2)|
+-----------------------------------------------------------------------------+
|                                                         a5cf6c42-0c85-418...|
+-----------------------------------------------------------------------------+

SELECT try_reflect('java.net.URLDecoder', 'decode', '%');
+-------------------------------------------+
|try_reflect(java.net.URLDecoder, decode, %)|
+-------------------------------------------+
|                                       NULL|
+-------------------------------------------+

-- typeof
SELECT typeof(1);
+---------+
|typeof(1)|
+---------+
|      int|
+---------+

SELECT typeof(array(1));
+----------------+
|typeof(array(1))|
+----------------+
|      array<int>|
+----------------+

-- user
SELECT user();
+--------+
|  user()|
+--------+
|spark-rm|
+--------+

-- uuid
SELECT uuid();
+--------------------+
|              uuid()|
+--------------------+
|46bf63f3-13cd-4c9...|
+--------------------+

-- version
SELECT version();
+--------------------+
|           version()|
+--------------------+
|4.0.0 fa33ea000a0...|
+--------------------+

ジェネレーター関数

関数	説明
collations()	すべてのSpark SQL文字列照合順序を取得します。
explode(expr)	配列`expr`の要素を複数の行に展開するか、マップ`expr`の要素を複数の行と列に展開します。特に指定がない限り、配列の要素にはデフォルトの列名`col`、マップの要素には`key`と`value`を使用します。
explode_outer(expr)	配列`expr`の要素を複数の行に展開するか、マップ`expr`の要素を複数の行と列に展開します。特に指定がない限り、配列の要素にはデフォルトの列名`col`、マップの要素には`key`と`value`を使用します。
inline(expr)	構造体の配列をテーブルに展開します。特に指定がない限り、デフォルトで列名`col1`、`col2`などを使用します。
inline_outer(expr)	構造体の配列をテーブルに展開します。特に指定がない限り、デフォルトで列名`col1`、`col2`などを使用します。
posexplode(expr)	配列`expr`の要素を位置情報付きで複数の行に展開するか、マップ`expr`の要素を位置情報付きで複数の行と列に展開します。特に指定がない限り、位置には`pos`、配列の要素には`col`、マップの要素には`key`と`value`という列名を使用します。
posexplode_outer(expr)	配列`expr`の要素を位置情報付きで複数の行に展開するか、マップ`expr`の要素を位置情報付きで複数の行と列に展開します。特に指定がない限り、位置には`pos`、配列の要素には`col`、マップの要素には`key`と`value`という列名を使用します。
sql_keywords()	Spark SQLキーワードを取得します。
stack(n, expr1, ..., exprk)	`expr1`、...、`exprk`を`n`行に分割します。特に指定がない限り、デフォルトで`col0`、`col1`などの列名を使用します。

例

-- collations
SELECT * FROM collations() WHERE NAME = 'UTF8_BINARY';
+-------+-------+-----------+--------+-------+------------------+----------------+-------------+-----------+
|CATALOG| SCHEMA|       NAME|LANGUAGE|COUNTRY|ACCENT_SENSITIVITY|CASE_SENSITIVITY|PAD_ATTRIBUTE|ICU_VERSION|
+-------+-------+-----------+--------+-------+------------------+----------------+-------------+-----------+
| SYSTEM|BUILTIN|UTF8_BINARY|    NULL|   NULL|  ACCENT_SENSITIVE|  CASE_SENSITIVE|       NO_PAD|       NULL|
+-------+-------+-----------+--------+-------+------------------+----------------+-------------+-----------+

-- explode
SELECT * FROM explode(array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+

SELECT * FROM explode(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+

-- explode_outer
SELECT explode_outer(array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+

SELECT explode_outer(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+

-- inline
SELECT * FROM inline(array(struct(1, 'a'), struct(2, 'b')));
+----+----+
|col1|col2|
+----+----+
|   1|   a|
|   2|   b|
+----+----+

SELECT * FROM inline(input => array(struct(1, 'a'), struct(2, 'b')));
+----+----+
|col1|col2|
+----+----+
|   1|   a|
|   2|   b|
+----+----+

-- inline_outer
SELECT inline_outer(array(struct(1, 'a'), struct(2, 'b')));
+----+----+
|col1|col2|
+----+----+
|   1|   a|
|   2|   b|
+----+----+

SELECT inline_outer(input => array(struct(1, 'a'), struct(2, 'b')));
+----+----+
|col1|col2|
+----+----+
|   1|   a|
|   2|   b|
+----+----+

-- posexplode
SELECT * FROM posexplode(array(10,20));
+---+---+
|pos|col|
+---+---+
|  0| 10|
|  1| 20|
+---+---+

SELECT * FROM posexplode(collection => array(10,20));
+---+---+
|pos|col|
+---+---+
|  0| 10|
|  1| 20|
+---+---+

-- posexplode_outer
SELECT * FROM posexplode_outer(array(10,20));
+---+---+
|pos|col|
+---+---+
|  0| 10|
|  1| 20|
+---+---+

SELECT * FROM posexplode_outer(collection => array(10,20));
+---+---+
|pos|col|
+---+---+
|  0| 10|
|  1| 20|
+---+---+

-- sql_keywords
SELECT * FROM sql_keywords() LIMIT 2;
+-------+--------+
|keyword|reserved|
+-------+--------+
|    ADD|   false|
|  AFTER|   false|
+-------+--------+

-- stack
SELECT stack(2, 1, 2, 3);
+----+----+
|col0|col1|
+----+----+
|   1|   2|
|   3|NULL|
+----+----+

テーブル関数

関数	説明
range(start[, end[, step[, numSlices]]]) / range(end)	指定された範囲内の値のテーブルを返します。

例

-- range
SELECT * FROM range(1);
+---+
| id|
+---+
|  0|
+---+

SELECT * FROM range(0, 2);
+---+
| id|
+---+
|  0|
|  1|
+---+

SELECT * FROM range(0, 4, 2);
+---+
| id|
+---+
|  0|
|  2|
+---+

バリアント関数

関数	説明
is_variant_null(expr)	バリアント値がバリアントNULLかどうかを確認します。入力がバリアントNULLである場合にのみtrueを返し、それ以外の場合はfalseを返します（SQL NULLの場合も含む）。
parse_json(jsonStr)	JSON文字列をバリアント値として解析します。文字列が無効なJSON値の場合、例外を発生させます。
schema_of_variant(v)	バリアントのSQL形式のスキーマを返します。
schema_of_variant_agg(v)	バリアント列のSQL形式の結合されたスキーマを返します。
to_variant_object(expr)	ネストされた入力（配列/マップ/構造体）をバリアントに変換します。マップと構造体は、SQL構造体とは異なり順序付けされないバリアントオブジェクトに変換されます。入力マップは文字列キーのみを持つことができます。
try_parse_json(jsonStr)	JSON文字列をバリアント値として解析します。文字列が無効なJSON値の場合、NULLを返します。
try_variant_get(v, path[, type])	`path`に従って`v`からサブバリアントを抽出し、その後サブバリアントを`type`にキャストします。`type`が省略されている場合、デフォルトは`variant`になります。パスが存在しない場合、またはキャストに失敗した場合はNULLを返します。
variant_explode(expr)	バリアントオブジェクト/配列を、そのフィールド/要素を含む複数の行に分割します。結果のスキーマは`struct<pos int, key string, value variant>`です。`pos`は親オブジェクト/配列内のフィールド/要素の位置、`value`はそのフィールド/要素の値です。`key`はバリアントオブジェクトを展開する際のフィールド名、またはバリアント配列を展開する際にはNULLになります。SQL NULL、バリアントNULL、およびその他のバリアント値を含む、バリアント配列/オブジェクトではない入力は無視されます。
variant_explode_outer(expr)	バリアントオブジェクト/配列を、そのフィールド/要素を含む複数の行に分割します。結果のスキーマは`struct<pos int, key string, value variant>`です。`pos`は親オブジェクト/配列内のフィールド/要素の位置、`value`はそのフィールド/要素の値です。`key`はバリアントオブジェクトを展開する際のフィールド名、またはバリアント配列を展開する際にはNULLになります。SQL NULL、バリアントNULL、およびその他のバリアント値を含む、バリアント配列/オブジェクトではない入力は無視されます。
variant_get(v, path[, type])	`path`に従って`v`からサブバリアントを抽出し、その後サブバリアントを`type`にキャストします。`type`が省略されている場合、デフォルトは`variant`になります。パスが存在しない場合はNULLを返します。キャストに失敗した場合は例外を発生させます。

例

-- is_variant_null
SELECT is_variant_null(parse_json('null'));
+---------------------------------+
|is_variant_null(parse_json(null))|
+---------------------------------+
|                             true|
+---------------------------------+

SELECT is_variant_null(parse_json('"null"'));
+-----------------------------------+
|is_variant_null(parse_json("null"))|
+-----------------------------------+
|                              false|
+-----------------------------------+

SELECT is_variant_null(parse_json('13'));
+-------------------------------+
|is_variant_null(parse_json(13))|
+-------------------------------+
|                          false|
+-------------------------------+

SELECT is_variant_null(parse_json(null));
+---------------------------------+
|is_variant_null(parse_json(NULL))|
+---------------------------------+
|                            false|
+---------------------------------+

SELECT is_variant_null(variant_get(parse_json('{"a":null, "b":"spark"}'), "$.c"));
+----------------------------------------------------------------------+
|is_variant_null(variant_get(parse_json({"a":null, "b":"spark"}), $.c))|
+----------------------------------------------------------------------+
|                                                                 false|
+----------------------------------------------------------------------+

SELECT is_variant_null(variant_get(parse_json('{"a":null, "b":"spark"}'), "$.a"));
+----------------------------------------------------------------------+
|is_variant_null(variant_get(parse_json({"a":null, "b":"spark"}), $.a))|
+----------------------------------------------------------------------+
|                                                                  true|
+----------------------------------------------------------------------+

-- parse_json
SELECT parse_json('{"a":1,"b":0.8}');
+---------------------------+
|parse_json({"a":1,"b":0.8})|
+---------------------------+
|            {"a":1,"b":0.8}|
+---------------------------+

-- schema_of_variant
SELECT schema_of_variant(parse_json('null'));
+-----------------------------------+
|schema_of_variant(parse_json(null))|
+-----------------------------------+
|                               VOID|
+-----------------------------------+

SELECT schema_of_variant(parse_json('[{"b":true,"a":0}]'));
+-------------------------------------------------+
|schema_of_variant(parse_json([{"b":true,"a":0}]))|
+-------------------------------------------------+
|                             ARRAY<OBJECT<a: B...|
+-------------------------------------------------+

-- schema_of_variant_agg
SELECT schema_of_variant_agg(parse_json(j)) FROM VALUES ('1'), ('2'), ('3') AS tab(j);
+------------------------------------+
|schema_of_variant_agg(parse_json(j))|
+------------------------------------+
|                              BIGINT|
+------------------------------------+

SELECT schema_of_variant_agg(parse_json(j)) FROM VALUES ('{"a": 1}'), ('{"b": true}'), ('{"c": 1.23}') AS tab(j);
+------------------------------------+
|schema_of_variant_agg(parse_json(j))|
+------------------------------------+
|                OBJECT<a: BIGINT,...|
+------------------------------------+

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

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

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

SELECT to_variant_object(array(map("a", 2)));
+-----------------------------------+
|to_variant_object(array(map(a, 2)))|
+-----------------------------------+
|                          [{"a":2}]|
+-----------------------------------+

-- try_parse_json
SELECT try_parse_json('{"a":1,"b":0.8}');
+-------------------------------+
|try_parse_json({"a":1,"b":0.8})|
+-------------------------------+
|                {"a":1,"b":0.8}|
+-------------------------------+

SELECT try_parse_json('{"a":1,');
+-----------------------+
|try_parse_json({"a":1,)|
+-----------------------+
|                   NULL|
+-----------------------+

-- try_variant_get
SELECT try_variant_get(parse_json('{"a": 1}'), '$.a', 'int');
+------------------------------------------+
|try_variant_get(parse_json({"a": 1}), $.a)|
+------------------------------------------+
|                                         1|
+------------------------------------------+

SELECT try_variant_get(parse_json('{"a": 1}'), '$.b', 'int');
+------------------------------------------+
|try_variant_get(parse_json({"a": 1}), $.b)|
+------------------------------------------+
|                                      NULL|
+------------------------------------------+

SELECT try_variant_get(parse_json('[1, "2"]'), '$[1]', 'string');
+-------------------------------------------+
|try_variant_get(parse_json([1, "2"]), $[1])|
+-------------------------------------------+
|                                          2|
+-------------------------------------------+

SELECT try_variant_get(parse_json('[1, "2"]'), '$[2]', 'string');
+-------------------------------------------+
|try_variant_get(parse_json([1, "2"]), $[2])|
+-------------------------------------------+
|                                       NULL|
+-------------------------------------------+

SELECT try_variant_get(parse_json('[1, "hello"]'), '$[1]');
+-----------------------------------------------+
|try_variant_get(parse_json([1, "hello"]), $[1])|
+-----------------------------------------------+
|                                        "hello"|
+-----------------------------------------------+

SELECT try_variant_get(parse_json('[1, "hello"]'), '$[1]', 'int');
+-----------------------------------------------+
|try_variant_get(parse_json([1, "hello"]), $[1])|
+-----------------------------------------------+
|                                           NULL|
+-----------------------------------------------+

-- variant_explode
SELECT * from variant_explode(parse_json('["hello", "world"]'));
+---+----+-------+
|pos| key|  value|
+---+----+-------+
|  0|NULL|"hello"|
|  1|NULL|"world"|
+---+----+-------+

SELECT * from variant_explode(input => parse_json('{"a": true, "b": 3.14}'));
+---+---+-----+
|pos|key|value|
+---+---+-----+
|  0|  a| true|
|  1|  b| 3.14|
+---+---+-----+

-- variant_explode_outer
SELECT * from variant_explode_outer(parse_json('["hello", "world"]'));
+---+----+-------+
|pos| key|  value|
+---+----+-------+
|  0|NULL|"hello"|
|  1|NULL|"world"|
+---+----+-------+

SELECT * from variant_explode_outer(input => parse_json('{"a": true, "b": 3.14}'));
+---+---+-----+
|pos|key|value|
+---+---+-----+
|  0|  a| true|
|  1|  b| 3.14|
+---+---+-----+

-- variant_get
SELECT variant_get(parse_json('{"a": 1}'), '$.a', 'int');
+--------------------------------------+
|variant_get(parse_json({"a": 1}), $.a)|
+--------------------------------------+
|                                     1|
+--------------------------------------+

SELECT variant_get(parse_json('{"a": 1}'), '$.b', 'int');
+--------------------------------------+
|variant_get(parse_json({"a": 1}), $.b)|
+--------------------------------------+
|                                  NULL|
+--------------------------------------+

SELECT variant_get(parse_json('[1, "2"]'), '$[1]', 'string');
+---------------------------------------+
|variant_get(parse_json([1, "2"]), $[1])|
+---------------------------------------+
|                                      2|
+---------------------------------------+

SELECT variant_get(parse_json('[1, "2"]'), '$[2]', 'string');
+---------------------------------------+
|variant_get(parse_json([1, "2"]), $[2])|
+---------------------------------------+
|                                   NULL|
+---------------------------------------+

SELECT variant_get(parse_json('[1, "hello"]'), '$[1]');
+-------------------------------------------+
|variant_get(parse_json([1, "hello"]), $[1])|
+-------------------------------------------+
|                                    "hello"|
+-------------------------------------------+

Spark SQL ガイド

組み込み関数

集計関数

例

ウィンドウ関数

例

配列関数

例

コレクション関数

例

構造体関数

例

マップ関数

例

日付とタイムスタンプ関数

例

数学関数

例

文字列関数

例

条件関数

例

ハッシュ関数

例

CSV 関数

例

JSON 関数

例

XML 関数

例

URL 関数

例

ビット演算関数

例

変換関数

例

述語関数

例

その他関数

例

ジェネレーター関数

例

テーブル関数

例

バリアント関数

例