配置单元运算符和用户定义的函数(UDF)

Case-insensitive

所有 Hive 关键字都不区分大小写，包括 Hive 运算符和函数的名称。

在Beeline或CLI中，使用以下命令显示最新文档：

SHOW FUNCTIONS;
DESCRIBE FUNCTION <function_name>;
DESCRIBE FUNCTION EXTENDED <function_name>;

Bug for expression caching when UDF nested in UDF or function

如果hive.cache.expr.evaluation设置为 true(默认设置)，则如果将其嵌套在另一个 UDF 或 Hive 函数中，则 UDF 会给出错误的结果。此错误影响版本 0.12.0、0.13.0 和 0.13.1. 版本 0.14.0 修复了该错误(HIVE-7314)。

该问题与 Hive 用户邮件列表中discussed的 UDF 对 getDisplayString 方法的实现有关。

Built-in Operators

Operators Precedences

Example	Operators	Description
A [B]，A.标识符	bracket_op([]), dot(.)	元素 selectors，点
-A	一元()，一元(-)，一元(~)	一元前缀运算符
一个 IS [NOT](NULL	TRUE	FALSE)	IS NULL，IS NOT NULL，...	unary suffix
A ^ B	bitwise xor(^)	bitwise xor
A * B	星号(*)，分度(/)，mod(％)，div(DIV)	multiplicative operators
乙	plus(+), minus(-)	additive operators
A		乙	string concatenate(\|\|)	string concatenate
A＆B	bitwise and(&)	bitwise and
A	乙	bitwise or(\|)	bitwise or

Relational Operators

以下运算符比较传递的操作数，并根据操作数之间的比较是否成立来生成 TRUE 或 FALSE 值。

Operator	Operand types	Description
A = B	所有原始类型	如果表达式 A 等于表达式 B，则为 TRUE，否则为 FALSE。
A == B	所有原始类型	=运算符的同义词。
A<=> B	所有原始类型	对于非空操作数，使用 EQUAL(=)运算符返回相同的结果，但是如果两个均为 NULL，则返回 TRUE，如果其中之一为 NULL，则返回 FALSE。 (从0.9.0版本开始。)
A<> B	所有原始类型	如果 A 或 B 为 NULL，则为 NULL，如果表达式 A 不等于表达式 B，则为 TRUE，否则为 FALSE。
A！= B	所有原始类型	\ <>运算符的同义词。
A <B	所有原始类型	如果 A 或 B 为 NULL，则为 NULL，如果表达式 A 小于表达式 B，则为 TRUE，否则为 FALSE。
A <= B	所有原始类型	如果 A 或 B 为 NULL，则为 NULL，如果表达式 A 小于或等于表达式 B，则为 TRUE，否则为 FALSE。
A> B	所有原始类型	如果 A 或 B 为 NULL，则为 NULL，如果表达式 A 大于表达式 B，则为 TRUE，否则为 FALSE。
A> = B	所有原始类型	如果 A 或 B 为 NULL，则为 NULL，如果表达式 A 大于或等于表达式 B，则为 TRUE，否则为 FALSE。
B 和 C 之间的[否]	所有原始类型	如果 A，B 或 C 为 NULL，则为 NULL；如果 A 大于或等于 B，而 A 小于或等于 C，则为 TRUE，否则为 FALSE。可以使用 NOT 关键字将其反转。 (从0.9.0版本开始。)
A IS NULL	All types	如果表达式 A 的计算结果为 NULL，则为 TRUE，否则为 FALSE。
一个不为空	All types	如果表达式 A 的计算结果为 NULL，则为 FALSE，否则为 TRUE。
是[否](TRUE	FALSE)	Boolean types	仅当 A 满足条件时评估为 TRUE。 (因为：3.0.0)

注意：NULL 为 UNKNOWN，因此(UNKNOWN 为 TRUE)和(UNKNOWN IS 为 FALSE)都将评估为 FALSE。
| A [NOT]如果 B 或 strings | NULL 如果 A 或 B 为 NULL，则为 TRUE，如果字符串 A 与 SQL 简单正则表达式 B 匹配，则为 FALSE。逐个字符进行比较。 B 中的字符匹配 A 中的任何字符(类似于 posix 正则表达式中的.)，而 B 中的％字符匹配 A 中任意数目的字符(类似于 posix 正则表达式中的.)。例如，“ foobar”之类的“ foobar”评估为 FALSE，而诸如“ foo”之类的“ foobar”评估为 TRUE，“ foobar”之类的评估为“ foo％”。
| A RLIKE B | strings | NULL，如果 A 或 B 为 NULL，则为 TRUE，如果 A 的任何子字符串(可能为空)与 Java 正则表达式 B 匹配，否则为 FALSE。例如，'foobar'RLIKE'foo'的计算结果为 TRUE，'foobar'RLIKE'^ f. r $'也是如此。
| A REGEXP B |字符串|与 RLIKE 相同。|

Arithmetic Operators

以下运算符支持对操作数的各种常见算术运算。所有返回 Numbers 类型；如果任何操作数为 NULL，则结果也为 NULL。

Operator	Operand types	Description
乙	所有数字类型	给出将 A 和 B 相加的结果。结果的类型与操作数类型的公共父对象(在类型层次结构中)相同。例如，由于每个整数都是浮点数，因此 float 是整数的包含类型，因此浮点数和 int 上的运算符将导致浮点数。
A-B	所有数字类型	给出从 A 减去 B 的结果。结果的类型与操作数类型的公共父级(在类型层次结构中)相同。
A * B	所有数字类型	给出将 A 和 B 相乘的结果。结果的类型与操作数类型的公共父级(在类型层次结构中)相同。请注意，如果乘法导致溢出，则必须将其中一个运算符转换为类型层次结构中较高的类型。
A/B	所有数字类型	给出将 A 除以 B 的结果。在大多数情况下，该结果为双精度类型。当 A 和 B 均为整数时，结果为双精度类型，除非hive.compat配置参数设置为“ 0.13”或“ latest”，在这种情况下，结果为十进制类型。
A DIV B	Integer types	给出将 A 除以 B 所得的整数部分。例如 17 div 3 得出 5.
A％B	所有数字类型	给出 A 除以 B 所得的提示。结果的类型与操作数类型的公共父级(在类型层次结构中)相同。
A＆B	所有数字类型	给出 A 和 B 的按位与的结果。结果的类型与操作数类型的公共父级(在类型层次结构中)相同。
A	乙	所有数字类型	给出 A 和 B 的按位或的结果。结果的类型与操作数类型的公共父级(在类型层次结构中)相同。
A ^ B	所有数字类型	给出 A 和 B 的按位 XOR 结果。结果的类型与操作数类型的公共父级(在类型层次结构中)相同。
~A	所有数字类型	给出 A 的按位 NOT 的结果。结果的类型与 A 的类型相同。

Logical Operators

以下运算符为创建逻辑表达式提供支持。它们都根据操作数的布尔值返回布尔 TRUE，FALSE 或 NULL。 NULL 表现为“未知”标志，因此，如果结果取决于未知状态，则结果本身是未知的。

Operator	Operand types	Description
A 和 B	boolean	如果 A 和 B 均为 TRUE，则为 TRUE，否则为 FALSE。如果 A 或 B 为 NULL，则为 NULL。
A 或 B	boolean	如果 A 或 B 或两者均为 TRUE，则为 TRUE，否则为 FALSE 或 NULL 为 NULL。
NOT A	boolean	如果 A 为 FALSE，则为 TRUE；如果 A 为 NULL，则为 NULL。否则为 FALSE。
! A	boolean	与 NOT A 相同。
A IN(val1，val2，...)	boolean	如果 A 等于任何值，则为 TRUE。从 Hive 0.13 开始，IN 语句中支持subqueries。
一个非 Importing(val1，val2，...)	boolean	如果 A 不等于任何值，则为 TRUE。从 Hive 0.13 开始，NOT IN 语句支持subqueries。
[NOT] EXISTS(子查询)		如果子查询返回至少一行，则为 TRUE。从Hive 0.13开始受支持。

String Operators

Operator	Operand types	Description
A		乙	strings	连接操作数-`concat(A,B)`的简写。从Hive 2.2.0开始受支持。

复杂类型的构造函数

以下函数构造复杂类型的实例。

Constructor Function	Operands	Description
map	(key1，value1，key2，value2，...)	使用给定的键/值对创建一个 Map。
struct	(val1，val2，val3，...)	用给定的字段值创建一个结构。结构字段名称将为 col1，col2，...。
named_struct	(名称 1，名称 1，名称 2，名称 2，...)	用给定的字段名称和值创建一个结构。 (从 Hive 0.8.0开始。)
array	(val1，val2，...)	用给定的元素创建一个数组。
create_union	(标签，val1，val2，...)	用 tag 参数指向的值创建一个联合类型。

复杂类型上的运算符

以下运算符提供了访问复杂类型中的元素的机制。

Operator	Operand types	Description
A[n]	A 是一个数组，n 是一个整数	返回数组 A 中的第 n 个元素。第一个元素的索引为 0.例如，如果 A 是包含['foo'，'bar']的数组，则 A [0]返回'foo'，而 A [1]返回'酒吧'。
M[key]	M 是 Map\ <K, V>，并且密钥的类型为 K	返回与 Map 中的键对应的值。例如，如果 M 是包含\ {'f' -> 'foo', 'b' -> 'bar', 'all' -> 'foobar'}的 Map，则 M ['all']返回'foobar'。
S.x	S 是一个结构	返回 S 的 x 字段。例如对于 foobar{int foo, int bar}结构，foobar.foo 返回存储在 foo 字段中的整数。

Built-in Functions

Mathematical Functions

Hive 支持以下内置 math 函数；当参数为 NULL 时，大多数返回 NULL：

Return Type	Name (Signature)	Description
DOUBLE	round(DOUBLE a)	返回舍入的`BIGINT`值`a`。
DOUBLE	舍入(DOUBLE a，INT d)	返回`a`舍入到`d`小数位。
DOUBLE	bround(DOUBLE a)	使用 HALF_EVEN 舍入模式(从Hive1.3.0，2.0.0开始)返回舍入的 BIGINT 值`a`。也称为高斯舍入或银行家舍入。例如：bround(2.5)= 2，bround(3.5)= 4.
DOUBLE	圆角(DOUBLE a，INT d)	使用 HALF_EVEN 舍入模式(从Hive1.3.0，2.0.0开始)，将`a`舍入到`d`小数位。例如：bround(8.25，1)= 8.2，bround(8.35，1)= 8.4.
BIGINT	floor(DOUBLE a)	返回等于或小于`a`的最大`BIGINT`值。
BIGINT	天花板(DOUBLE A)，天花板(DOUBLE A)	返回等于或大于`a`的最小 BIGINT 值。
DOUBLE	rand()，rand(INT 种子)	返回从 0 到 1 均匀分布的随机数(逐行变化)。指定种子将确保所生成的随机数序列具有确定性。
DOUBLE	exp(DOUBLE a)，exp(DECIMAL a)	返回`ea`，其中`e`是自然对数的底数。 Hive 0.13.0中添加了十进制版本。
DOUBLE	ln(DOUBLE a)，ln(DECIMAL a)	返回参数`a`的自然对数。 Hive 0.13.0中添加了十进制版本。
DOUBLE	log10(DOUBLE a)，log10(DECIMAL a)	返回参数`a`的以 10 为底的对数。 Hive 0.13.0中添加了十进制版本。
DOUBLE	log2(DOUBLE a)，log2(DECIMAL a)	返回参数`a`的以 2 为底的对数。 Hive 0.13.0中添加了十进制版本。
DOUBLE	日志(DOUBLE base，DOUBLE a)
log(DECIMAL base，DECIMAL a)	返回自变量`a`的底数`base`对数。 Hive 0.13.0中添加了十进制版本。
DOUBLE	pow(DOUBLE a，DOUBLE p)，功率(DOUBLE a，DOUBLE p)	返回`ap`。
DOUBLE	sqrt(DOUBLE a)，sqrt(DECIMAL a)	返回`a`的平方根。 Hive 0.13.0中添加了十进制版本。
STRING	bin(BIGINT a)	以二进制格式返回数字(请参见http://dev.mysql.com/doc/refman/5.0/en/string-functions.html#function_bin)。
STRING	hex(BIGINT a)hex(STRING a)hex(BINARY a)	如果参数是`INT`或`binary`，则`hex`以十六进制格式将数字作为`STRING`返回。否则，如果数字为`STRING`，则它将每个字符转换为其十六进制表示形式，并返回结果`STRING`。 (请参阅 Hive 0.12.0的http://dev.mysql.com/doc/refman/5.0/en/string-functions.html#function_hex，`BINARY`版本。)
BINARY	unhex(STRING a)	十六进制的逆。将每对字符解释为十六进制数字，并转换为数字的字节表示形式。 (自 Hive 0.12.0起的`BINARY`版本，用于返回字符串。)
STRING	conv(BIGINT num，INT from_base，INT to_base)，conv(STRING num，INT from_base，INT to_base)	将数字从给定的基数转换为另一个基数(请参见http://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html#function_conv)。
DOUBLE	abs(DOUBLE a)	返回绝对值。
INT 或 DOUBLE	pmod(INT a，INT b)，pmod(DOUBLE a，DOUBLE b)	返回`a mod b`的正值。
DOUBLE	sin(DOUBLE a)，sin(DECIMAL a)	返回`a`的正弦(`a`以弧度表示)。 Hive 0.13.0中添加了十进制版本。
DOUBLE	asin(DOUBLE a)，asin(DECIMAL a)	如果-1 <= a <= 1，则返回`a`的反正弦值，否则返回 NULL。 Hive 0.13.0中添加了十进制版本。
DOUBLE	cos(DOUBLE a)，cos(DECIMAL a)	返回`a`的余弦(`a`以弧度表示)。 Hive 0.13.0中添加了十进制版本。
DOUBLE	acos(DOUBLE a)，acos(DECIMAL a)	如果-1 <= a <= 1，则返回`a`的反余弦值，否则返回 NULL。 Hive 0.13.0中添加了十进制版本。
DOUBLE	tan(DOUBLE a)，tan(DECIMAL a)	返回`a`的切线(`a`以弧度表示)。 Hive 0.13.0中添加了十进制版本。
DOUBLE	atan(DOUBLE a)，atan(DECIMAL a)	返回`a`的反正切。 Hive 0.13.0中添加了十进制版本。
DOUBLE	degrees(DOUBLE a)，degrees(DECIMAL a)	将`a`的值从弧度转换为度数。 Hive 0.13.0中添加了十进制版本。
DOUBLE	弧度(DOUBLE a)，弧度(DOUBLE a)	将`a`的值从度转换为弧度。 Hive 0.13.0中添加了十进制版本。
INT 或 DOUBLE	正(INT a)，正(DOUBLE a)	返回`a`。
INT 或 DOUBLE	负数(INT a)，负数(DOUBLE a)	返回`-a`。
DOUBLE 或 INT	sign(DOUBLE a)，sign(DECIMAL a)	将`a`的符号返回为'1.0'(如果`a`为正)或'-1.0'(如果`a`为负)，否则为'0.0'。十进制版本返回 INT 而不是 DOUBLE。 Hive 0.13.0中添加了十进制版本。
DOUBLE	e()	返回`e`的值。
DOUBLE	pi()	返回`pi`的值。
BIGINT	factorial(INT a)	返回`a`的阶乘(从 Hive 1.2.0起)。有效`a`为[0..20]。
	DOUBLE	cbrt(DOUBLE a)	返回`a` double 值的立方根(从 Hive 1.2.0开始)。
INT BIGINT	向左移(TINYINT	SMALLINT	INT a，INT b) shiftleft(BIGINT a，INT b)	按位左移(从 Hive 1.2.0开始)。将`a` `b`位置向左移动。为 tinyint，smallint 和 int `a`返回 int。为 bigint `a`返回 bigint。
INT BIGINT	shiftright(TINYINT	SMALLINT	INT a，INT b) shiftright(BIGINT a，INT b)	按位右移(从 Hive 1.2.0开始)。向右移动`a` `b`位置。为 tinyint，smallint 和 int `a`返回 int。为 bigint `a`返回 bigint。
INT BIGINT	shiftrightunsigned(TINYINT	SMALLINT	INT a，INT b)， shiftrightunsigned(BIGINT a，INT b)	按位无符号右移(从 Hive 1.2.0开始)。向右移动`a` `b`位置。为 tinyint，smallint 和 int `a`返回 int。为 bigint `a`返回 bigint。
T	greatest(T v1，T v2，...)	返回值列表的最大值(从 Hive 1.1.0开始)。固定为当一个或多个参数为 NULL 且严格类型限制放宽时返回 NULL，与“>”运算符一致(从 Hive 2.0.0开始)。
T	least(T v1，T v2，...)	返回值列表中的最小值(从 Hive 1.1.0开始)。固定为当一个或多个参数为 NULL 并放宽严格的类型限制(与 Hive 2.0.0一致)时，返回严格的类型限制，以返回 NULL。
INT	width_bucket(NUMERIC expr，NUMERIC min_value，NUMERIC max_value，INT num_buckets)	通过将 exprMap 到第 i 个大小相等的存储桶中，返回 0 到 num_buckets 1 之间的整数。通过将[min_value，max_value]划分为大小相等的区域来制作存储桶。如果 expr< min_value, return 1, if expr > max_value 返回 num_buckets 1.请参见https://docs.oracle.com/cd/B19306_01/server.102/b14200/functions214.htm(从 Hive 3.0.0 开始)

小数数据类型的 math 函数和运算符

Version

Hive 0.11.0(HIVE-2693)中引入了十进制数据类型。

所有常规算术运算符(例如，-，*，/)和相关的 mathUDF(Floor，Ceil，Round 等)都已更新为处理十进制类型。有关受支持的 UDF 的列表，请参见Hive 数据类型中的Mathematical UDFs。

Collection Functions

Hive 支持以下内置收集功能：

Return Type	Name(Signature)	Description
int	size(Map<K.V>)	返回 Map 类型中的元素数。
int	size(Array<T>)	返回数组类型中的元素数。
array<K>	map_keys(Map<K.V>)	返回包含 ImportingMap 键的无序数组。
array<V>	map_values(Map<K.V>)	返回包含 ImportingMap 值的无序数组。
boolean	array_contains(Array<T>, value)	如果数组包含值，则返回 TRUE。
array<t>	sort_array(Array<T>)	根据数组元素的自然 Sequences 以升序对 Importing 数组进行排序，然后将其返回(从版本0.9.0开始)。

类型转换功能

Hive 支持以下类型转换功能：

Return Type	Name(Signature)	Description
binary	binary(string\|binary)	将参数转换为二进制。
期望“ =”跟随“类型”	强制转换(expr 为 )	将表达式 expr 的结果转换为\ 。例如，cast('1'as BIGINT)会将字符串'1'转换为其整数表示。如果转换不成功，则返回 null。如果 cast(expr 为 boolean)，则 Hive 对于非空字符串返回 true。

Date Functions

Hive 支持以下内置日期功能：

Return Type	Name(Signature)	Description
string	from_unixtime(bigint unixtime[, string format])	将 unix 纪元(1970-01-01 00:00:00 UTC)的秒数转换为一个字符串，该字符串表示当前系统时区中该 Moment 的时间戳，格式为“ 1970-01-01 00:00： 00”。
bigint	unix_timestamp()	以秒为单位获取当前的 Unix 时间戳。此函数不是确定性的，其值在查询执行范围内也不是固定的，因此会阻止对查询的适当优化-自 2.0 版以来已弃用此函数，而推荐使用 CURRENT_TIMESTAMP 常量。
bigint	unix_timestamp(string date)	使用默认时区和默认语言环境将格式为`yyyy-MM-dd HH:mm:ss`的时间字符串转换为 Unix 时间戳(以秒为单位)，如果失败，则返回 0：unix_timestamp('2009-03-20 11:30:01')= 1237573801
bigint	unix_timestamp(字符串日期，字符串模式)	将具有给定模式(请参见 [http://docs.oracle.com/javase/tutorial/i18n/format/simpleDateFormat.html])的时间字符串转换为 Unix 时间戳(以秒为单位)，如果失败，则返回 0：unix_timestamp('2009-03-20'，'yyyy-MM-dd')= 1237532400.
* 2.1.0 之前的版本：*字符串
* 2.1.0 on：* date	to_date(字符串时间戳记)	返回时间戳记字符串的日期部分(Hive 2.1.0 之前)：to_date(“ 1970-01-01 00:00:00”)=“ 1970 -01-01”。从 Hive 2.1.0 开始，返回日期对象。

在 Hive 2.1.0(HIVE-13248)之前，返回类型为 String，因为创建方法时不存在 Date 类型。
| int | year(字符串日期)|返回日期或时间戳字符串的年份部分：year(“ 1970-01-01 00:00:00”)= 1970，year(“ 1970-01-01”)= 1970.|
| int | quarter(date/timestamp/string)|返回日期，时间戳或字符串在 1 到 4 范围内的一年的四分之一(从 Hive 1.3.0开始)。示例：quarter('2015-04-08')= 2 |
| int | month(string date)|返回日期或时间戳记字符串的月份部分：month(“ 1970-11-01 00:00:00”)= 11，month(“ 1970-11-01”)= 11 |
| int | day(string date)dayofmonth(date)|返回日期或时间戳记字符串的 day 部分：day(“ 1970-11-01 00:00:00”)= 1，day(“ 1970-11- 01“)= 1. |
| int | hour(字符串日期)|返回时间戳的小时：hour('2009-07-30 12:58:59')= 12，hour('12：58：59')= 12.
| int | minute(字符串日期)|返回时间戳记的分钟。
| int | second(字符串日期)|返回时间戳的秒。
| int | weekofyear(字符串日期)|返回时间戳字符串的星期数：weekofyear(“ 1970-11-01 00:00:00”)= 44，weekofyear(“ 1970-11-01”)= 44.
| int | extract(字段 FROM 源)|从源中检索字段，例如天或小时(自 Hive 2.2.0起)。源必须是日期，时间戳记，间隔或可以转换为日期或时间戳记的字符串。支持的字段包括：日，星期几，小时，分钟，月，季度，秒，周和年。

Examples:

选择摘录(“ 2016-10-20”中的月份)得出 10.

选择摘录(来自“ 2016-10-20 05:06:07”的小时)的结果为 5.

选择摘录(dayofweek，来自“ 2016-10-20 05:06:07”)，结果为 5.

选择摘录(从“ 1-3”年到月的月份中的月份)结果为 3.

选择摘录(从间隔'3 12:20:30 天到第二分钟的分钟数)得到 20.
| int | datediff(字符串结束日期，字符串开始日期)|返回从开始日期到结束日期的天数：datediff('2009-03-01'，'2009-02-27')= 2.
| * pre 2.1.0：字符串

2.1.0 on：* date | date_add(date/timestamp/string startdate，tinyint/smallint/int days)|添加了若干天作为开始日期：date_add('2008-12-31'，1)='2009- 01-01'。

在 Hive 2.1.0(HIVE-13248)之前，返回类型为 String，因为创建方法时不存在 Date 类型。
| * pre 2.1.0：字符串

2.1.0 on：* date | date_sub(日期/时间戳记/字符串开始日期，tinyint/smallint/int 天)|减去开始日期的天数：date_sub('2008-12-31'，1)='2008- 12-30'。

在 Hive 2.1.0(HIVE-13248)之前，返回类型为 String，因为创建方法时不存在 Date 类型。
| timestamp | from_utc_timestamp( { any primitive type } ts，字符串 timezone)|将 UTC 中的时间戳*转换为给定的时区(从 Hive 0.8.0开始)。

时间戳是一种原始类型，包括时间戳/日期，tinyint/smallint/int/bigint，float/double 和十进制。

小数部分被视为秒。整数值以毫秒为单位。例如，from_utc_timestamp(2592000.0，'PST')，from_utc_timestamp(2592000000，'PST')和 from_utc_timestamp(timestamp'1970-01-30 16:00:00'，'PST')都返回时间戳 1970-01-30 08：00：00. |
| timestamp | to_utc_timestamp( { any primitive type } ts，字符串时区)|将给定时区中的时间戳转换为 UTC(从 Hive 0.8.0开始)。

*时间戳是一种原始类型，包括时间戳/日期，tinyint/smallint/int/bigint，float/double 和十进制。

小数部分被视为秒。整数值以毫秒为单位。例如，to_utc_timestamp(2592000.0，'PST')，to_utc_timestamp(2592000000，'PST')和 to_utc_timestamp(timestamp'1970-01-30 16:00:00'，'PST')都返回时间戳 1970-01-31 00：00：00.|
| date | current_date |返回查询评估开始时的当前日期(从 Hive 1.2.0开始)。在同一查询中对 current_date 的所有调用均返回相同的值。
| timestamp | current_timestamp |返回查询评估开始时的当前时间戳(从 Hive 1.2.0开始)。在同一查询中对 current_timestamp 的所有调用均返回相同的值。
| string | add_months(字符串起始日期，int num_months，output_date_format)|返回起始日期之后 num_months 的日期(从 Hive 1.1.0开始)。 start_date 是字符串，日期或时间戳。 num_months 是一个整数。如果 start_date 是该月的最后一天，或者如果结果月份的天数少于 start_date 的天部分，则结果是结果月份的最后一天。否则，结果与 start_date 具有相同的天组成部分。默认输出格式为“ yyyy-MM-dd”。

在 Hive 4.0.0 之前，日期的时间部分将被忽略。

从 Hive 4.0.0开始，add_months 支持可选参数 output_date_format，该参数接受一个 String，该 String 表示输出的有效日期格式。这样可以在输出中保留时间格式。

例如：

add_months('2009-08-31'，1)返回'2009-09-30'。

| add_months('2017-12-31 14:15:16'，2，'YYYY-MM-dd HH：mm：ss')返回'2018-02-28 14:15:16'。
| string | last_day(字符串日期)|返回日期所属月份的最后一天(从 Hive 1.1.0开始)。 date 是格式为“ yyyy-MM-dd HH：mm：ss”或“ yyyy-MM-dd”的字符串。日期的时间部分将被忽略。
| string | next_day(字符串 start_date，字符串 day_of_week)|返回晚于 start_date 并命名为 day_of_week 的第一个日期(从 Hive 1.2.0开始)。 start_date 是一个字符串/日期/时间戳。 day_of_week 是 2 个字母，3 个字母或一周中某天的全名(例如 Mo，tue 和 FRIDAY)。 start_date 的时间部分将被忽略。例如：next_day('2015-01-14'，'TU')= 2015-01-20.
| string | trunc(字符串日期，字符串格式)|返回被截断为该格式指定的单位的日期(从 Hive 1.2.0开始)。支持的格式：MONTH/MON/MM，YEAR/YYYY/YY。示例：trunc('2015-03-17'，'MM')= 2015-03-01.
| double | months_between(date1，date2)|返回日期 date1 和 date2 之间的月份数(从 Hive 1.2.0开始)。如果 date1 晚于 date2，则结果为正。如果 date1 早于 date2，则结果为负。如果 date1 和 date2 是月份的同一天或月份的最后几天，则结果始终是整数。否则，UDF 将基于 31 天的月份来计算结果的小数部分，并考虑时间分量 date1 和 date2 的差异。 date1 和 date2 类型可以是日期，时间戳或字符串，格式为“ yyyy-MM-dd”或“ yyyy-MM-dd HH：mm：ss”。结果四舍五入到小数点后 8 位。例如：months_between('1997-02-28 10:30:00'，'1996-10-30')= 3.94959677 |
| string | date_format(日期/时间戳记/字符串 ts，字符串 fmt)|将日期/时间戳记/字符串转换为日期格式 fmt(从 Hive 1.2.0起)指定的格式的字符串值。支持的格式是 Java SimpleDateFormat 格式https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html。第二个参数 fmt 应该是常量。示例：date_format('2015-04-08'，'y')='2015'。

date_format 可用于实现其他 UDF，例如：

dayname(date)是 date_format(date，'EEEE')

dayofyear(date)是 date_format(date，'D')|

Conditional Functions

Return Type	Name(Signature)	Description
T	if(boolean testCondition，T valueTrue，T valueFalseOrNull)	当 testCondition 为 true 时返回 valueTrue，否则返回 valueFalseOrNull。
boolean	无效(a)	如果 a 为 NULL，则返回 true，否则返回 false。
boolean	isnotnull(a)	如果 a 不为 NULL，则返回 true，否则返回 false。
T	nvl(T 值，T default_value)	如果 value 为 null，则返回默认值，否则返回值(从 HIve 0.11开始)。
T	COALESCE(T v1，T v2，...)	返回第一个不为 NULL 的 v，如果所有 v 均为 NULL，则返回 NULL。
T	案例 a 何时 b 然后 c [何时 e] * [其他 f]结束	当 a = b 时，返回 c;当 a = d 时，返回 e;否则返回 f。
T	aTHEN 时的情况 b [When c THEN d] * [ELSE e]结束	当 a = true 时，返回 b;当 c = true 时，返回 d;否则返回 e。
T	nullif(a，b)	如果 a = b，则返回 NULL；否则返回 NULL。否则返回一个(从 Hive 2.3.0开始)。
简写：CASE 当 a = b 时为 NULL，否则为 a
void	assert_true(布尔条件)	如果'condition'不为 true，则引发异常，否则返回 null(从 Hive 0.8.0开始)。例如，选择 assert_true(2 <1)。

String Functions

Hive 支持以下内置的 String 函数：

Return Type	Name(Signature)	Description
int	ascii(string str)	返回 str 的第一个字符的数值。
string	base64(binary bin)	将参数从二进制转换为基数为 64 的字符串(从 Hive 0.12.0开始)。
int	character_length(string str)	返回 str 中包含的 UTF-8 字符数(从 Hive 2.2.0开始)。函数 char_length 是该函数的简写。
string	chr(bigint\|double A)	返回具有与 A 等效的二进制值的 ASCII 字符(从 Hive 1 .3.0 和 2.1.0开始)。如果 A 大于 256，则结果等于 chr(A％256)。示例：选择 chr(88);返回“ X”。
string	concat(字符串	二进制 A，字符串	二进制 B ...)	返回按 Sequences 串联作为参数传入的字符串或字节得到的字符串。例如，concat('foo'，'bar')的结果为'foobar'。请注意，此函数可以接受任意数量的 Importing 字符串。
array<struct<string,double>>	context_ngrams(array<array>，array，int K，int pf)	给定字符串“ context”，从一组标记化语句返回前 k 个上下文 N-gram。有关更多信息，请参见StatisticsAndDataMining。
string	concat_ws(字符串 SEP，字符串 A，字符串 B ...)	与上面的 concat()类似，但具有自定义分隔符 SEP。
string	concat_ws(字符串 SEP，数组 )	就像上面的 concat_ws()一样，但是采用字符串数组。 (自 Hive 0.9.0起)
string	解码(二进制 bin，字符串字符集)	使用提供的字符集(“ US-ASCII”，“ ISO-8859-1”，“ UTF-8”，“ UTF-16BE”，“ UTF-16LE”，“ UTF- 16')。如果任一参数为 null，则结果也将为 null。 (从 Hive 0.12.0开始。)
string	elt(N int，str1 字符串，str2 字符串，str3 字符串，...)	返回索引号处的字符串。例如 elt(2，'hello'，'world')返回'world'。如果 N 小于 1 或大于参数个数，则返回 NULL。
(see https://dev.mysql.com/doc/refman/5.7/en/string-functions.html#function_elt)
binary	encode(字符串 src，字符串字符集)	使用提供的字符集(“ US-ASCII”，“ ISO-8859-1”，“ UTF-8”，“ UTF- 16BE”，“ UTF-16LE”，“ UTF-16”)。如果任一参数为 null，则结果也将为 null。 (自 Hive 0.12.0起。)
int	field(val T，val1 T，val2 T，val3 T，...)	返回 val1，val2，val3，...列表中 val 的索引，如果找不到，则返回 0.例如 field('world'，'say'，'hello'，'world')返回 3. 支持所有基本类型，使用 str.equals(x)比较参数。如果 val 为 NULL，则返回值为 0. (see https://dev.mysql.com/doc/refman/5.7/en/string-functions.html#function_field)
int	find_in_set(字符串 str，字符串 strList)	返回 str 在 strList 中的首次出现，其中 strList 是逗号分隔的字符串。如果任一参数为 null，则返回 null。如果第一个参数包含任何逗号，则返回 0.例如，find_in_set('ab'，'abc，b，ab，c，def')返回 3.
string	format_number(number x，int d)	将数字 X 格式化为'#，###，###.##'之类的格式，四舍五入到 D 小数位，然后将结果作为字符串返回。如果 D 为 0，则结果没有小数点或小数部分。 (从 Hive 0.10.0开始；在Hive 0.14.0中修复了 float 类型的错误，在Hive 0.14.0中添加了小数类型支持)
string	get_json_object(字符串 json_string，字符串路径)	根据指定的 json 路径从 json 字符串中提取 json 对象，并返回提取的 json 对象的 json 字符串。如果 Importing 的 json 字符串无效，它将返回 null。 *注意：json 路径只能包含字符[0-9a-z_]，即不能包含大写或特殊字符.此外，键不能以数字开头.** *这是由于对 Hive 列名的限制。
	boolean	in_file(字符串 str，字符串文件名)	如果字符串 str 在文件名中显示为整行，则返回 true。
int	instr(string str，string substr)	返回`str`中第一次出现的`substr`的位置。如果其中一个参数为`null`，则返回`null`；如果在`str`中找不到`substr`，则返回`0`。请注意，这不是基于零的。 `str`中的第一个字符的索引为 1.
int	length(字符串 A)	返回字符串的长度。
int	locate(字符串 substr，字符串 str [，int pos])	返回在位置 pos 之后的 str 中第一次出现 substr 的位置。
string	lower(字符串 A)lcase(字符串 A)	返回将 B 的所有字符都转换成小写形式的字符串。例如，lower('fOoBaR')会导致'foobar'。
string	lpad(string str，int len，字符串 pad)	返回 str，用 pad 左填充到 len 的长度。如果 str 大于 len，则返回值缩短为 len 个字符。	如果填充字符串为空，则返回值为 null。
string	ltrim(字符串 A)	返回从 A 的开头(左侧)起修剪空格而产生的字符串。例如，ltrim('foobar')的结果为'foobar'。
array<struct<string,double>>	ngrams(array<array>，int N，int K，int pf)	从一组带标记的语句中返回前 k 个 N-gram，例如由句子()UDAF 返回的语句。有关更多信息，请参见StatisticsAndDataMining。
int	octet_length(string str)	返回以 UTF-8 编码保存字符串 str 所需的八位字节数(自 Hive 2.2.0以来)。请注意，octet_length(str)可以大于 character_length(str)。
string	parse_url(字符串 urlString，字符串 partToExtract [，字符串 keyToExtract])	从 URL 返回指定部分。 partToExtract 的有效值包括 HOST，PATH，QUERY，REF，PROTOCOL，AUTHORITY，FILE 和 USERINFO。例如，parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1'，'HOST')返回'facebook.com'。通过将键作为第三个参数，也可以提取 QUERY 中特定键的值，例如 parse_url('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1'，	'QUERY'，'k1')返回'v1'。
string	printf(String format，Obj ... args)	返回根据 do printf 样式格式的字符串格式化的 Importing(从 Hive 0.9.0开始)。
string	quote(字符串文本)	返回带引号的字符串(包括任何单引号HIVE-4.0.0的转义字符)	Importing	输出		NULL	NULL		DONT	'DONT'	不要'DON 'T'
string	regexp_extract(字符串主题，字符串模式，int 索引)	返回使用该模式提取的字符串。例如，regexp_extract('foothebar'，'foo(.*？)(bar)'，2)返回'bar'。请注意，使用 sched 义字符类时必须格外小心：使用' s'作为第二个参数将与字母 s 匹配； '\ s'是匹配空格等所必需的。'index'参数是 Java regex Matcher group()方法的索引。有关'index'或 Java regex group()方法的更多信息，请参见docs/api/java/util/regex/Matcher.html。
string	regexp_replace(字符串 INITIAL_STRING，字符串 PATTERN，字符串 REPLACEMENT)	返回由 INITIAL_STRING 中所有与 PATTERN 中定义的 Java 正则表达式语法匹配的子字符串替换为 REPLACEMENT 实例所产生的字符串。例如，regexp_replace(“ foobar”，“ oo	ar”，“”)返回'fb'。请注意，使用 sched 义字符类时必须格外小心：使用' s'作为第二个参数将与字母 s 匹配； '\ s'是匹配空格等所必需的
string	repeat(string str，int n)	重复 str n 次。
string	replace(字符串 A，字符串 OLD，字符串 NEW)	返回字符串 A，其中所有非重叠出现的 OLD 都被 NEW 取代(从Hive1.3.0 和 2.1.0开始)。示例：选择 replace(“ ababab”，“ abab”，“ Z”);返回“ Zab”。
string	reverse(字符串 A)	返回反转的字符串。
string	rpad(string str，int len，字符串 pad)	返回 str，用 pad 右填充到 len 的长度。如果 str 大于 len，则返回值缩短为 len 个字符。	如果填充字符串为空，则返回值为 null。
string	rtrim(string A)	返回从 A 的末端(右侧)修剪空格所得到的字符串。例如，rtrim('foobar')会生成'foobar'。
array<array>	句子(字符串 str，字符串 lang，字符串语言环境)	将一串自然语言文本标记为单词和句子，其中每个句子在适当的句子边界处断开并作为单词数组返回。 “ lang”和“ locale”是可选参数。例如，句子(“ Hello there！您好吗？”)返回((“ Hello”，“ there”)，(“ How”，“ are”，“ you”)))。
string	space(int n)	返回 n 个空格的字符串。
array	split(字符串 str，字符串 pat)	在 pat 周围拆分 str(pat 是一个正则表达式)。
map<string,string>	str_to_map(text [，delimiter1，delimiter2])	使用两个定界符将文本分割为键/值对。 Delimiter1 将文本分成 K-V 对，Delimiter2 将每个 K-V 对分开。		默认分隔符是'，'代表 delimiter1，'：'代表 delimiter2.
string	substr(字符串	二进制 A，int 起始)substring(字符串	二进制 A，int 起始)	返回从字节 A 的起始位置开始到结尾的 A 的字节数组的子字符串或切片。例如，substr ('foobar'，4)产生'bar'(请参见 [http://dev.mysql.com/doc/refman/5.0/en/string-functions.html#function_substr])。
string	substr(字符串	二进制 A，int 起始，int len)substring(字符串	二进制 A，int 起始，int len)	从长度为 len 的起始位置返回 A 的字节数组的子字符串或切片。例如，substr('foobar'，4，1)的结果为'b'(请参见 [http://dev.mysql.com/doc/refman/5.0/en/string-functions.html#function_substr])。
string	substring_index(字符串 A，字符串 delim，整数计数)	在计数出现定界符 delim 之前(从 Hive 1.3.0开始)从字符串 A 返回子字符串。如果 count 为正，则返回最后定界符左侧的所有内容(从左侧开始计数)。如果 count 为负，则返回最后定界符右边的所有内容(从右边开始计数)。搜索 delim 时，Substring_index 执行区分大小写的匹配。例如：substring_index('www.apache.org'，'.'，2)='www.apache'。
string	translate(字符串	char	varcharImporting，字符串	char	varchar 从，字符串	char	varchar 到)	通过将`from`字符串中存在的字符替换为`to`字符串中的相应字符来翻译 Importing 字符串。这类似于PostgreSQL中的`translate`函数。如果此 UDF 的任何参数为 NULL，则结果也为 NULL。 (自 Hive 0.10.0起，适用于字符串类型) 从Hive 0.14.0开始添加了对 char/varchar 的支持。
string	trim(string A)	返回从 A 的两端修剪空格产生的字符串。例如，trim('foobar')产生'foobar'
binary	unbase64(string str)	将参数从基数 64 的字符串转换为 BINARY。 (自 Hive 0.12.0起。)
string	upper(字符串 A)ucase(字符串 A)	返回将 A 的所有字符都转换为大写字母的字符串。例如，upper('fOoBaR')的结果为'FOOBAR'。
string	initcap(string A)	返回字符串，每个单词的首字母大写，其他所有字母小写。单词由空格分隔。 (自 Hive 1.1.0起。)
int	levenshtein(字符串 A，字符串 B)	返回两个字符串之间的 Levenshtein 距离(从 Hive 1.2.0开始)。例如，levenshtein('kitten'，'sitting')得出 3.
string	soundex(字符串 A)	返回字符串的 soundex 代码(从 Hive 1.2.0开始)。例如，soundex('Miller')生成 M460.

数据屏蔽功能

Hive 支持以下内置数据屏蔽功能：

Return Type	Name(Signature)	Description
string	mask(string str[, string upper[, string lower[, string number]]])	返回 str 的掩码版本(从 Hive 2.1.0开始)。默认情况下，大写字母转换为“ X”，小写字母转换为“ x”，数字转换为“ n”。例如 mask(“ abcd-EFGH-8765-4321”)的结果为 xxxx-XXXX-nnnn-nnnn。您可以通过提供其他参数来覆盖掩码中使用的字符：第二个参数控制大写字母的掩码字符，第三个参数控制小写字母的字符，第四个参数控制数字的字符。例如，mask(“ abcd-EFGH-8765-4321”，“ U”，“ l”，“#”)生成 llll-UUUU-####-####。
string	mask_first_n(string str[, int n])	返回带掩码的版本的 str，其中前 n 个值被掩码(从 Hive 2.1.0开始)。大写字母转换为“ X”，小写字母转换为“ x”，数字转换为“ n”。例如，mask_first_n(“ 1234-5678-8765-4321”，4)生成 nnnn-5678-8765-4321.
string	mask_last_n(string str[, int n])	返回带有掩码的最后一个 n 值的 str 的掩码版本(从 Hive 2.1.0开始)。大写字母转换为“ X”，小写字母转换为“ x”，数字转换为“ n”。例如，mask_last_n(“ 1234-5678-8765-4321”，4)生成 1234-5678-8765-nnnn。
string	mask_show_first_n(string str[, int n])	返回 str 的掩码版本，显示未掩码的前 n 个字符(从 Hive 2.1.0开始)。大写字母转换为“ X”，小写字母转换为“ x”，数字转换为“ n”。例如，mask_show_first_n(“ 1234-5678-8765-4321”，4)的结果为 1234-nnnn-nnnn-nnnn。
string	mask_show_last_n(string str[, int n])	返回 str 的掩码版本，显示未掩码的最后 n 个字符(从 Hive 2.1.0开始)。大写字母转换为“ X”，小写字母转换为“ x”，数字转换为“ n”。例如，mask_show_last_n(“ 1234-5678-8765-4321”，4)的结果为 nnnn-nnnn-nnnn-4321.
string	mask_hash(string\|char\|varchar str)	返回基于 str 的哈希值(从 Hive 2.1.0开始)。哈希是一致的，可用于将跨表的掩码值连接在一起。对于非字符串类型，此函数返回 null。

Misc. Functions

Return Type	Name(Signature)	Description
varies	java_method(class, method[, arg1[, arg2..]])	`reflect`的同义词。 (从 Hive 0.9.0开始。)
varies	reflect(class, method[, arg1[, arg2..]])	通过使用反射匹配参数签名来调用 Java 方法。 (从 Hive 0.7.0开始。)有关示例，请参见反映(通用)UDF。
int	hash(a1[, a2...])	返回参数的哈希值。 (从 Hive 0.4 开始.)
string	current_user()	从已配置的身份验证器 Management 器返回当前的用户名(从 Hive 1.2.0开始)。可以与连接时提供的用户相同，但是与某些身份验证 Management 器(例如 HadoopDefaultAuthenticator)不同。
string	logged_in_user()	从会话状态返回当前的用户名(从 Hive 2.2.0开始)。这是连接到 Hive 时提供的用户名。
string	current_database()	返回当前的数据库名称(从 Hive 0.13.0开始)。
string	md5(string/binary)	计算字符串或二进制文件的 MD5 128 位校验和(从 Hive 1.3.0开始)。该值以 32 个十六进制数字的字符串形式返回，如果参数为 NULL，则返回 NULL。例如：md5('ABC')='902fbdd2b1df0c4f70b4a5d23525e932'。
string	sha1(string/binary)
sha(string/binary)	计算字符串或二进制文件的 SHA-1 摘要，并以十六进制字符串形式返回值(从 Hive 1.3.0开始)。例如：sha1('ABC')='3c01bdbb26f358bab27f267924aa2c9a03fcfdb8'。
bigint	crc32(string/binary)	计算字符串或二进制参数的循环冗余校验值，并返回 bigint 值(从 Hive 1.3.0起)。例如：crc32('ABC')= 2743272264.
string	sha2(string/binary，int)	计算 SHA-2 系列哈希函数(SHA-224，SHA-256，SHA-384 和 SHA-512)(从 Hive 1.3.0起)。第一个参数是要哈希的字符串或二进制。第二个参数表示结果的所需位长，该位的值必须为 224、256、384、512 或 0(等于 256)。从 Java 8 开始支持 SHA-224.如果任一参数为 NULL 或哈希长度不是允许的值之一，则返回值为 NULL。例如：sha2('ABC'，256)='b5d4045c3f466fa91fe2cc6abe79232a1a57cdf104f7a26e716e0a1e2789df78'。
binary	aes_encrypt(Importing 字符串/二进制，密钥字符串/二进制)	使用 AES 加密 Importing(自 Hive 1.3.0起)。可以使用 128、192 或 256 位的密钥长度。如果安装了 Java 密码学扩展(JCE)无限强度管辖权策略文件，则可以使用 192 位和 256 位密钥。如果任一参数为 NULL 或密钥长度不是允许的值之一，则返回值为 NULL。例如：base64(aes_encrypt('ABC'，'1234567890123456'))='y6Ss zCYObpCbgfWfyNWTw =='。
binary	aes_decrypt(Importing 二进制，密钥字符串/二进制)	使用 AES 解密 Importing(自 Hive 1.3.0起)。可以使用 128、192 或 256 位的密钥长度。如果安装了 Java 密码学扩展(JCE)无限强度管辖权策略文件，则可以使用 192 位和 256 位密钥。如果任一参数为 NULL 或密钥长度不是允许的值之一，则返回值为 NULL。例如：aes_decrypt(unbase64('y6Ss zCYObpCbgfWfyNWTw ==')，'1234567890123456')='ABC'。
string	version()	返回 Hive 版本(从 Hive 2.1.0开始)。该字符串包含 2 个字段，第一个是内部版本号，第二个是内部散列。示例：“ select version();”可能会返回“ 2.1.0.2.5.0.0-1245 r027527b9c5ce1a3d7d0b6d2e6de2378fb0c39232”。实际结果将取决于您的构建。
bigint	surrogate_key([write_id_bits，task_id_bits])	在向表中 Importing 数据时自动为行生成数字 ID。只能用作酸表或仅插入表的默认值。

xpath

LanguageManual XPathUDF中描述了以下功能：

xpath，xpath_short，xpath_int，xpath_long，xpath_float，xpath_double，xpath_number，xpath_string

get_json_object

支持受限版本的 JSONPath：

$：根对象
。：子运算符
[]：数组的下标运算符
*：[]的通配符

不支持的语法值得注意：

：零长度字符串作为键
..：递归下降
@：当前对象/元素
()：脚本表达式
？()：过滤(脚本)表达式。
[，]：联合运算符
[start：end.step]：数组切片运算符

示例：src_json 表是单列(json)，单行表：

+----+
                               json
+----+
{"store":
  {"fruit":\[{"weight":8,"type":"apple"},{"weight":9,"type":"pear"}],
   "bicycle":{"price":19.95,"color":"red"}
  },
 "email":"amy@only_for_json_udf_test.net",
 "owner":"amy"
}
+----+

可以使用以下查询来提取 json 对象的字段：

hive> SELECT get_json_object(src_json.json, '$.owner') FROM src_json;
amy

hive> SELECT get_json_object(src_json.json, '$.store.fruit\[0]') FROM src_json;
{"weight":8,"type":"apple"}

hive> SELECT get_json_object(src_json.json, '$.non_exist_key') FROM src_json;
NULL

内置的汇总函数(UDAF)

Hive 支持以下内置的聚合函数：

Return Type	Name(Signature)	Description
BIGINT	count(*)，count(expr)，count(DISTINCT expr [，expr ...])	count(*)-返回检索到的行总数，包括包含 NULL 值的行。

count(expr)-返回提供的表达式为非 NULL 的行数。
count(DISTINCT expr [，expr])-返回为其提供的表达式唯一且非 NULL 的行数。可以使用hive.optimize.distinct.rewrite来优化执行。
|| DOUBLE | sum(col)，sum(DISTINCT col)|返回组中元素的总和或组中列的不同值的总和。
|| DOUBLE | avg(col)，avg(DISTINCT col)|返回组中元素的平均值或组中列的不同值的平均值。
| DOUBLE | min(col)|返回组中列的最小值。
| DOUBLE | max(col)|返回组中列的最大值。
|| DOUBLE | variance(col)，var_pop(col)|返回组中数字列的方差。
|| DOUBLE | var_samp(col)|返回组中数字列的无偏 samples 方差。
| DOUBLE | stddev_pop(col)|返回组中数字列的标准偏差。
| DOUBLE | stddev_samp(col)|返回组中数字列的无偏 samples 标准差。
| DOUBLE | covar_pop(col1，col2)|返回组中一对数字列的总体协方差。
|| DOUBLE | covar_samp(col1，col2)|返回组中一对数字列的 samples 协方差。
|| DOUBLE | corr(col1，col2)|返回组中一对数字列的皮尔逊相关系数。
| DOUBLE | percentile(BIGINT col，p)|返回组中列的精确 pth 百分位数(不适用于浮点类型)。 p 必须在 0 到 1 之间。注意：只能为整数值计算真实的百分位数。如果您 Importing 的内容不是整数，请使用 PERCENTILE_APPROX。
| array<double> | percentile(BIGINT col，array(p1 [，p2] ...))|返回组中列的确切百分位数 p1，p2，...(不适用于浮点类型)。 pi 必须在 0 到 1 之间。注意：只能为整数值计算真实百分位数。如果您 Importing 的内容不是整数，请使用 PERCENTILE_APPROX。
| DOUBLE | percentile_approx(DOUBLE col，p [，B])|返回组中数字列(包括浮点类型)的大约 pth 百分位数。 B 参数控制近似精度，但以存储为代价。值越高，近似值越好，默认值为 10,000.当 col 中的不同值的数量小于 B 时，这将给出精确的百分位数。
| array<double> | percentile_approx(DOUBLE col，array(p1 [，p2] ...)[，B])|与上述相同，但是接受并返回一个百分数值数组，而不是单个百分数值。
| double | regr_avgx(独立，从属)|相当于 avg(独立)。自Hive 2.2.0。
| double | regr_avgy(独立，从属)|相当于 avg(独立)。自Hive 2.2.0。
| double | regr_count(独立，从属)|返回用于拟合线性回归线的非空对的数量。自Hive 2.2.0。
| double | regr_intercept(独立，从属)|返回线性回归线的 y 截距，即方程式 dependent = a 独立 b 中的 b 值。自Hive 2.2.0。|
| double | regr_r2(独立，从属)|返回确定系数以进行回归。自Hive 2.2.0。|
| double | regr_slope(独立，从属)|返回线性回归线的斜率，即方程式 dependent = a 独立 b 中 a 的值。自Hive 2.2.0。|
| double | regr_sxx(独立，从属)|等效于 regr_count(独立，从属) var_pop(独立)。自Hive 2.2.0。
| double | regr_sxy(独立，从属)|相当于 regr_count(独立，从属) covar_pop(独立，从属)。自Hive 2.2.0。
| double | regr_syy(独立，从属)|等效于 regr_count(独立，从属)* var_pop(独立)。自Hive 2.2.0。
| array<struct { 'x','y' } > | histogram_numeric(col，b)|使用 b 个非均匀间隔的 bin 计算组中数字列的直方图。输出是大小为 b 的双值(x，y)坐标数组，这些数组表示 bin 的中心和高度|
| array | collect_set(col)|返回消除了重复元素的一组对象。
| array | collect_list(col)|返回具有重复项的对象列表。 (自 Hive 0.13.0起。)|
| INTEGER | ntile(INTEGER x)|将有序分区划分为称为桶的x组，并为分区中的每一行分配一个桶号。这样可以轻松计算三分位数，四分位数，十分位数，百分位数和其他常见的汇总统计信息。 (自 Hive 0.11.0起。)|

内置表生成函数(UDTF)

普通的用户定义函数(例如 concat())接受单个 Importing 行并输出单个输出行。相反，表生成函数将单个 Importing 行转换为多个输出行。

行设置列类型	Name(Signature)	Description
T	explode(ARRAY<T> a)	将数组分解为多行。返回具有单列(* col *)的行集，该数组代表数组中每个元素的一行。
Tkey,Tvalue	explode(MAP<Tkey,Tvalue> m)	将 Map 分解为多行。返回具有两列的行集(* key，value)*，ImportingMap 中的每个键值对一行。 (自 Hive 0.8.0起)。
int,T	posexplode(ARRAY<T> a)	使用* int 类型的附加位置列将数组分解为多行(原始数组中项的位置，从 0 开始)。返回具有两列( pos，val *)的行集，该数组中的每个元素一行。
T1,...,Tn	inline(ARRAY<STRUCT<f1:T1,...,fn:Tn>> a)	将结构数组分解为多行。返回具有 N 列的行集(N =结构中顶级元素的数量)，数组中每个结构一行一行。 (从 Hive 0.10开始。)
T1,...,Tn/r	堆栈(int r，T1 V1，...，Tn/r Vn)	将* n 个值 V1，...，Vn 分解为 r 行。每行将具有 n/r 列。 r *必须是常数。

string1,...,stringn	json_tuple(字符串 jsonStr，字符串 k1，...，字符串 kn)	接收 JSON 字符串和一组* n 键，并返回 n *值的 Tuples。这是`get_json_object` UDF 的一种更有效的版本，因为它只需一次调用就可以获取多个键。
string 1,...,stringn	parse_url_tuple(字符串 urlStr，字符串 p1，...，字符串 pn)	接受 URL 字符串和一组* n * URL 部分，并返回* n *值的 Tuples。这类似于`parse_url()` UDF，但可以一次从 URL 中提取多个部分。有效的部件名称是：HOST，PATH，QUERY，REF，PROTOCOL，AUTHORITY，FILE，USERINFO，QUERY：\ 。

Usage Examples

explode (array)

select explode(array('A','B','C'));
select explode(array('A','B','C')) as col;
select tf.* from (select 0) t lateral view explode(array('A','B','C')) tf;
select tf.* from (select 0) t lateral view explode(array('A','B','C')) tf as col;

col
A
B
C

explode (map)

select explode(map('A',10,'B',20,'C',30));
select explode(map('A',10,'B',20,'C',30)) as (key,value);
select tf.* from (select 0) t lateral view explode(map('A',10,'B',20,'C',30)) tf;
select tf.* from (select 0) t lateral view explode(map('A',10,'B',20,'C',30)) tf as key,value;

key	value
A	10
B	20
C	30

posexplode (array)

select posexplode(array('A','B','C'));
select posexplode(array('A','B','C')) as (pos,val);
select tf.* from (select 0) t lateral view posexplode(array('A','B','C')) tf;
select tf.* from (select 0) t lateral view posexplode(array('A','B','C')) tf as pos,val;

pos	val
0	A
1	B
2	C

内联(结构数组)

select inline(array(struct('A',10,date '2015-01-01'),struct('B',20,date '2016-02-02')));
select inline(array(struct('A',10,date '2015-01-01'),struct('B',20,date '2016-02-02'))) as (col1,col2,col3);
select tf.* from (select 0) t lateral view inline(array(struct('A',10,date '2015-01-01'),struct('B',20,date '2016-02-02'))) tf;
select tf.* from (select 0) t lateral view inline(array(struct('A',10,date '2015-01-01'),struct('B',20,date '2016-02-02'))) tf as col1,col2,col3;

col1	col2	col3
A	10	2015-01-01
B	20	2016-02-02

stack (values)

select stack(2,'A',10,date '2015-01-01','B',20,date '2016-01-01');
select stack(2,'A',10,date '2015-01-01','B',20,date '2016-01-01') as (col0,col1,col2);
select tf.* from (select 0) t lateral view stack(2,'A',10,date '2015-01-01','B',20,date '2016-01-01') tf;
select tf.* from (select 0) t lateral view stack(2,'A',10,date '2015-01-01','B',20,date '2016-01-01') tf as col0,col1,col2;

col0	col1	col2
A	10	2015-01-01
B	20	2016-01-01

使用语法“ SELECT udtf(col)AS colAlias ...”有一些限制：

SELECT 中不允许其他表达式
不支持 SELECT pageid，explode(adid_list)AS myCol ...
UDTF 不能嵌套
不支持 SELECT explode(explode(adid_list))AS myCol ...
不支持 GROUP BY/CLUSTER BY/DISTRIBUTE BY/SORT BY
SELECT explode(adid_list)AS myCol ...不支持 GROUP BY myCol

不具有这些限制的其他语法，请参见LanguageManual LateralView。

如果要创建自定义 UDTF，也请参见Writing UDTFs。

explode

explode()接受数组(或 Map)作为 Importing，并将数组(Map)的元素作为单独的行输出。 UDTF 可以在 SELECT 表达式列表中使用，也可以作为 LATERAL VIEW 的一部分使用。

作为在 SELECT 表达式列表中使用explode()的示例，请考虑一个名为 myTable 的表，该表具有单列(myCol)和两行：

Array<int> myCol
[100,200,300]
[400,500,600]

然后运行查询：

SELECT explode(myCol) AS myNewCol FROM myTable;

will produce:

(int) myNewCol
100
200
300
400
500
600

Maps 的用法类似：

SELECT explode(myMap) AS (myMapKey, myMapValue) FROM myMapTable;

posexplode

Version

自 Hive 0.13.0 起可用。参见HIVE-4943。

posexplode()与explode类似，但它不仅返回数组的元素，还返回元素及其在原始数组中的位置。

作为在 SELECT 表达式列表中使用posexplode()的示例，请考虑一个名为 myTable 的表，该表具有单列(myCol)和两行：

Array<int> myCol
[100,200,300]
[400,500,600]

然后运行查询：

SELECT posexplode(myCol) AS pos, myNewCol FROM myTable;

will produce:

(int) pos	(int) myNewCol
1	100
2	200
3	300
1	400
2	500
3	600

json_tuple

Hive 0.7 中引入了新的 json_tuple()UDTF。它使用一组名称(键)和一个 JSON 字符串，并使用一个函数返回值的 Tuples。这比调用 GET_JSON_OBJECT 从单个 JSON 字符串中检索多个密钥要有效得多。在任何情况下，单个 JSON 字符串都会被解析多次，如果您解析一次 JSON_TUPLE，查询将更加高效。由于 JSON_TUPLE 是 UDTF，因此您将需要使用LATERAL VIEW语法来实现相同的目标。

For example,

select a.timestamp, get_json_object(a.appevents, '$.eventid'), get_json_object(a.appenvets, '$.eventname') from log a;

应该更改为：

select a.timestamp, b.*
from log a lateral view json_tuple(a.appevent, 'eventid', 'eventname') b as f1, f2;

parse_url_tuple

parse_url_tuple()UDTF 与 parse_url()相似，但是可以提取给定 URL 的多个部分，以 Tuples 形式返回数据。可以通过将冒号和键附加到 partToExtract 参数来提取 QUERY 中特定键的值，例如 parse_url_tuple('http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1' ，'QUERY：k1'，'QUERY：k2')返回值为'v1'，'v2'的 Tuples。这比多次调用 parse_url()更有效。所有 Importing 参数和输出列类型都是字符串。

SELECT b.*
FROM src LATERAL VIEW parse_url_tuple(fullurl, 'HOST', 'PATH', 'QUERY', 'QUERY:id') b as host, path, query, query_id LIMIT 1;

对 f(列)进行分组和排序

典型的 OLAP 模式是您有一个 timestamp 列，并且希望按每日或其他较不精确的日期窗口进行分组，而不是按秒进行分组。因此，您可能要选择 concat(year(dt)，month(dt))，然后在该 concat()上分组。但是，如果您尝试在应用了函数和别名的列上使用 GROUP BY 或 SORT BY，如下所示：

select f(col) as fc, count(*) from table_name group by fc;

你会得到一个错误：

FAILED: Error in semantic analysis: line 1:69 Invalid Table Alias or Column Reference fc

因为您无法对已应用功能的列别名进行 GROUP BY 或 SORT BY。有两种解决方法。首先，您可以使用子查询来重新构造此查询，这有点复杂：

select sq.fc,col1,col2,...,colN,count(*) from
  (select f(col) as fc,col1,col2,...,colN from table_name) sq
 group by sq.fc,col1,col2,...,colN;

或者您可以确保不使用更简单的列别名：

select f(col) as fc, count(*) from table_name group by f(col);

如果您想进一步讨论，请与 RiotGames dot com 的 Tim Ellis(tellis)联系。

Utility Functions

Function Name	Return Type	Description	To Run
version	String	提供 Hive 版本详细信息(软件包内置版本)	select version();
buildversion	String	版本功能的扩展，其中包括校验和	select buildversion();

UDF internals

UDF 的评估方法的上下文一次是一行。像这样的 UDF 的简单调用

SELECT length(string_col) FROM table_name;

将评估作业的 Map 部分中每个 string_col 值的长度。在 Map 端评估 UDF 的副作用是您无法控制发送到 Map 器的行的 Sequences。发送到 Map 器的文件拆分的序列化 Sequences 与此相同。任何 reduce 边操作(例如 SORT BY，ORDER BY，常规 JOIN 等)将应用于 UDF 输出，就好像它只是表的另一列一样。这很好，因为 UDF 的评估方法的上下文一次只能排成一行。

如果您想控制将哪些行发送到相同的 UDF(可能以什么 Sequences)，您将敦促在简化阶段对 UDF 进行评估。这可以通过使用分配依据，排序依据，分组依据实现。查询示例为：

SELECT reducer_udf(my_col, distribute_col, sort_col) FROM
(SELECT my_col, distribute_col, sort_col FROM table_name DISTRIBUTE BY distribute_col SORT BY distribute_col, sort_col) t

但是，有人可能会争辩说，控制发送到同一 UDF 的行集的前提是在该 UDF 中进行聚合。在这种情况下，使用用户定义的聚合函数(UDAF)是更好的选择。您可以阅读有关编写 UDAF here的更多信息。或者，您可以使用Hive 的转换功能使用自定义的 reduce 脚本来完成相同的任务。这两个选项都将在归约方面进行汇总。

创建自定义 UDF

有关如何创建自定义 UDF 的信息，请参见Hive Plugins和Create Function。

选择 explode(array('A'，'B'，'C'));选择 explode(array('A'，'B'，'C'))作为 col;从(选择 0)t 中选择 tf.侧面爆炸(array('A'，'B'，'C'))tf;从(选择 0)中选择 tf. t 侧面爆炸(array('A'，'B'，'C')) tf 作为 col;

Name	Apache Hive 中文手册
Version
Language
Badge
Last Updated	2021-07-05T14:25:28