内置函数
聚合函数
函数 | 描述 |
---|---|
any(expr) | 如果 `expr` 的至少一个值为真,则返回真。 |
any_value(expr[, isIgnoreNull]) | 返回一个组行的 `expr` 的某个值。 如果 `isIgnoreNull` 为真,则只返回非空值。 |
approx_count_distinct(expr[, relativeSD]) | 通过 HyperLogLog++ 返回估计的基数。 `relativeSD` 定义了允许的最大相对标准差。 |
approx_percentile(col, percentage [, accuracy]) | 返回数字或 ANSI 区间列 `col` 的近似 `percentile`,这是有序 `col` 值中最小的值(从小到大排序),使得不超过 `percentage` 的 `col` 值小于或等于该值。比例值必须在 0.0 和 1.0 之间。 `accuracy` 参数(默认值:10000)是一个正数,用于控制近似的准确性,以牺牲内存为代价。较高的 `accuracy` 值会提供更好的准确性,`1.0/accuracy` 是近似的相对误差。 当 `percentage` 是一个数组时,百分比数组中的每个值必须在 0.0 和 1.0 之间。 在这种情况下,返回给定百分比数组的列 `col` 的近似百分位数数组。 |
array_agg(expr) | 收集并返回一个非唯一元素的列表。 |
avg(expr) | 返回从一组值计算的平均值。 |
bit_and(expr) | 返回所有非空输入值的按位与,如果没有返回空。 |
bit_or(expr) | 返回所有非空输入值的按位或,如果没有返回空。 |
bit_xor(expr) | 返回所有非空输入值的按位异或,如果没有返回空。 |
bitmap_construct_agg(child) | 返回一个位图,其中包含所有来自子表达式的值的位设置位置。子表达式可能是 bitmap_bit_position()。 |
bitmap_or_agg(child) | 返回一个位图,它是来自子表达式的所有位图的按位或。输入应该是由 bitmap_construct_agg() 创建的位图。 |
bool_and(expr) | 如果 `expr` 的所有值为真,则返回真。 |
bool_or(expr) | 如果 `expr` 的至少一个值为真,则返回真。 |
collect_list(expr) | 收集并返回一个非唯一元素的列表。 |
collect_set(expr) | 收集并返回一个唯一元素的集合。 |
corr(expr1, expr2) | 返回一组数字对的皮尔逊相关系数。 |
count(*) | 返回检索到的行的总数,包括包含空的行。 |
count(expr[, expr...]) | 返回供应的表达式的非空行数。 |
count(DISTINCT expr[, expr...]) | 返回供应的表达式的唯一且非空行数。 |
count_if(expr) | 返回该表达式的 `TRUE` 值的数量。 |
count_min_sketch(col, eps, confidence, seed) | 返回具有给定 esp、置信度和种子的列的计数最小草图。结果是一个字节数组,可以在使用之前反序列化为 `CountMinSketch`。计数最小草图是一种用于基数估计的概率数据结构,使用的是亚线性空间。 |
covar_pop(expr1, expr2) | 返回一组数字对的总体协方差。 |
covar_samp(expr1, expr2) | 返回一组数字对的样本协方差。 |
every(expr) | 如果 `expr` 的所有值为真,则返回真。 |
first(expr[, isIgnoreNull]) | 返回组行的 `expr` 的第一个值。 如果 `isIgnoreNull` 为真,则只返回非空值。 |
first_value(expr[, isIgnoreNull]) | 返回组行的 `expr` 的第一个值。 如果 `isIgnoreNull` 为真,则只返回非空值。 |
grouping(col) | 指示在 GROUP BY 中指定的列是否被聚合,如果聚合则在结果集中返回 1,否则返回 0。 |
grouping_id([col1[, col2 ..]]) | 返回分组级别,等于 `(grouping(c1) << (n-1)) + (grouping(c2) << (n-2)) + ... + grouping(cn)` |
histogram_numeric(expr, nb) | 计算数字 'expr' 的直方图,使用 nb 个箱子。 返回值是表示直方图箱子中心的 (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` 为真,则只返回非空值。 |
last_value(expr[, isIgnoreNull]) | 返回组行的 `expr` 的最后一个值。 如果 `isIgnoreNull` 为真,则只返回非空值。 |
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) | 返回 `col` 中值的最频繁值。NULL 值被忽略。如果所有值都是 NULL,或者行数为 0,则返回 NULL。 |
percentile(col, percentage [, frequency]) | 返回在给定百分比处的数字或 ANSI 区间列 `col` 的确切百分位数值。百分比值必须在 0.0 和 1.0 之间。频率的值应该是正整数。 |
percentile(col, array(percentage1 [, percentage2]...) [, frequency]) | 返回在给定百分比处的数字列 `col` 的确切百分位数值数组。百分比数组中的每个值必须在 0.0 和 1.0 之间。频率的值应该是正整数。 |
percentile_approx(col, percentage [, accuracy]) | 返回数字或 ANSI 区间列 `col` 的近似 `percentile`,这是有序 `col` 值中最小的值(从小到大排序),使得不超过 `percentage` 的 `col` 值小于或等于该值。百分比值必须在 0.0 和 1.0 之间。 `accuracy` 参数(默认值:10000)是一个正数,用于控制近似的准确性,以牺牲内存为代价。较高的 `accuracy` 值会提供更好的准确性,`1.0/accuracy` 是近似的相对误差。 当 `percentage` 是一个数组时,百分比数组中的每个值必须在 0.0 和 1.0 之间。 在这种情况下,返回给定百分比数组的列 `col` 的近似百分位数数组。 |
regr_avgx(y, x) | 返回组中非空配对的自变量的平均值,其中 `y` 是因变量,`x` 是自变量。 |
regr_avgy(y, x) | 返回组中非空配对的因变量的平均值,其中 `y` 是因变量,`x` 是自变量。 |
regr_count(y, x) | 返回组中非空数字对的数量,其中 `y` 是因变量,`x` 是自变量。 |
regr_intercept(y, x) | 返回组中非空配对的单变量线性回归线的截距,其中 `y` 是因变量,`x` 是自变量。 |
regr_r2(y, x) | 返回组中非空配对的决定系数,其中 `y` 是因变量,`x` 是自变量。 |
regr_slope(y, x) | 返回组中非空配对的线性回归线的斜率,其中 `y` 是因变量,`x` 是自变量。 |
regr_sxx(y, x) | 返回组中非空配对的 REGR_COUNT(y, x) * VAR_POP(x),其中 `y` 是因变量,`x` 是自变量。 |
regr_sxy(y, x) | 返回组中非空配对的 REGR_COUNT(y, x) * COVAR_POP(y, x),其中 `y` 是因变量,`x` 是自变量。 |
regr_syy(y, x) | 返回组中非空配对的 REGR_COUNT(y, x) * VAR_POP(y),其中 `y` 是因变量,`x` 是自变量。 |
skewness(expr) | 返回从一组值计算的偏度值。 |
some(expr) | 如果 `expr` 的至少一个值为真,则返回真。 |
std(expr) | 返回从一组值计算的样本标准差。 |
stddev(expr) | 返回从一组值计算的样本标准差。 |
stddev_pop(expr) | 返回从一组值计算的总体标准差。 |
stddev_samp(expr) | 返回从一组值计算的样本标准差。 |
sum(expr) | 返回从一组值计算的总和。 |
try_avg(expr) | 返回从一组值计算的平均值,溢出时结果为null。 |
try_sum(expr) | 返回从一组值计算的总和,溢出时结果为null。 |
var_pop(expr) | 返回从一组值计算的总体方差。 |
var_samp(expr) | 返回从一组值计算的样本方差。 |
variance(expr) | 返回从一组值计算的样本方差。 |
示例
-- 任何
SELECT 任何(col) FROM VALUES (true), (false), (false) AS tab(col);
+--------+
|任何(col)|
+--------+
| true|
+--------+
SELECT 任何col) FROM VALUES (NULL), (true), (false) AS tab(col);
+--------+
|任何col)|
+--------+
| true|
+--------+
SELECT 任何col) FROM VALUES (false), (false), (NULL) AS tab(col);
+--------+
|任何col)|
+--------+
| false|
+--------+
-- 任何值
SELECT 任何值col) FROM VALUES (10), (5), (20) AS tab(col);
+--------------+
|任何值col)|
+--------------+
| 10|
+--------------+
SELECT 任何值col) FROM VALUES (NULL), (5), (20) AS tab(col);
+--------------+
|任何值col)|
+--------------+
| NULL|
+--------------+
SELECT 任何值col, true) FROM VALUES (NULL), (5), (20) AS tab(col);
+--------------+
|任何值col)|
+--------------+
| 5|
+--------------+
-- 近似唯一计数
SELECT approx_count_distinctcol1) FROM VALUES (1), (1), (2), (2), (3) tab(col1);
+---------------------------+
|approx_count_distinctcol1)|
+---------------------------+
| 3|
+---------------------------+
-- 近似百分位数
SELECT approx_percentilecol, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col);
+-------------------------------------------------+
|approx_percentilecol, array(0.5, 0.4, 0.1), 100)|
+-------------------------------------------------+
| [1, 1, 0]|
+-------------------------------------------------+
SELECT approx_percentilecol, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col);
+--------------------------------+
|approx_percentilecol, 0.5, 100)|
+--------------------------------+
| 7|
+--------------------------------+
-- 分位数
SELECT percentile(col) FROM VALUES (0), (10) AS tab(col);
+-----------------------+
|percentilecol)|
+-----------------------+
|5.||
+-----------------------+
SELECT percentilecol, 0.3) FROM VALUES (0), (10) AS tab(col);
+-----------------------+
|percentilecol, 0.3)|
+-----------------------+
| 2.5|
+-----------------------+
-- 近似百分位
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...|
+--------------------------------------------+
-- 回归平均
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);
+---------------+
<span class
窗口函数
函数 | 描述 |
---|---|
cume_dist() | 计算一个值相对于分区中所有值的位置。 |
dense_rank() | 计算一组值中一个值的排名。结果是之前分配的排名值加一。与函数rank不同,dense_rank不会在排名序列中产生间隙。 |
lag(input[, offset[, default]]) | 返回窗口中当前行之前第`offset`行的`input`值。`offset`的默认值是1,`default`的默认值是null。如果`input`在第`offset`行的值为null,则返回null。如果没有这样的偏移行(例如,当offset为1时,窗口的第一行没有任何之前的行),则返回`default`。 |
lead(input[, offset[, default]]) | 返回窗口中当前行之后第`offset`行的`input`值。`offset`的默认值是1,`default`的默认值是null。如果`input`在第`offset`行的值为null,则返回null。如果没有这样的偏移行(例如,当offset为1时,窗口的最后一行没有任何后续行),则返回`default`。 |
nth_value(input[, offset]) | 返回窗口框架开始处第`offset`行的`input`值。偏移量从1开始。如果ignoreNulls=true,在寻找第`offset`行时会跳过null值。否则,每一行都会计入`offset`。如果没有这样的`offset`行(例如,当offset为10时,窗口框架的大小小于10),则返回null。 |
ntile(n) | 将每个窗口分区的行划分为从1到最多`n`的`n`个桶。 |
percent_rank() | 计算一组值中一个值的百分比排名。 |
rank() | 计算一组值中一个值的排名。结果是当前行在分区排序中的前面或相等行的数量加一。值将在序列中产生间隙。 |
row_number() | 根据窗口分区内行的排序,为每行分配一个唯一的顺序编号,从1开始。 |
示例
-- 累积分布
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|
+---+---+--------------------------------------------------------------------------------------------------------------+
-- 密集排名
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|
+---+---+--------------------------------------------------------------------------------------------------------------+
-- 滞后
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|
+---+---+-----------------------------------------------------------------------------------------------------------+
-- 前导
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|
+---+---+----------------------------------------------------------------------------------------------------------+
-- 第n个值
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|
+---+---+------------------------------------------------------------------------------------------------------------------+
-- 分块
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|
+---+---+----------------------------------------------------------------------------------------------------------+
-- 百分比排名
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|
+---+---+----------------------------------------------------------------------------------------------------------------+
-- 排名
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|
+---+---+--------------------------------------------------------------------------------------------------------+
-- 行号
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) | 将 val 放入数组 x 的索引 pos 中。数组索引从 1 开始。最大负索引为 -1,函数会在当前最后一个元素之后插入新元素。索引超出数组大小会附加数组,如果索引为负则在数组前面附加 'null' 元素。 |
array_intersect(array1, array2) | 返回 array1 和 array2 交集中的元素数组,且没有重复项。 |
array_join(array, delimiter[, nullReplacement]) | 使用分隔符连接给定数组的元素,并使用可选字符串替换 null 值。如果没有为 nullReplacement 设置值,任何 null 值都将被过滤。 |
array_max(array) | 返回数组中的最大值。NaN 大于任何非 NaN 元素,适用于 double/float 类型。NULL 元素将被跳过。 |
array_min(array) | 返回数组中的最小值。NaN 大于任何非 NaN 元素,适用于 double/float 类型。NULL 元素将被跳过。 |
array_position(array, element) | 返回数组中第一个匹配元素的 (1 基础) 索引,如果未找到匹配,则返回 0。 |
array_prepend(array, element) | 将元素添加到作为第一个参数传递的数组的开头。元素的类型应与数组元素的类型相同。null 元素也将被放入数组前面。但如果传递的数组为 NULL,输出也将是 NULL。 |
array_remove(array, element) | 从数组中删除所有等于元素的元素。 |
array_repeat(element, count) | 返回一个包含元素计数次的数组。 |
array_union(array1, array2) | 返回一个包含 array1 和 array2 中元素的数组,且没有重复项。 |
arrays_overlap(a1, a2) | 如果 a1 至少包含一个在 a2 中也存在的非 null 元素,则返回 true。如果数组没有公共元素,并且它们都是非空的,并且其中之一包含 null 元素,则返回 null,否则返回 false。 |
arrays_zip(a1, a2, ...) | 返回一个合并的结构数组,其中第 N 个结构包含输入数组的所有第 N 个值。 |
flatten(arrayOfArrays) | 将数组的数组转换为一个单一的数组。 |
get(array, index) | 返回给定 (0 基础) 索引的数组元素。如果索引指向数组边界之外,则该函数返回 NULL。 |
sequence(start, stop, step) |
从 start 到 stop(包含)生成一个元素数组,按 step 增加。返回元素的类型与参数表达式的类型相同。
支持的类型为:byte,short,integer,long,date,timestamp。 开始和停止表达式必须解析为相同类型。如果开始和停止表达式解析为 'date' 或 'timestamp' 类型,则步长表达式必须解析为 'interval' 或 'year-month interval' 或 'day-time interval' 类型,否则解析为与开始和停止表达式相同的类型。 |
shuffle(array) | 返回给定数组的随机排列。 |
slice(x, start, length) | 从索引 start 开始对数组 x 进行子集处理(数组索引从 1 开始,或如果 start 为负,从末尾开始),并指定长度。 |
sort_array(array[, ascendingOrder]) | 根据数组元素的自然顺序对输入数组进行升序或降序排序。NaN 大于任何非 NaN 元素,适用于 double/float 类型。null 元素将排在返回数组的开头(升序)或结尾(降序)。 |
示例
-- 数组
SELECT array(1, 2, 3);
+--------------+
|array(1, 2, 3)|
+--------------+
| [1, 2, 3]|
+--------------+
-- 数组添加
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|
+---------------------+
-- 数组压缩
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]|
+-----------------------------+
-- 数组包含
SELECT array_contains(array(1, 2, 3), 2);
+---------------------------------+
|array_contains(array(1, 2, 3), 2)|
+---------------------------------+
| true|
+---------------------------------+
-- 数组去重
SELECT array_distinct(array(1, 2, 3, null, 3));
+---------------------------------------+
|array_distinct(array(1, 2, 3, NULL, 3))|
+---------------------------------------+
| [1, 2, 3, NULL]|
+---------------------------------------+
-- 数组差集
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
+--------------------------------------------+
|array_except(array(1, 2, 3), array(1, 3, 5))|
+--------------------------------------------+
| [2]|
+--------------------------------------------+
-- 数组插入
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]|
+--------------------------------------+
-- 数组交集
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
+-----------------------------------------------+
|array_intersect(array(1, 2, 3), array(1, 3, 5))|
+-----------------------------------------------+
| [1, 3]|
+-----------------------------------------------+
-- 数组连接
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|
+-------------------------------------------+
-- 数组最大值
SELECT array_max(array(1, 20, null, 3));
+--------------------------------+
|array_max(array(1, 20, NULL, 3))|
+--------------------------------+
| 20|
+--------------------------------+
-- 数组最小值
SELECT array_min(array(1, 20, null, 3));
+--------------------------------+
|array_min(array(1, 20, NULL, 3))|
+--------------------------------+
| 1|
+--------------------------------+
-- 数组位置
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|
+----------------------------------------------+
-- 数组前置
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|
+----------------------+
-- 数组移除
SELECT array_remove(array(1, 2, 3, null, 3), 3);
+----------------------------------------+
|array_remove(array(1, 2, 3, NULL, 3), 3)|
+----------------------------------------+
| [1, 2, NULL]|
+----------------------------------------+
-- 数组重复
SELECT array_repeat('123', 2);
+--------------------+
|array_repeat(123, 2)|
+--------------------+
| [123, 123]|
+--------------------+
-- 数组合并
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]|
+-------------------------------------------+
-- 数组重叠
SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5));
+----------------------------------------------+
|arrays_overlap(array(1, 2, 3), array(3, 4, 5))|
+----------------------------------------------+
| true|
+----------------------------------------------+
-- 数组压缩
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...|
+-------------------------------------------------+
-- 扁平化
SELECT flatten(array(array(1, 2), array(3, 4)));
+----------------------------------------+
|flatten(array(array(1, 2), array(3, 4)))|
+----------------------------------------+
| [1, 2, 3, 4]|
+----------------------------------------+
-- 获取
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|
+-----------------------+
-- 序列
SELECT sequence<None
映射函数
函数 | 描述 |
---|---|
element_at(array, index) | 返回数组中给定(从1开始)索引的元素。如果索引为0,Spark会抛出错误。如果索引< 0,从最后一个元素访问到第一个元素。如果索引超过数组的长度并且`spark.sql.ansi.enabled`设置为false,则函数返回NULL。如果`spark.sql.ansi.enabled`设置为true,对于无效索引会抛出ArrayIndexOutOfBoundsException。 |
element_at(map, key) | 返回给定键的值。如果键不包含在映射中,则函数返回NULL。 |
map(key0, value0, key1, value1, ...) | 使用给定的键/值对创建一个映射。 |
map_concat(map, ...) | 返回所有给定映射的并集。 |
map_contains_key(map, key) | 如果映射包含该键,则返回true。 |
map_entries(map) | 返回给定映射中所有条目的无序数组。 |
map_from_arrays(keys, values) | 使用给定的键/值数组对创建一个映射。键中的所有元素不得为null。 |
map_from_entries(arrayOfEntries) | 返回从给定条目数组创建的映射。 |
map_keys(map) | 返回包含映射键的无序数组。 |
map_values(map) | 返回包含映射值的无序数组。 |
str_to_map(text[, pairDelim[, keyValueDelim]]) | 通过使用分隔符将文本拆分为键/值对后创建一个映射。默认分隔符是','对于`pairDelim`和':'对于`keyValueDelim`。`pairDelim`和`keyValueDelim`都被视为正则表达式。 |
try_element_at(array, index) | 返回数组中给定(从1开始)索引的元素。如果索引为0,Spark会抛出错误。如果索引< 0,从最后一个元素访问到第一个元素。如果索引超过数组的长度则函数始终返回NULL。 |
try_element_at(map, key) | 返回给定键的值。如果键不包含在映射中,函数始终返回NULL。 |
示例
-- 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|
+------------------------------+
-- 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}|
+-------------------+
-- 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|
+----------------------------------+
日期和时间戳函数
Function | 描述 |
---|---|
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) | 将 `timestamp` 转换为由日期格式 `fmt` 指定的字符串值。 |
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) | 返回日期/时间戳的月份中的日期。 |
dayofmonth(date) | 返回日期/时间戳的月份中的日期。 |
dayofweek(date) | 返回日期/时间戳的星期几(1 = 星期天,2 = 星期一,...,7 = 星期六)。 |
dayofyear(date) | 返回日期/时间戳的年份中的日期。 |
extract(field FROM source) | 提取日期/时间戳或间隔源的一部分。 |
from_unixtime(unix_time[, fmt]) | 返回 `unix_time` 在指定 `fmt` 中。 |
from_utc_timestamp(timestamp, timezone) | 给定一个像 '2017-07-14 02:40:00.0' 的时间戳,将其解释为 UTC 的时间,并将该时间呈现为给定时区的时间戳。例如,'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) | 返回日期/时间戳的月份部分。 |
months_between(timestamp1, timestamp2[, roundOff]) | 如果 `timestamp1` 晚于 `timestamp2`,则结果为正。如果 `timestamp1` 和 `timestamp2` 在同一天,或者都是月份的最后一天,则忽略时间。否则,基于每月31天计算差值,并四舍五入到8位数字,除非 roundOff=false。 |
next_day(start_date, day_of_week) | 返回晚于 `start_date` 的第一个日期,该日期以指定的方式命名。如果至少一个输入参数为 NULL,函数返回 NULL。当两个输入参数都不为 NULL 且 day_of_week 是无效输入时,如果 `spark.sql.ansi.enabled` 设置为 true,函数抛出 IllegalArgumentException,否则返回 NULL。 |
now() | 返回查询评估开始时的当前时间戳。 |
quarter(date) | 返回日期所在年份的季度,范围为 1 到 4。 |
second(timestamp) | 返回字符串/时间戳的秒部分。 |
session_window(time_column, gap_duration) | 根据指定时间戳列和间隔持续时间生成会话窗口。详见 '时间窗口的类型' 在结构化流指南文档中的详细解释和示例。 |
timestamp_micros(microseconds) | 根据自 UTC 纪元以来的微秒数创建时间戳。 |
timestamp_millis(milliseconds) | 根据自 UTC 纪元以来的毫秒数创建时间戳。 |
timestamp_seconds(seconds) | 根据自 UTC 纪元以来的秒数(可以是小数)创建时间戳。 |
to_date(date_str[, fmt]) | 使用 `fmt` 表达式解析 `date_str` 表达式为日期。无效输入返回 null。默认情况下,如果省略 `fmt`,则遵循日期的转换规则。 |
to_timestamp(timestamp_str[, fmt]) | 使用 `fmt` 表达式解析 `timestamp_str` 表达式为时间戳。无效输入返回 null。默认情况下,如果省略 `fmt`,则遵循时间戳的转换规则。结果数据类型与配置 `spark.sql.timestampType` 的值一致。 |
to_timestamp_ltz(timestamp_str[, fmt]) | 使用 `fmt` 表达式解析 `timestamp_str` 表达式为带有本地时区的时间戳。无效输入返回 null。默认情况下,如果省略 `fmt`,则遵循时间戳的转换规则。 |
to_timestamp_ntz(timestamp_str[, fmt]) | 使用 `fmt` 表达式解析 `timestamp_str` 表达式为不带时区的时间戳。无效输入返回 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) | 返回 `date`,日期部分被截断到格式模型 `fmt` 指定的单位。 |
try_to_timestamp(timestamp_str[, fmt]) | 使用 `fmt` 表达式解析 `timestamp_str` 表达式为时间戳。函数在无论 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]]) | 将行分为一个或多个时间窗口,给定一个指定时间戳列。窗口开始是包含的,但窗口结束是排除的,例如 12:05 将位于窗口 [12:05,12:10) 中,而不在 [12:00,12:05) 中。窗口可以支持微秒精度。不支持按月的窗口。详见 '事件时间上的窗口操作' 在结构化流指南文档中的详细解释和示例。 |
window_time(window_column) | 从时间/会话窗口列中提取时间值,该值可以用于窗口的事件时间值。提取的时间是 (window.end - 1),反映了聚合窗口的上限是排除的 - [start, end)。详见 '事件时间上的窗口操作' 在结构化流指南文档中的详细解释和示例。 |
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()|
+--------------+
| 2024-09-09|
+--------------+
-- current_date
SELECT current_date();
+--------------+
|current_date()|
+--------------+
| 2024-09-09|
+--------------+
SELECT current_date;
+--------------+
|current_date()|
+--------------+
| 2024-09-09|
+--------------+
-- current_timestamp
SELECT current_timestamp();
+--------------------+
| current_timestamp()|
+--------------------+
|2024-09-09 06:59:...|
+--------------------+
SELECT current_timestamp;
+--------------------+
| current_timestamp()|
+--------------------+
|2024-09-09 06:59:...|
+--------------------+
-- 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 );
+--------------------------------------------------+
|date_part(MONTH, INTERVAL YEAR TO MONTH)|
+--------------------------------------------------+
| 11|
+--------------------------------------------------+
SELECT date_part('MINUTE', INTERVAL DAY TO SECOND);
+---------------------------------------------------------------+
|date_part(MINUTE, INTERVAL DAY TO SECOND)|
+---------------------------------------------------------------+
| 55|
+---------------------------------------------------------------+
-- date_sub
SELECT date_sub(, 1);
+-----------------------+
|date_sub(2016-07-30, 1)|
+-----------------------+
| 2016-07-29|
+-----------------------+
-- date_trunc
SELECT date_trunc(, );
+-----------------------------------------+
|date_trunc(YEAR, 2015-03-05T09:32:05.359)|
+-----------------------------------------+
| 2015-01-01 00:00:00|
+-----------------------------------------+
SELECT date_trunc(, );
+---------------------------------------+
|date_trunc(MM, 2015-03-05T09:32:05.359)|
+---------------------------------------+
| 2015-03-01 00:00:00|
+---------------------------------------+
SELECT date_trunc(, );
+---------------------------------------+
|date_trunc(DD, 2015-03-05T09:32:05.359)|
+---------------------------------------+
| 2015-03-05 00:00:00|
+---------------------------------------+
SELECT date_trunc(, );
+-----------------------------------------+
|date_trunc(HOUR, 2015-03-05T09:32:05.359)|
+-----------------------------------------+
| 2015-03-05 09:00:00|
+-----------------------------------------+
SELECT date_trunc(, );
+---------------------------------------------------+
|date_trunc(MILLISECOND, 2015-03-05T09:32:05.123456)|
+---------------------------------------------------+
| 2015-03-05 09:32:...|
+---------------------------------------------------+
-- dateadd
SELECT dateadd(, 1);
+-----------------------+
|date_add(2016-07-30, 1)|
+-----------------------+
| 2016-07-31|
+-----------------------+
-- datediff
SELECT datediff(, );
+--------------------------------+
|datediff(2009-07-31, 2009-07-30)|
+--------------------------------+
| 1|
+--------------------------------+
SELECT datediff(, );
+--------------------------------+
|datediff(2009-07-30, 2009-07-31)|
+--------------------------------+
| -1|
+--------------------------------+
-- datepart
SELECT datepart(, TIMESTAMP );
+----------------------------------------------------------+
|datepart(YEAR FROM TIMESTAMP )|
+----------------------------------------------------------+
| 2019|
+----------------------------------------------------------+
SELECT datepart(, timestamp);
+----------------------------------------------------------+
|datepart(week, FROM TIMESTAMP )|
+----------------------------------------------------------+
| 33|
+----------------------------------------------------------+
SELECT datepart(, DATE);
+------------------------------------+
|datepart(doy FROM DATE )|
+------------------------------------+
| 224|
+------------------------------------+
SELECT datepart(, timestamp);
+------------------------------------------------------------+
|datepart(SECONDS FROM TIMESTAMP )|
+------------------------------------------------------------+
| 1.000001|
+------------------------------------------------------------+
SELECT datepart(, interval 5 days 3 hours 7 minutes);
+----------------------------------------------------+
|datepart(days FROM INTERVAL DAY TO MINUTE)|
+----------------------------------------------------+
| 5|
+----------------------------------------------------+
SELECT datepart(, interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+----------------------------------------------------------------+
|datepart(seconds, INTERVAL HOUR TO SECOND)|
+----------------------------------------------------------------+
| 30.001001|
+----------------------------------------------------------------+
SELECT datepart(, INTERVAL YEAR TO MONTH);
+-----------------------------------------------------+
|datepart(MONTH FROM INTERVAL YEAR TO MONTH)|
+-----------------------------------------------------+
| 11|
+-----------------------------------------------------+
SELECT datepart(, INTERVAL DAY TO SECOND);
+------------------------------------------------------------------+
|datepart(MINUTE, INTERVAL DAY TO SECOND)|
+------------------------------------------------------------------+
| 55|
+------------------------------------------------------------------+
-- day
SELECT day();
+---------------+
|day(2009-07-30)|
+---------------+
| 30|
+---------------+
-- dayofmonth
SELECT dayofmonth();
+----------------------+
|dayofmonth(2009-07-30)|
+----------------------+
| 30|
+----------------------+
-- dayofweek
SELECT dayofweek();
+---------------------+
|dayofweek(2009-07-30)|
+---------------------+
| 5|
+---------------------+
-- dayofyear
SELECT dayofyear();
+---------------------+
|dayofyear(2016-04-09)|
+---------------------+
| 100|
+---------------------+
-- extract
SELECT extract(YEAR FROM TIMESTAMP );
+---------------------------------------------------------+
|extract(YEAR FROM TIMESTAMP )|
+---------------------------------------------------------+
| 2019|
+---------------------------------------------------------+
SELECT datepart(, timestamp);
+---------------------------------------------------------+
|datepart(week, FROM TIMESTAMP )|
+---------------------------------------------------------+
| 33|
+---------------------------------------------------------+
SELECT datepart(, DATE);
+------------------------------------+
|datepart(doy FROM DATE )|
+------------------------------------+
| 224|
+------------------------------------+
SELECT datepart(, timestamp);
+------------------------------------------------------------+
|datepart(SECONDS, INTERVAL HOUR TO SECOND)|
+------------------------------------------------------------+
| 30.001001|
+------------------------------------------------------------+
SELECT datepart(, interval 5 days 3 hours 7 minutes<span class="pNone
JSON 函数
Function | 描述 |
---|---|
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 字符串 |
示例
-- 从_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>>' );
+--------------------------------------------------------------------------------------------------------+
|from_json({"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]})|
+--------------------------------------------------------------------------------------------------------+
| {Alice, [{Bob, 1}...|
+--------------------------------------------------------------------------------------------------------+
-- 获取_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();
+----------------------------------+
|json_object_keys({"key": "value"})|
+----------------------------------+
| [key]|
+----------------------------------+
SELECT json_object_keys();
+--------------------------------------------------------+
|json_object_keys({"f1":"abc","f2":{"f3":"a", "f4":"b"}})|
+--------------------------------------------------------+
| [f1, f2]|
+--------------------------------------------------------+
-- json_tuple
SELECT json_tuple(, , );
+---+---+
| c0| c1|
+---+---+
| 1| 2|
+---+---+
-- schema_of_json
SELECT schema_of_json();
+---------------------------+
|schema_of_json([{"col":0}])|
+---------------------------+
| ARRAY<STRUCT<col:...|
+---------------------------+
SELECT schema_of_json(, map(, ));
+----------------------------+
|schema_of_json([{"col":01}])|
+----------------------------+
| ARRAY<STRUCT<col:...|
+----------------------------+
-- 转_json
SELECT to_json(named_struct(, 1, , 2));
+---------------------------------+
|to_json(named_struct(a, 1, b, 2))|
+---------------------------------+
| {"a":1,"b":2}|
+---------------------------------+
SELECT to_json(named_struct(, to_timestamp(, )), map( ));
+-----------------------------------------------------------------+
|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}]|
+-------------------------+
数学函数
函数 | 描述 |
---|---|
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) | 返回正 x 轴和由坐标(`exprX`, `exprY`)给出的点之间的弧度角,就像由 `java.lang.Math.atan2` 计算的那样。 |
atanh(expr) | 返回 `expr` 的反双曲正切。 |
bin(expr) | 返回长整型值 `expr` 的二进制字符串表示。 |
bround(expr, d) | 返回 `expr` 四舍五入到 `d` 位小数,使用 HALF_EVEN 取整模式。 |
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。结果被转换为长整型。 |
e() | 返回欧拉数 e。 |
exp(expr) | 返回 e 的 `expr` 次幂。 |
expm1(expr) - 返回 exp(`expr`) | 1. |
factorial(expr) | 返回 `expr` 的阶乘。`expr` 是 [0..20]。否则返回 null。 |
floor(expr[, scale]) | 返回不大于 `expr` 的向下取整后的最大值。可以指定可选的 `scale` 参数来控制取整行为。 |
greatest(expr, ...) | 返回所有参数中的最大值,跳过 null 值。 |
hex(expr) | 将 `expr` 转换为十六进制。 |
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 mod expr2 | 返回 `expr1`/`expr2` 的余数。 |
negative(expr) | 返回 `expr` 的取反值。 |
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) | 返回 `expr` 四舍五入到 `d` 位小数,使用 HALF_UP 取整模式。 |
sec(expr) | 返回 `expr` 的割余弦,就像由 `1/java.lang.Math.cos` 计算的那样。 |
shiftleft(base, expr) | 位运算左移。 |
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_multiply(expr1, expr2) | 返回 `expr1`*`expr2`,在溢出时结果为 null。接受的输入类型与 `*` 运算符相同。 |
try_subtract(expr1, expr2) | 返回 `expr1`-`expr2`,在溢出时结果为 null。接受的输入类型与 `-` 运算符相同。 |
unhex(expr) | 将十六进制的 `expr` 转换为二进制。 |
width_bucket(value, min_value, max_value, num_bucket) | 返回 `value` 在具有 `num_bucket` 桶的等宽直方图中将被分配的桶号,范围在 `min_value` 到 `max_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(None
字符串函数
函数 | 描述 |
---|---|
ascii(str) | 返回 `str` 第一个字符的数值。 |
base64(bin) | 将参数从二进制 `bin` 转换为 base 64 字符串。 |
bit_length(expr) | 返回字符串数据的位长度或二进制数据的位数。 |
btrim(str) | 删除 `str` 的前导和尾随空格字符。 |
btrim(str, trimStr) | 删除 `str` 的前导和尾随 `trimStr` 字符。 |
char(expr) | 返回具有与 `expr` 二进制等效的 ASCII 字符。如果 n 大于 256,则结果等价于 chr(n % 256) |
char_length(expr) | 返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括尾随空格。二进制数据的长度包括二进制零。 |
character_length(expr) | 返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括尾随空格。二进制数据的长度包括二进制零。 |
chr(expr) | 返回具有与 `expr` 二进制等效的 ASCII 字符。如果 n 大于 256,则结果等价于 chr(n % 256) |
concat_ws(sep[, str | array(str)]+) | 返回由 `sep` 分隔的字符串的连接,跳过 null 值。 |
contains(left, right) | 返回布尔值。如果在 left 中找到 right,则值为 True。 如果任一输入表达式为 NULL,则返回 NULL。否则,返回 False。 left 和 right 必须为 STRING 或 BINARY 类型。 |
decode(bin, charset) | 使用第二个参数字符集解码第一个参数。 |
decode(expr, search, result [, search, result ] ... [, default]) | 按顺序将 expr 与每个搜索值进行比较。如果 expr 等于某个搜索值,decode 返回相应的结果。如果未找到匹配项,则返回默认值。如果省略默认值,则返回 null。 |
elt(n, input1, input2, ...) | 返回第 `n` 个输入,例如,当 `n` 为 2 时返回 `input2`。 如果索引超过数组长度且 `spark.sql.ansi.enabled` 设置为 false,则函数返回 NULL。如果 `spark.sql.ansi.enabled` 设置为 true,则对无效索引抛出 ArrayIndexOutOfBoundsException。 |
encode(str, charset) | 使用第二个参数字符集编码第一个参数。 |
endswith(left, right) | 返回布尔值。如果 left 以 right 结尾,则值为 True。 如果任一输入表达式为 NULL,则返回 NULL。否则,返回 False。 left 和 right 必须为 STRING 或 BINARY 类型。 |
find_in_set(str, str_array) | 返回给定字符串 (`str`) 在逗号分隔列表 (`str_array`) 中的索引(基于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) | 返回 `substr` 在 `str` 中首次出现的 (1-based) 索引。 |
lcase(str) | 返回 `str`,所有字符均转换为小写。 |
left(str, len) | 返回字符串 `str` 中最左侧的 `len`(`len` 可以是字符串类型)个字符,如果 `len` 小于或等于 0,则结果为空字符串。 |
len(expr) | 返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括尾随空格。二进制数据的长度包括二进制零。 |
length(expr) | 返回字符串数据的字符长度或二进制数据的字节数。字符串数据的长度包括尾随空格。二进制数据的长度包括二进制零。 |
levenshtein(str1, str2[, threshold]) | 返回两个给定字符串之间的 Levenshtein 距离。如果设置了阈值并且距离超过该值,则返回 -1。 |
locate(substr, str[, pos]) | 返回 `substr` 在 `str` 中首次出现的位置,位置在 `pos` 之后。 给定的 `pos` 和返回值皆为基于 1。 |
lower(str) | 返回 `str`,所有字符均转换为小写。 |
lpad(str, len[, pad]) | 返回 `str`,在左侧用 `pad` 填充至长度 `len`。 如果 `str` 长于 `len`,则返回值缩短为 `len` 个字符或字节。 如果未指定 `pad`,则如果它是字符字符串,`str` 将用空格字符在左侧填充,如果它是字节序列,则用零填充。 |
ltrim(str) | 删除 `str` 的前导空格字符。 |
luhn_check(str ) | 检查数字字符串是否符合 Luhn 算法。 此校验和函数广泛应用于信用卡号和政府身份证号,以区分有效数字和输入错误的数字。 |
mask(input[, upperChar, lowerChar, digitChar, otherChar]) | 掩盖给定的字符串值。 此函数用 'X' 或 'x' 替换字符,用 'n' 替换数字。 这对于创建去除敏感信息的表副本可能会很有用。 |
octet_length(expr) | 返回字符串数据的字节长度或二进制数据的字节数。 |
overlay(input, replace, pos[, len]) | 用长度为 `len` 的 `replace` 替换从 `pos` 开始的 `input`。 |
position(substr, str[, pos]) | 返回 `substr` 在 `str` 中首次出现的位置,位置在 `pos` 之后。 给定的 `pos` 和返回值皆为基于 1。 |
printf(strfmt, obj, ...) | 从 printf 风格的格式字符串返回格式化字符串。 |
regexp_count(str, regexp) | 返回正则表达式模式 `regexp` 在字符串 `str` 中匹配的次数。 |
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]) | 用 `rep` 替换所有与 `regexp` 匹配的 `str` 子字符串。 |
regexp_substr(str, regexp) | 返回匹配字符串 `str` 内正则表达式 `regexp` 的子字符串。如果未找到正则表达式,则结果为 null。 |
repeat(str, n) | 返回重复给定字符串值 n 次的字符串。 |
replace(str, search[, replace]) | 用 `replace` 替换所有与 `search` 匹配的部分。 |
right(str, len) | 返回字符串 `str` 中最右侧的 `len`(`len` 可以是字符串类型)个字符,如果 `len` 小于或等于 0,则结果为空字符串。 |
rpad(str, len[, pad]) | 返回 `str`,在右侧用 `pad` 填充至长度 `len`。 如果 `str` 长于 `len`,则返回值缩短为 `len` 个字符。 如果未指定 `pad`,则如果它是字符字符串,`str` 将在右侧用空格字符填充,如果它是二进制字符串,则用零填充。 |
rtrim(str) | 删除 `str` 的尾随空格字符。 |
sentences(str[, lang, country]) | 将 `str` 拆分为单词的数组。 |
soundex(str) | 返回字符串的 Soundex 代码。 |
space(n) | 返回一个由 `n` 个空格组成的字符串。 |
split(str, regex, limit) | 根据匹配 `regex` 的出现位置拆分 `str`,并返回长度最多为 `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) | 返回 `str` 中在 `count` 次出现之前的子字符串 `delim`。 如果 `count` 为正数,则返回最终分隔符左侧的所有内容(从左计数)。如果 `count` 为负数,则返回最终分隔符右侧的所有内容(从右计数)。函数 substring_index 在搜索 `delim` 时执行区分大小写的匹配。 |
to_binary(str[, fmt]) | 根据提供的 `fmt` 将输入 `str` 转换为二进制值。 `fmt` 可以是 "hex"、"utf-8"、"utf8" 或 "base64" 的不区分大小写的字符串文字。 如果省略 `fmt`,则默认的二进制格式为 "hex"。 如果至少有一个输入参数为 NULL,则该函数返回 NULL。 |
to_char(numberExpr, formatExpr) | 根据 `formatExpr` 将 `numberExpr` 转换为字符串。 如果转换失败,则抛出异常。格式可以包含以下字符,大小写不敏感: '0' 或 '9': 指定预期数字范围在 0 到 9 之间。格式字符串中的 0 或 9 序列与输入值中的数字序列匹配,生成的结果字符串长度与格式字符串中的相应序列长度相同。如果 0/9 序列包含的数字多于十进制值中匹配部分的数字,结果字符串用零左侧填充,否则用空格填充。 '.' 或 'D': 指定小数点的位置(可选,仅允许一次)。 ',' 或 'G': 指定分组(千位)分隔符 (,) 的位置。每个分组分隔符的左右必须有 0 或 9。 '$': 指定 $ 货币符号的位置。此字符仅可指定一次。 'S' 或 'MI': 指定 '-' 或 '+' 符号的位置(可选,仅允许在格式字符串的开头或结尾指定一次)。请注意,'S' 对于正值打印 '+',但 'MI' 打印空格。 'PR': 仅允许在格式字符串的末尾;指定如果输入值为负数,结果字符串将用尖括号包裹。 ('<1>'). |
to_number(expr, fmt) | 根据字符串格式 `fmt` 将字符串 'expr' 转换为数字。 如果字符串 'expr' 不符合预期格式,则返回 NULL。格式遵循与 to_number 函数相同的语义。 |
to_varchar(numberExpr, formatExpr) | 根据 `formatExpr` 将 `numberExpr` 转换为字符串。 如果转换失败,则抛出异常。格式可以包含以下字符,大小写不敏感: '0' 或 '9': 指定预期数字范围在 0 到 9 之间。格式字符串中的 0 或 9 序列与输入值中的数字序列匹配,生成的结果字符串长度与格式字符串中的相应序列长度相同。如果 0/9 序列包含的数字多于十进制值中匹配部分的数字,结果字符串用零左侧填充,否则用空格填充。 '.' 或 'D': 指定小数点的位置(可选,仅允许一次)。 ',' 或 'G': 指定分组(千位)分隔符 (,) 的位置。每个分组分隔符的左右必须有 0 或 9。 '$': 指定 $ 货币符号的位置。此字符仅可指定一次。 'S' 或 'MI': 指定 '-' 或 '+' 符号的位置(可选,仅允许在格式字符串的开头或结尾指定一次)。请注意,'S' 对于正值打印 '+',但 'MI' 打印空格。 'PR': 仅允许在格式字符串的末尾;指定结果字符串将在输入值为负时用尖括号包裹。 ('<1>'). |
translate(input, from, to) | 通过用 `to` 字符串中的对应字符替换 `from` 字符串中存在的字符来翻译 `input` 字符串。 |
trim(str) | 删除 `str` 的前导和尾随空格字符。 |
trim(BOTH FROM str) | 删除 `str` 的前导和尾随空格字符。 |
trim(LEADING FROM str) | 删除 `str` 的前导空格字符。 |
trim(TRAILING FROM str) | 删除 `str` 的尾随空格字符。 |
trim(trimStr FROM str) | 删除 `str` 的前导和尾随 `trimStr` 字符。 |
trim(BOTH trimStr FROM str) | 删除 `str` 的前导和尾随 `trimStr` 字符。 |
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) | 根据字符串格式 `fmt` 将字符串 'expr' 转换为数字。 如果字符串 'expr' 不符合预期格式,则返回 NULL。格式遵循与 to_number 函数相同的语义。 |
ucase(str) | 返回 `str`,所有字符均转换为大写。 |
unbase64(str) | 将参数从 base 64 字符串 `str` 转换为二进制。 |
upper(str) | 返回 `str`,所有字符均转换为大写。 |
示例
-- 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();
+----------------------------+
|character_length(Spark SQL )|
+----------------------------+
| 10|
+----------------------------+
SELECT character_length(x);
+---------------------------------------+
|character_length(X)|
+---------------------------------------+
| 9|
+---------------------------------------+
SELECT CHAR_LENGTH();
+-----------------------+
|char_length(Spark SQL )|
+-----------------------+
| 10|
+-----------------------+
SELECT CHARACTER_LENGTH();
+----------------------------+
|character_length(Spark SQL )|
+----------------------------+
| 10|
+----------------------------+
-- levenshtein
SELECT levenshtein(, );
+----------------------------+
|levenshtein(kitten, sitting)|
+----------------------------+
| 3|
+----------------------------+
SELECT levenshtein(, , 2);
+-------------------------------+
|levenshtein(kitten, sitting, 2)|
+-------------------------------+
| -1|
+-------------------------------+
-- locate
SELECT locate(
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
| 4|
+-------------------------+
SELECT locate( 5);
+-------------------------+
|locate(bar, foobarbar, 5)|
+-------------------------+
| 7|
+-------------------------+
SELECT POSITION(IN
+-------------------------+
|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|
+------------------------------------+
-- regexp_count
SELECT regexp_count(, );
+------------------------------------------------------------------------------+
|regexp_count(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)|
+------------------------------------------------------------------------------+
| 2|
+------------------------------------------------------------------------------+
SELECT regexp_count(, );
+--------------------------------------------------+
|regexp_count(abcdefghijklmnopqrstuvwxyz, a-z]{3})|
+--------------------------------------------------+
| 8|
+--------------------------------------------------+
-- regexp_extract
SELECT regexp_extract(, , 1);
+---------------------------------------+
|regexp_extract(100-200, (\d+)-(\d+), 1)|
+---------------------------------------+
| 100|
+---------------------------------------+
-- regexp_extract_all
SELECT regexp_extract_all(, , 1);
+----------------------------------------------------+
|regexp_extract_all(100-200, 300-400, (\d+)-(\d+), 1)|
+----------------------------------------------------+
| [100, 300]|
+----------------------------------------------------+
-- regexp_instr
SELECT regexp_instr(, );
+----------------------------------------------+
|regexp_instr(user@spark.apache.org, @[^.]*, 0)|
+----------------------------------------------+
| 5|
+----------------------------------------------+
-- regexp_replace
SELECT regexp_replace(, , );
+--------------------------------------+
|regexp_replace(100-200, (\d+), num, 1)|
+--------------------------------------+
| num-num|
+--------------------------------------+
-- right
SELECT right(, 3);
+-------------------+
|right(Spark SQL, 3)|
+-------------------+
| SQL|
+-------------------+
-- rpad
SELECT rpad(, 5, );
+---------------+
|rpad(hi, 5, ??)|
+---------------+
| hi???|
+---------------+
SELECT rpad(, 1, );
+---------------+
|rpad(hi, 1, ??)|
+---------------+
| h|
+---------------+
SELECT rpad(, 5);
+--------------+
|rpad(hi, 5, )|
+--------------+
| hi|
+--------------+
SELECT hex(rpad(unhex(), 5));
+--------------------------------+
|hex(rpad(unhex(aabb), 5, X))|
+--------------------------------+
| 000000AABB|
+--------------------------------+
SELECT hex(rpad(unhex(), 5, unhex()));
+--------------------------------------+
|hex(rpad(unhex(aabb), 5, unhex(1122)))|
+--------------------------------------+
| AABB112211|
+--------------------------------------+
-- rtrim
SELECT rtrim();
+----------------------+
|rtrim( SparkSQL )|
+----------------------+
| SparkSQL|
+----------------------+
-- sentences
SELECT sentences();
+--------------------------------------+
|sentences(Hi there! Good morning., , )|
+--------------------------------------+
| [[Hi, there], [Go...|
+--------------------------------------+
-- soundex
SELECT soundex();
+---------------+
|soundex(Miller)|
+---------------+
| M460|
+---------------+
-- space
SELECT concat(space(2), );
+-------------------+
|concat(space(2), 1)|
+-------------------+
| 1|
+-------------------+
-- split
SELECT split(, );
+--------------------------------+
|split(oneAtwoBthreeC, [ABC], -1)|
+--------------------------------+
| [one, two, three, ]|
+--------------------------------+
SELECT split(, , 2);
+-------------------------------+
|split(oneAtwoBthreeC, [ABC], 2)|
+-------------------------------+
| [one, twoBthreeC]|
+-------------------------------+
-- split_part
SELECT split_part(, , 3);
+--------------------------+
|split_part(11.12.13, 3)|
+--------------------------+
| 13|
+--------------------------+
-- startswith
SELECT startswith(, );
+----------------------------+
|startswith(Spark SQL, Spark)|
+----------------------------+
| true|
+----------------------------+
SELECT startswith(, );
+--------------------------+
|startswith(Spark SQL, SQL)|
+--------------------------+
| false|
+--------------------------+
SELECT startswith(null);
+---------------------------+
|startswith(Spark SQL, NULL)|
+---------------------------+
| NULL|
+---------------------------+
SELECT startswith(x, x);
+------------------------------------------------+
|startswith(X, X)|
+------------------------------------------------+
| true|
+------------------------------------------------+
SELECT startswith(x, x);
+--------------------------------------------+
|startswith(X, X)|
+--------------------------------------------+
| false|
+--------------------------------------------+
-- substr
SELECT substr(, 5);
+--------------------------------+
|substr(Spark SQL, 5, 2147483647)|
+--------------------------------+
| k SQL|
+--------------------------------+
SELECT substr(, -3);
+---------------------------------+
|substr(Spark SQL, -3, 2147483647)|
+---------------------------------+
| SQL|
+---------------------------------+
SELECT substr( FROM 5);
+-----------------------------------+
|substring(Spark SQL, 5, 2147483647)|
+-----------------------------------+
| k SQL|
+-----------------------------------+
SELECT substr( FROM -3);
+------------------------------------+
|substring(Spark SQL, -3, 2147483647)|
+------------------------------------+
| SQL|
+------------------------------------+
SELECT substring( FROM 5 FOR 1);
+--------------------------+
|substring(Spark SQL, 5, 1)|
+--------------------------+
| k|
+--------------------------+
SELECT substring(encode</None
条件函数
函数 | 描述 |
---|---|
coalesce(expr1, expr2, ...) | 返回第一个存在的非空参数。如果不存在,则返回null。 |
if(expr1, expr2, expr3) | 如果 `expr1` 计算为真,则返回 `expr2`;否则返回 `expr3`。 |
ifnull(expr1, expr2) | 如果 `expr1` 为null,则返回 `expr2`,否则返回 `expr1`。 |
nanvl(expr1, expr2) | 如果 `expr1` 不是NaN,则返回 `expr1`,否则返回 `expr2`。 |
nullif(expr1, expr2) | 如果 `expr1` 等于 `expr2`,则返回null,否则返回 `expr1`。 |
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`。 |
示例
-- 选择第一个非空值
SELECT coalesce(NULL, 1, NULL);
+-----------------------+
|coalesce(NULL, 1, NULL)|
+-----------------------+
| 1|
+-----------------------+
-- 如果
SELECT if(1 < 2, 'a', 'b');
+-------------------+
|(IF((1 < 2), a, b))|
+-------------------+
| a|
+-------------------+
-- 如果为空
SELECT ifnull(NULL, array('2'));
+----------------------+
|ifnull(NULL, array(2))|
+----------------------+
| [2]|
+----------------------+
-- 替代空值
SELECT nanvl(cast('NaN' as double), 123);
+-------------------------------+
|nanvl(CAST(NaN AS DOUBLE), 123)|
+-------------------------------+
| 123.0|
+-------------------------------+
-- 如果相等则返回空
SELECT nullif(2, 2);
+------------+
|nullif(2, 2)|
+------------+
| NULL|
+------------+
-- 替代值
SELECT nvl(NULL, array('2'));
+-------------------+
|nvl(NULL, array(2))|
+-------------------+
| [2]|
+-------------------+
-- 第一个参数为NULL时返回第二个参数,否则返回第三个参数
SELECT nvl2(NULL, 2, 1);
+----------------+
|nvl2(NULL, 2, 1)|
+----------------+
| 1|
+----------------+
-- 条件选择
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|
+--------------------------------------------------+
按位函数
函数 | 描述 |
---|---|
expr1 & expr2 | 返回`expr1`和`expr2`的按位与结果。 |
expr1 ^ expr2 | 返回`expr1`和`expr2`的按位异或结果。 |
bit_count(expr) | 返回参数expr中设置的位数作为无符号64位整数,如果参数为NULL则返回NULL。 |
bit_get(expr, pos) | 返回指定位置的位的值(0或1)。 位置从右到左编号,从零开始。 位置参数不能为负。 |
getbit(expr, pos) | 返回指定位置的位的值(0或1)。 位置从右到左编号,从零开始。 位置参数不能为负。 |
shiftright(base, expr) | 按位(带符号)右移。 |
shiftrightunsigned(base, expr) | 按位无符号右移。 |
expr1 | expr2 | 返回`expr1`和`expr2`的按位或结果。 |
~ expr | 返回`expr`的按位非结果。 |
示例
-- &
SELECT 3 & 5;
+-------+
|(3 & 5)|
+-------+
| 1|
+-------+
-- ^
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|
+-------------+
-- shiftright
SELECT shiftright(4, 1);
+----------------+
|shiftright(4, 1)|
+----------------+
| 2|
+----------------+
-- shiftrightunsigned
SELECT shiftrightunsigned(4, 1);
+------------------------+
|shiftrightunsigned(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`。 |
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`。 |
示例
-- 转换
SELECT cast('10' as int);
+---------------+
|CAST(10 AS INT)|
+---------------+
| 10|
+---------------+
谓词函数
函数 | 描述 |
---|---|
! expr | 逻辑非。 |
expr1 < expr2 | 如果 `expr1` 小于 `expr2`,则返回真。 |
expr1 <= expr2 | 如果 `expr1` 小于或等于 `expr2`,则返回真。 |
expr1 <=> expr2 | 对于非空操作数,返回与 EQUAL(=) 操作符相同的结果,但如果都是空,则返回真;如果其中一个为空,则返回假。 |
expr1 = expr2 | 如果 `expr1` 等于 `expr2`,则返回真,否则返回假。 |
expr1 == expr2 | 如果 `expr1` 等于 `expr2`,则返回真,否则返回假。 |
expr1 > expr2 | 如果 `expr1` 大于 `expr2`,则返回真。 |
expr1 >= expr2 | 如果 `expr1` 大于或等于 `expr2`,则返回真。 |
expr1 and expr2 | 逻辑与。 |
str ilike pattern[ ESCAPE escape] | 如果 str 匹配 `pattern`(不区分大小写),则返回真;如果任何参数为 null,则返回 null,否则返回假。 |
expr1 in(expr2, expr3, ...) | 如果 `expr` 等于任何 valN,则返回真。 |
isnan(expr) | 如果 `expr` 是 NaN,则返回真,否则返回假。 |
isnotnull(expr) | 如果 `expr` 不是 null,则返回真,否则返回假。 |
isnull(expr) | 如果 `expr` 是 null,则返回真,否则返回假。 |
str like pattern[ ESCAPE escape] | 如果 str 匹配 `pattern`,则返回真;如果任何参数为 null,则返回 null,否则返回假。 |
not expr | 逻辑非。 |
expr1 or expr2 | 逻辑或。 |
regexp(str, regexp) | 如果 `str` 匹配 `regexp`,则返回真,否则返回假。 |
regexp_like(str, regexp) | 如果 `str` 匹配 `regexp`,则返回真,否则返回假。 |
rlike(str, regexp) | 如果 `str` 匹配 `regexp`,则返回真,否则返回假。 |
示例
-- !
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))|
+--------------------------------------------------------------+
| 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|
+----------------+
-- ilike
SELECT ilike('Spark', '_Park');
+-------------------+
|ilike(Spark, _Park)|
+-------------------+
| 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 '\%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|
+----------------+
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 '\%SystemDrive\%\\\\Users%';
+-----------------------------------------------------+
|%SystemDrive%\USERS\John, LIKE \%SystemDrive\%\\Users%)|
+-----------------------------------------------------+
| true|
+-----------------------------------------------------+
SELECT '%SystemDrive%/Users/John' like '/%SystemDrive/%//Users%' ESCAPE ;
+-----------------------------------------------------+
|%SystemDrive%/Users/John LIKE /%SystemDrive/%//Users%|
+-----------------------------------------------------+
| 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', );
+--------------------------------------------------------+
|REGEXP(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+--------------------------------------------------------+
| true|
+--------------------------------------------------------+
SET spark.sql.parser.escapedStringLiterals=false;
+--------------------+-----+
| key|value|
+--------------------+-----+
|spark.sql.parser....|false|
+--------------------+-----+
SELECT regexp_like('%SystemDrive%\Users\John', );
+-------------------------------------------------------------+
|REGEXP_LIKE(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+-------------------------------------------------------------+
| true|
+-------------------------------------------------------------+
SET spark.sql.parser.escapedStringLiterals=false;
+--------------------+-----+
| key|value|
+--------------------+-----+
|spark.sql.parser....|false|
+--------------------+-----+
SELECT rlike('%SystemDrive%\Users\John', );
+-------------------------------------------------------+
|RLIKE(%SystemDrive%\Users\John, %SystemDrive%\\Users.*)|
+-------------------------------------------------------+
| true|
+-------------------------------------------------------+
CSV 函数
函数 | 描述 |
---|---|
from_csv(csvStr, schema[, options]) | 返回一个包含给定 `csvStr` 和 `schema` 的结构值。 |
schema_of_csv(csv[, options]) | 返回CSV字符串的DDL格式的模式。 |
to_csv(expr[, options]) | 返回一个包含给定结构值的CSV字符串 |
示例
-- 从 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...|
+--------------------+
-- CSV 的模式
SELECT schema_of_csv('1,abc');
+--------------------+
|schema_of_csv(1,abc)|
+--------------------+
|STRUCT<_c0: INT, ...|
+--------------------+
-- 转换为 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|
+----------------------------------------------------------------+
杂项函数
函数 | 描述 |
---|---|
aes_decrypt(expr, key[, mode[, padding[, aad]]]) | 返回使用 AES 在 `mode` 下和 `padding` 解密的 `expr` 的值。 支持长度为 16、24 和 32 位的密钥。支持的 (`mode`, `padding`) 组合为 ('ECB', 'PKCS'), ('GCM', 'NONE') 和 ('CBC', 'PKCS')。 可选的附加认证数据 (AAD) 仅在 GCM 中支持。如果在加密时提供,则必须在解密时提供相同的 AAD 值。 默认模式为 GCM。 |
aes_encrypt(expr, key[, mode[, padding[, iv[, aad]]]]) | 返回使用 AES 在给定 `mode` 和指定 `padding` 下加密的 `expr` 的值。 支持长度为 16、24 和 32 位的密钥。支持的 (`mode`, `padding`) 组合为 ('ECB', 'PKCS'), ('GCM', 'NONE') 和 ('CBC', 'PKCS')。 可选的初始化向量 (IVs) 仅在 CBC 和 GCM 模式中支持。这些必须是 CBC 的 16 字节和 GCM 的 12 字节。如果未提供,将生成一个随机向量并将其添加到输出的开头。 可选的附加认证数据 (AAD) 仅在 GCM 中支持。如果在加密时提供,则必须在解密时提供相同的 AAD 值。 默认模式为 GCM。 |
assert_true(expr) | 如果 `expr` 不是 true,则抛出异常。 |
bitmap_bit_position(child) | 返回给定输入子表达式的位位置。 |
bitmap_bucket_number(child) | 返回给定输入子表达式的桶编号。 |
bitmap_count(child) | 返回子位图中设置的位数。 |
current_catalog() | 返回当前目录。 |
current_database() | 返回当前数据库。 |
current_schema() | 返回当前数据库。 |
current_user() | 当前执行上下文的用户名。 |
equal_null(expr1, expr2) | 对于非 null 操作数返回与 EQUAL(=) 运算符相同的结果, 但如果两个都是 null,则返回 true,如果其中一个是 null,则返回 false。 |
hll_sketch_estimate(expr) | 根据 Datasketches HllSketch 的二进制表示返回唯一值的估计数量。 |
hll_union(first, second, allowDifferentLgConfigK) | 合并两个 Datasketches HllSketch 对象的二进制表示,使用 Datasketches Union 对象。 将 allowDifferentLgConfigK 设置为 true 以允许合并具有不同 lgConfigK 值的草图(默认为 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 ..]]) | 使用反射调用方法。 |
spark_partition_id() | 返回当前分区 ID。 |
try_aes_decrypt(expr, key[, mode[, padding[, aad]]]) | 这是 `aes_decrypt` 的特殊版本,执行相同的操作,但如果无法执行解密,则返回 NULL 值而不是抛出错误。 |
typeof(expr) | 返回输入的数据类型的 DDL 格式字符串。 |
user() | 当前执行上下文的用户名。 |
uuid() | 返回一个通用唯一标识符(UUID)字符串。值作为标准的 UUID 36 字符串返回。 |
version() | 返回 Spark 版本。字符串包含 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, , ))|
+-----------------------------------------------------------+
| 9614413752042C234...|
+-----------------------------------------------------------+
SELECT hex(aes_encrypt('Spark SQL', '0000111122223333', 'GCM'));
+---------------------------------------------------------------+
|hex(aes_encrypt(Spark SQL, 0000111122223333, GCM, DEFAULT, , ))|
+---------------------------------------------------------------+
| AA9594C51312A7113...|
+---------------------------------------------------------------+
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, , ))|
+---------------------------------------------------------------------+
| xeNc/BK93l2gtRIEH...|
+---------------------------------------------------------------------+
SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop12345678ABCDEFGH', 'CBC', 'DEFAULT', unhex()));
+---------------------------------------------------------------------------------------------------------------------+
|base64(aes_encrypt(Spark, abcdefghijklmnop12345678ABCDEFGH, CBC, DEFAULT, unhex(00000000000000000000000000000000), ))|
+---------------------------------------------------------------------------------------------------------------------+
| AAAAAAAAAAAAAAAAA...|
+---------------------------------------------------------------------------------------------------------------------+
SELECT base64(aes_encrypt('Spark', 'abcdefghijklmnop12345678ABCDEFGH', 'GCM', 'DEFAULT', unhex(), ));
+------------------------------------------------------------------------------------------------------------------------------------------------+
|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 );
+---------------------+
|bitmap_count(X)|
+---------------------+
| 16|
+---------------------+
SELECT bitmap_count(X );
+-------------------+
|bitmap_count(X)|
+-------------------+
| 0|
+-------------------+
-- current_catalog
SELECT current_catalog();
+-----------------+
|current_catalog()|
+-----------------+
| spark_catalog|
+-----------------+
-- current_database
SELECT current_database();
+------------------+
|current_database()|
+------------------+
| default|
+------------------+
-- current_schema
SELECT current_schema();
+------------------+
|current_database()|
+------------------+
| default|
+------------------+
-- current_user
SELECT current_user();
+--------------+
|current_user()|
+--------------+
| spark-rm|
+--------------+
-- 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|
+----------------------+
-- 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)|
+---------------------------------------+
| 343994f0-f2e9-4f6...|
+---------------------------------------+
SELECT java_method('java.util.UUID', , );
+-----------------------------------------------------------------------------+
|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(, );
+-----------------------------------+
|reflect(java.util.UUID, randomUUID)|
+-----------------------------------+
| 51efe616-c51d-42e...|
+-----------------------------------+
SELECT reflect(, , );
+-------------------------------------------------------------------------+
|reflect(java.util.UUID, fromString, a5cf6c42-0c85-418f-af6c-3e4e5b1328f2)|
+-------------------------------------------------------------------------+
| a5cf6c42-0c85-418...|
+-------------------------------------------------------------------------+
-- spark_partition_id
SELECT spark_partition_id();
+--------------------+
|SPARK_PARTITION_ID()|
+--------------------+
| 0|
+--------------------+
-- try_aes_decrypt
SELECT try_aes_decrypt(unhex(), , );
+------------------------------------------------------------------------------------------------------------------------------------+
|try_aes_decrypt(unhex(6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210), 0000111122223333, GCM, DEFAULT, )|
+------------------------------------------------------------------------------------------------------------------------------------+
| [53 70 61 72 6B 2...|
+------------------------------------------------------------------------------------------------------------------------------------+
SELECT try_aes_decrypt(unhex(), , );
+------------------------------------------------------------------------------------------------------------------------------------+
|try_aes_decrypt(unhex(----------468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210), 0000111122223333, GCM, DEFAULT, )|
+------------------------------------------------------------------------------------------------------------------------------------+
| NULL|
+------------------------------------------------------------------------------------------------------------------------------------+
-- typeof
SELECT typeof(1);
+---------+
|typeof(1)|
+---------+
| int|
+---------+
SELECT typeof(array(1));
+----------------+
|typeof(array(1))|
<span <span="None
生成器函数
函数 | 描述 |
---|---|
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`。 |
stack(n, expr1, ..., exprk) | 将 `expr1`,...,`exprk` 分隔为 `n` 行。默认情况下使用列名 col0, col1 等,除非另有说明。 |
示例
-- explode
SELECT explode(array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
SELECT explode(collection => 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 inline(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|
+----+----+
-- posexplode
SELECT posexplode(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
SELECT * FROM posexplode(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
-- posexplode_outer
SELECT posexplode_outer(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
SELECT * FROM posexplode_outer(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
-- stack
SELECT stack(2, 1, 2, 3);
+----+----+
|col0|col1|
+----+----+
| 1| 2|
| 3|NULL|
+----+----+