Hive运算符和函数使用方法（全）（中文文档, 手动修改翻译并测试）
目录
文章目录
参考文档
翻译整理自Hive官网LanguageManual UDF和LanguageManual WindowingAndAnalytics，建议查看官方英文文档了解更多。
在谷歌翻译的基础上测试函数并修改为可理解的文字描述，并增加了测试例子
文档整理时间2021-03-25
0 前言
不区分大小写
所有Hive关键字都不区分大小写，包括Hive运算符和函数的名称。
在Beeline或CLI中，使用以下命令显示函数和函数的使用方法：
SHOW FUNCTIONS;
DESCRIBE FUNCTION <function_name>;
DESCRIBE FUNCTION EXTENDED <function_name>;
支持
select + <function_name>来测试函数作用。
select round(2.5);
1 内置函数 UDFs
UDFs英文全称User-Defined Functions
个人理解：进去一个数据，出来一个数据
1.1 数学函数
Hive支持以下内置数学函数；当参数为NULL时，大多数返回NULL
| 返回类型 | 函数 | 描述 |
|---|---|---|
| DOUBLE | round(DOUBLE a) | 返回a的四舍五入后的BIGINT值。 |
| DOUBLE | round(DOUBLE a, INT d) | 返回a四舍五入到小数点后d位。 |
| DOUBLE | bround(DOUBLE a) | 使用HALF_EVEN舍入模式(自Hive 1.3.0, 2.0.0)返回a的四舍五入的BIGINT值。也称为高斯四舍五入或银行家四舍五入。例:bround(2.5) = 2, bround(3.5) = 4。向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数，则左边数字加1，如果为偶数，则左边数字不变。 |
| DOUBLE | bround(DOUBLE a, INT d) | 使用HALF_EVEN舍入模式(自Hive 1.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 | ceil(DOUBLE a), ceiling(DOUBLE a) | 返回大于或等于a的最小BIGINT 值。 |
| DOUBLE | rand(), rand(INT seed) | 返回一个从0到1均匀分布的随机数。可以指定种子将确保生成的随机数是确定性的。 |
| DOUBLE | exp(DOUBLE a), exp(DECIMAL a) | 返回e^a，其中e是自然对数的底数2.71828...。十进制版本添加在Hive 0.13.0。 |
| DOUBLE | ln(DOUBLE a), ln(DECIMAL a) | 以e为底，返回参数a的自然对数。十进制版本添加在Hive 0.13.0。如ln(2.718281828459045)=1.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 | log(DOUBLE base, DOUBLE a)log(DECIMAL base, DECIMAL a) | 返回参数a的以base为底的对数。十进制版本添加在Hive 0.13.0。 |
| DOUBLE | pow(DOUBLE a, DOUBLE p), power(DOUBLE a, DOUBLE p) | 返回 a^p. |
| DOUBLE | sqrt(DOUBLE a), sqrt(DECIMAL a) | 返回a的平方根。十进制版本添加在Hive 0.13.0。 |
| STRING | bin(BIGINT a) | 以二进制格式返回数字(参见这里)。如bin(2)=10, bin(3)=11 |
| STRING | hex(BIGINT a) hex(STRING a) hex(BINARY a) | 如果参数是INT或BINARY，hex将返回STRING类型十六进制的数字。如果是STRING，它将每个字符转换成它的十六进制并返回字符串类型。(参见这里, Hive 0.12.0的BINARY版本。) |
| BINARY | unhex(STRING a) | 与hex相反。将每对字符解释为十六进制数，并转换为该数的字节表示形式。(Hive 0.12.0的BINARY版本，用于返回一个字符串。) |
| STRING | conv(BIGINT num, INT from_base, INT to_base), conv(STRING num, INT from_base, INT to_base) | 将一个数字从给定的进制转换为另一个进制(参见这里)。如conv(2,10,2)=10, 将2从十进制转为二进制 |
| DOUBLE | abs(DOUBLE a) | 返回绝对值。 |
| INT or 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。π=180°（π单位为弧度） |
| DOUBLE | asin(DOUBLE a), asin(DECIMAL a) | 如果-1<=a<=1，则返回a的反sin值，否则返回NULL。十进制版本添加在Hive 0.13.0。asin是sin反函数。 |
| 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的反tan值。十进制版本添加在Hive 0.13.0。 |
| DOUBLE | degrees(DOUBLE a), degrees(DECIMAL a) | 将a的值从弧度转换为角度。十进制版本添加在Hive 0.13.0。 |
| DOUBLE | radians(DOUBLE a), radians(DOUBLE a) | 将a的值从角度转换为弧度。十进制版本添加在Hive 0.13.0。 |
| INT or DOUBLE | positive(INT a), positive(DOUBLE a) | 返回 a。 |
| INT or DOUBLE | negative(INT a), negative(DOUBLE a) | 返回 -a。 |
| DOUBLE or INT | sign(DOUBLE a), sign(DECIMAL a) | 如果a为正数, a返回1.0, 如果a为负数, a返回-1.0，否则返回0.0。十进制版本返回INT而不是DOUBLE。十进制版本添加在Hive 0.13.0。 |
| DOUBLE | e() | 返回e的值。e的值为3.718281828......。 |
| DOUBLE | pi() | 返回pi的值。pi的值为3.1415926535.....。 |
| BIGINT | factorial(INT a) | 返回a的阶乘(如Hive 1.2.0)。有效的a是[0…20]。 |
| DOUBLE | cbrt(DOUBLE a) | 返回a的立方根，返回结果为double值(如Hive 1.2.0)。 |
| INTBIGINT | shiftleft(TINYINT|SMALLINT|INT a, INT b)shiftleft(BIGINT a, INT b) | 位运算，按位左移(如Hive 1.2.0)。如shiftleft(4,1)=8, shiftleft(4,2)=16。 |
| INTBIGINT | shiftright(TINYINT|SMALLINT|INT a, INT b)shiftright(BIGINT a, INT b) | 位运算，按位右移(如Hive 1.2.0)。如shiftright(4,1)=8, shiftright(4,2)=16。 |
| INTBIGINT | shiftrightunsigned(TINYINT|SMALLINT|INT a, INT b),shiftrightunsigned(BIGINT a, INT b) | 按位无符号右移(如Hive 1.2.0)。 |
| 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时返回NULL，并且放宽严格的类型限制，与"<"操作符一致(如Hive 2.0.0)。 |
| INT | width_bucket(NUMERIC expr, NUMERIC min_value, NUMERIC max_value, INT num_buckets) | 通过将expr映射到第i个大小相等的桶，返回0到num_buckets+1之间的整数。bucket是通过将[min_value, max_value]划分为相同大小的区域来创建的。如果expr < min_value，返回1，如果expr > max_value返回num_buckets+1。参见https://docs.oracle.com/cd/B19306_01/server.102/b14200/functions214.htm(自Hive 3.0.0) |
十进制数据类型的数学函数和运算符
版本 在Hive 0.11.0（HIVE-2693）中引入了十进制数据类型。
所有常规算术运算符（例如+，-，*，/）和相关的数学UDF（Floor，Ceil，Round等）都已更新为处理十进制类型。有关支持的UDF的列表，请参阅数学的UDF在hive的数据类型。
1.2 集合函数
Hive支持以下内置的集合函数
| 返回类型 | 函数 | 描述 |
|---|---|---|
| int | size(Map<K.V>) | 返回Map类型中元素的数量。 |
| int | size(Array) | 返回Array类型中元素的数量。 |
| array | map_keys(Map<K.V>) | 返回一个无序数组，包含输入map的key。 |
| array | map_values(Map<K.V>) | 返回一个无序数组，包含输入map的value。 |
| boolean | array_contains(Array, value) | 如果数组中包含value则返回TRUE。 |
| array | sort_array(Array) | 根据数组元素的自然顺序从小到大对输入数组进行排序并返回它(从版本0.9.0开始)。 |
1.3 类型转换函数
Hive支持以下类型转换函数
| 返回类型 | 函数 | 描述 |
|---|---|---|
| binary | binary(string|binary) | 将参数转换为二进制。Casts the parameter into a binary. |
| Expected “=” to follow "type" | cast(expr as ) | 将表达式expr的结果转换为<type>类型。例如，cast(‘1’ as BIGINT)将字符串’1’转换为其整数表示形式。如果转换不成功，则返回null。如果强制转换cast(expr as boolean)，expr为非空字符串返回true。 |
1.4 日期函数
Hive支持以下内置日期函数:
| 返回类型 | 函数 | 描述 |
|---|---|---|
| string | from_unixtime(bigint unixtime[, string format]) | 将unix epoch (从1970-01-01 00:00:00 UTC开始)中的秒数转换为表示当前系统时区中该时刻的时间戳的字符串，默认格式为"1970-01-01 00:00:00"。可以指定格式。如from_unixtime(1615766400)=2021-03-15 00:00:00。from_unixtime(1615766400,‘yyyy’)=2021。 |
| bigint | unix_timestamp() | 获取当前操作系统时间戳(以秒为单位)。这个函数生成的数字看不出具体时间，它的值对于查询执行的范围也不是固定的，因此妨碍了对查询的适当优化——从2.0开始，这个函数就被弃用了，转而使用CURRENT_TIMESTAMP。unix_timestamp()=1616654397。current_timestamp=2021-03-25 14:39:45.094。 |
| 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(string date, string pattern) | 将给定匹配pattern的时间字符串(参见这里)转换为Unix时间戳(以秒为单位)，如果失败不匹配则返回NULL，如unix_timestamp(‘2009-03-20’, ‘yyyy-MM-dd’) = 1237532400。unix_timestamp(‘2009-03-20’, ‘yyyy-MM-dd HH:mm:ss’)=NULL。 |
| pre 2.1.0: string2.1.0 on: date | to_date(string timestamp) | 返回时间戳字符串的年月日部分(pre-Hive 2.1.0): to_date(“1970-01-01 00:00:00”) = “1970-01-01”。从Hive 2.1.0开始，返回一个date对象。在Hive 2.1.0 (Hive -13248)之前，返回类型是一个字符串，因为在创建方法时没有日期类型存在。 |
| int | year(string date) | 返回日期或时间戳字符串的年份部分: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(“1970-11-05 00:00:00”) = 5, day(“1970-11-05”) = 5。dayofmonth(current_timestamp)=25(当前日期)。 |
| int | hour(string date) | 返回时间戳的小时:hour(‘2009-07-30 12:58:59’) = 12, hour(‘12:58:59’) = NULL。 |
| int | minute(string date) | 返回时间戳的分钟。minute(‘2009-07-30 12:58:59’) = 58。 |
| int | second(string date) | 返回时间戳的秒。second(‘2009-07-30 12:58:59’) = 59。 |
| int | weekofyear(string date) | 返回时间戳字符串在一年中第几周:weekofyear(“1970-11-01 00:00:00”) = 44, weekofyear(“1970-01-07”) = 1。 |
| int | extract(field FROM source) | 从源检索字段，如天或小时(如Hive 2.2.0)。源必须是日期、时间戳、时间间隔或可以转换为日期或时间戳的字符串。支持的字段包括:day、dayofweek、hour、minute、month、quarter、second、week和year。示例:select extract(month from “2016-10-20”) 结果为 10。select extract(hour from “2016-10-20 05:06:07”)结果为 5。select extract(dayofweek from “2016-10-20 05:06:07”) 结果为 5。select extract(month from interval ‘1-3’ year to month)结果为 3。select extract(minute from interval ‘3 12:20:30’ day to second) 结果为 20。 |
| int | datediff(string enddate, string startdate) | 返回enddate减去startdate的天数。 |
| pre 2.1.0: string2.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)之前，返回类型是一个字符串，因为在创建方法时没有日期类型存在。 |
| pre 2.1.0: string2.1.0 on: date | date_sub(date/timestamp/string startdate, tinyint/smallint/int days) | 从开始日期中减去天数:date_sub(‘2008-12-31’, 1) = ‘2008-12-30’。在Hive 2.1.0 (Hive -13248)之前，返回类型是一个字符串，因为在创建方法时没有日期类型存在。 |
| timestamp | from_utc_timestamp({any primitive type} ts, string timezone) | 将UTC中的timestamp转换为指定的时区(从Hive 0.8.0)。ts是一个基本类型，包括timestamp/date、tinyint/smallint/int/bigint、float/double和decimal。 ts小数值被认为是秒。整数值被认为是毫秒。例如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, string timezone) | 将给定时区中的timestamp转换为UTC(从Hive 0.8.0).ts是一个基本类型，包括timestamp/date、tinyint/smallint/int/bigint、float/double和decimal。 ts小数值被认为是秒。整数值被认为是毫秒。例如，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调用都会返回相同的值。current_date=2021-03-25。 |
| timestamp | current_timestamp | 返回查询计算开始时指定格式的当前时间戳(从Hive 1.2.0开始)。同一个查询中的所有current_timestamp调用都会返回相同的值。current_timestamp=2021-03-25 14:39:45.094。 |
| string | add_months(string start_date, int num_months, output_date_format) | 返回起始日期之后num_months的日期(自Hive 1.1.0)。start_date是一个字符串，日期或时间戳。num_months是一个整数。如果start_date是一个月的最后一天，或者如果生成月份的天数比start_date的月份的天数少，那么结果就是生成的月份的最后一天。如：add_months(‘2021-01-30’,1)=2021-02-28 。否则，生成月份的日期天数和start_date相同。默认输出格式为’yyyy-MM-dd’，可指定自定义格式。在Hive 4.0.0之前，日期的时间部分会被忽略。在Hive 4.0.0中，add_months支持一个可选参数output_date_format，该参数接受一个表示输出日期格式的字符串。这允许在输出中保留时间格式。例如: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(string date) | 返回日期所属月份的最后一天(如Hive 1.1.0)。date为字符串，格式为’yyyy-MM-dd HH:mm:ss’或’yyyy-MM-dd’。 |
| string | next_day(string start_date, string day_of_week) | 返回距离start_date最近的day_of_week（星期几）的日期(从Hive 1.2.0开始)。start_date是字符串/日期/时间戳。day_of_week由一周中某一天的两个字母、三个字母或全名组成(英文字母，例如:Mo, tuesday, FRIDAY)。start_date的部分时间被忽略。例如:next_day(‘2021-03-25’, ‘tuesday’) = 2021-03-20。返回下一个距离2021-03-25最近的周二的日期。 |
| string | trunc(string date, string format) | 返回日期截断到指定的年的第一个月或月的第一天(从Hive 1.2.0开始)。支持的格式为:MONTH/MON/MM, YEAR/YYYY/YY。例如:trunc(‘2015-03-17’, ‘MM’) = 2015-03-01。trunc(‘2015-03-17’, ‘YY’) = 2015-01-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(date/timestamp/string ts, string fmt) | 将日期/时间戳/字符串格式化为fmt指定格式的字符串值(自Hive 1.2.0)。支持的格式是Java SimpleDateFormat格式。第二个参数fmt应该是常量。例如:date_format(‘2015-04-08’, ‘y’) = ‘2015’。date_format可用于实现其他udf，例如dayname(date) 是 date_format(date, ‘EEEE’)。dayofyear(date) 是 date_format(date, ‘D’)。 |
1.5 条件函数
| 返回类型 | 函数 | 描述 |
|---|---|---|
| T | if(boolean testCondition, T valueTrue, T valueFalseOrNull) | 当testCondition为true时返回valueTrue，否则返回valueFalseOrNull。如：if(1+1=2, true, null) 返回true。if(1+1=2, ‘yes’,‘no’) 返回yes。 |
| boolean | isnull( a ) | 如果a为NULL则返回true，否则返回false。 |
| boolean | isnotnull ( a ) | 如果a不为NULL则返回true，否则返回false。 |
| T | nvl(T value, T default_value) | 如果value为null则返回默认值，否则返回value(如HIve 0.11)。如：nvl(null,‘abc’)=‘abc’。 |
| T | COALESCE(T v1, T v2, …) | 返回第一个不为空的v1 v2…，如果所有v1 v2 …都为空，则返回NULL。 |
| T | CASE a WHEN b THEN c [WHEN d THEN e]* [ELSE f] END | 当a = b时，返回c；当a = d，返回e；否则返回f。[WHEN d THEN e]能写多个。如：CASE 1 WHEN 2 THEN 3 WHEN 1 THEN 4 ELSE 5 END返回5。注意end不要忘记写。 |
| T | CASE WHEN a THEN b [WHEN c THEN d]* [ELSE e] END | 当a = true时，返回b；当c = true时，返回d；否则返回e。[WHEN c THEN d]能写多个。返回第一个为true的值。如：CASE WHEN true THEN 1 WHEN true THEN 2 ELSE 3 END返回1。 |
| T | nullif( a, b ) | 如果a=b，返回NULL；否则返回a (as of Hive 2.3.0)。CASE WHEN a = b then NULL else a的简写。 |
| void | assert_true(boolean condition) | 如果condition不为true，则抛出异常，否则返回null(如Hive 0.8.0)。例如，select assert_true (2<1)会报错抛出异常。 |
1.6 字符串函数
Hive支持以下内置字符串函数
| 返回类型 | 函数 | 描述 |
|---|---|---|
| int | ascii(string str) | 返回str第一个字符的ascii。如：ascii(‘abc’)=97。ascii(‘ab’)=97。 |
| string | base64(binary bin) | 将bin从二进制转换为base 64字符串(如Hive 0.12.0)。如：base64(unbase64(‘hello’))=hello。 |
| binary | unbase64(string str) | 将str从base 64字符串转换为二进制(如Hive 0.12.0)。如：unbase64(‘hello’)。 |
| int | character_length(string str) | 返回str中包含的UTF-8字符数量(自Hive 2.2.0)。char_length函数是这个函数的简写。如：character_length(‘hello’)=5。 |
| string | chr(bigint|double A) | 返回ASCII值A对应的字符(如Hive1.3.0和2.1.0)。如果A大于256，则结果等于chr(A % 256)。例如:select chr(88); 返回 “X”。select chr(97); 返回 “a”。 |
| string | concat(string|binary A, string|binary B…) | 按传入参数顺序拼接字符串或字节，返回字符串或字节串。无分隔符。例如，concat(‘foo’, ‘bar’)结果为’foobar’。注意，这个函数可以接受任意数量的输入字符串。 |
| array<struct<string,double>> | context_ngrams(array<array>, array, int K, int pf) | Returns the top-k contextual N-grams from a set of tokenized sentences, given a string of “context”. See StatisticsAndDataMining for more information. |
| string | concat_ws(string SEP, string A, string B…) | 与concat()函数类似，但可以自定义分隔符SEP。如select concat_ws( ‘.’ , ‘www’, ‘idataduck’ ,‘com’)将返回’www.idataduck.com’ |
| string | concat_ws(string SEP, string A,array) | 与concat_ws()函数类似，但是接受一个字符串数组。(自Hive 0.9.0)。可以将A与数组中的元素按照指定的SEP拼接起来。如：select concat_ws( ‘.’ , ‘www’, array(‘idataduck’ , ‘com’ ))将返回’www.idataduck.com’ |
| string | decode(binary bin, string charset) | 使用提供的字符集(‘US-ASCII’, ‘ISO-8859-1’, ‘UTF-8’, ‘UTF-16BE’, ‘UTF-16LE’, ‘UTF-16’)中的一个将第一个二进制参数解码为字符串。如果任意一个参数为空，结果也将为空。(自Hive 0.12.0。) |
| string | elt(N int,str1 string,str2 string,str3 string,…) | 返回索引N位置的字符串，索引从1开始。例如elt(2, ‘hello’, ‘world’)返回’world’。如果N小于1或大于参数个数，则返回NULL。(见这里) |
| binary | encode(string src, string charset) | 使用提供的字符集(‘US-ASCII’, ‘ISO-8859-1’, ‘UTF-8’, ‘UTF-16BE’, ‘UTF-16LE’, ‘UTF-16’)中的一个将第一个字符串参数编码为二进制。如果任意一个参数为空，结果也将为空。(自Hive 0.12.0。) |
| int | field(val T,val1 T,val2 T,val3 T,…) | 返回val在val1,val2,val3，…中的索引, 索引从1开始。如果没有找到，则返回0。例如field(‘world’, ‘say’, ‘hello’, ‘world’)返回3。支持所有基本类型，参数使用str.equals(x)进行比较。如果val为NULL，则返回值为0。(见这里) |
| int | find_in_set(string str, string strList) | 返回strList中第一次出现的str的索引，索引从1开始。其中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中浮动类型的bug， Hive 0.14.0中增加了十进制类型的支持)，如：format_number(105, 2)=105.00，format_number(105.55, 2)=105.6。 |
| string | get_json_object(string json_string, string path) | 根据指定的json路径从json字符串中提取json对象，并返回提取的json对象的json字符串。如果输入的json字符串无效，则返回null。注意: json路径只能包含字符 [0-9a-z_], i.e., 不允许大写和特殊字符. 另外keys 不能以数字开头，这是由于对Hive列名的限制。如：get_json_object(’{“info”:{“name”:“xhx”,“age”:18}}’, ’
.
i
n
f
o
′
)
=
"
n
a
m
e
"
:
"
x
h
x
"
,
"
a
g
e
"
:
18
。
支
持
‘
.info')={"name":"xhx","age":18}。支持`
.info′)="name":"xhx","age":18。支持‘ 跟对象，. 子操作，* 通配符`等。执行describe extended get_json_object查看更多。 |
| boolean | in_file(string str, string filename) | 如果字符串str与filename文件内容中某一整行完全一致，则返回true。否则返回false。filename为本地某个文件的路径，且该文件要存在hive server所在机器。 |
| int | instr(string str, string substr) | 返回substr 在 str第一次出现的索引。如果任意一个参数为 null则返回null ， 如果 substr 不能在 str找到返回0。注意str中的第一个字符的索引为1。 |
| int | length(string A) | 返回字符串A的长度。 |
| int | locate(string substr, string str[, int pos]) | 返回substr在str中的索引pos之后（包括pos）第一次出现的索引。pos不写默认为1，如果pos为0或者大于str长度返回0，pos为可选参数。如果 substr 不能在 str索引pos之后找到返回0。str中的第一个字符的索引为1。 |
| string | lower(string A) lcase(string A) | 返回将字符串A中的所有字符转换为小写。例如，lower(‘fOoBaR’)将返回 ‘foobar’。 |
| string | lpad(string str, int len, string pad) | 如果pad为空，则返回值为null。如果str的长度大于len，则str会从第一个字符开始保留len长度的字符。如果str的长度小于len，则用pad从左侧填充到str，使str的长度填充为len长度。如：lpad(‘abcd’, 2, ‘h’)=ab，lpad(‘abcd’, 6, ‘h’)=hhabcd。 |
| string | ltrim(string A) | 返回去掉字符串A的左边的空格得到的字符串。例如，ltrim(’ foobar ') 返回 'foobar '。 |
| array<struct<string,double>> | ngrams(array<array>, int N, int K, int pf) | Returns the top-k N-grams from a set of tokenized sentences, such as those returned by the sentences() UDAF. See StatisticsAndDataMining for more information. |
| int | octet_length(string str) | 返回用于保存UTF-8编码的字符串str的字节数((自Hive 2.2.0)。注意，octet_length(str)可能比character_length(str)大。如：character_length(‘你好’)=2，octet_length(‘你好’)=6。 |
| string | parse_url(string urlString, string partToExtract [, string 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中特定key的值也可以通过提供key作为第三个参数来提取，例如：parse_url(‘http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1’, ‘QUERY’, ‘k1’)返回’v1’。 |
| string | printf(String format, Obj… args) | 根据printf-style格式化字符串标准输出(如Hive 0.9.0)。如select printf(“Hello World %d %s”,100,“days”)返回’Hello World 100 days’。%d 十进制有符号整数，%s 字符串。点击这里查看更多。 |
| string | quote(String text) | version3.0.0.3.0 Function ‘quote’ does not exist 返回带引号的字符串(包括单引号的转义字符HIVE-4.0.0) input output NULL NULL DONT ‘DONT’ DON’T 'DON\‘T’ |
| string | regexp_extract(string subject, string pattern, int index) | 返回匹配pattern的字符串。例如： regexp_extract(‘foothebar’, ‘foo(.*?)(bar)’, 2) 返回’bar.’ 注意，在使用预定义字符类时需要注意: 使用 ‘\s’ 作为第二个参数将匹配字母 s; ‘\\s’ 用于匹配空格等, ‘index’ 参数是Java regex Matcher group() method index. 看docs/api/java/util/regex/Matcher.html了解更多。 |
| string | regexp_replace(string INITIAL_STRING, string PATTERN, string REPLACEMENT) | 返回将INITIAL_STRING中与PATTERN中定义的java正则表达式语法匹配的所有子字符串替换为REPLACEMENT字符串。例如，regexp_replace(“foobar”, “oo|ar”, “”) 返回 ‘fb’。注意，在使用预定义字符类时需要注意:使用’\s’作为第二个参数将匹配字母s;’\\s’用于匹配空格等。 |
| string | repeat(string str, int n) | 重复str n次。如：repeat(‘a’,2)=‘aa’ |
| string | replace(string A, string OLD, string NEW) | 将字符串A中所有的OLD替换为NEW(自Hive 1.3.0和2.1.0)。示例:选择replace(“ababab”, “abab”, “Z”);返回’Zab’。 |
| string | reverse(string A) | 返回A反转后的字符串。如：reverse(‘idataduck’)=‘kcudatadi’ |
| string | rpad(string str, int len, string pad) | 如果pad为空，则返回值为null。如果str的长度大于len，则str会从第一个字符开始保留len长度的字符。如果str的长度小于len，则用pad从右侧填充到str，使str的长度填充为len长度。如：rpad(‘abcd’, 2, ‘h’)=ab，rpad(‘abcd’, 6, ‘h’)=abcdhh。 |
| string | rtrim(string A) | 返回去掉字符串A的右边的空格得到的字符串。例如，rtrim(’ foobar ‘) 返回 ’ foobar’。 |
| array<array> | sentences(string str, string lang, string locale) | 将自然语言文本字符串标记为单词和句子，其中每个句子在适当的句子边界被分割，并作为单词数组返回。'lang’和’locale’是可选参数。例如，sentences(‘Hello there! How are you?’)返回( [[“Hello”,“there”],[“How”,“are”,“you”]]。 |
| string | space(int n) | 返回n个空格组成的字符串。 |
| array | split(string str, string pat) | 根据pat拆分str (pat是一个正则表达式)，返回一个数组。如split(‘ab,v’, ‘,’)返回[“ab”,“v”]。 |
| map<string,string> | str_to_map(text[, delimiter1, delimiter2]) | 将字符串转为map，使用两个分隔符将text分割为键-值对。Delimiter1将text分隔为K-V对，Delimiter2将每个K-V对分隔。Delimiter1默认分隔符是’,’ delimiter2的默认分隔符是’:’。如：str_to_map(‘name:xhx,age:23’)将返回{“name”:“xhx”,“age”:“23”}。 |
| string | substr(string|binary A, int start) substring(string|binary A, int start) | 返回A从start位置开始直到字符串A结束的字节数组的子字符串或切片。例如，substr(‘foobar’, 4)将会返回’bar’(参见这里)。位置从1开始。 |
| string | substr(string|binary A, int start, int len) substring(string|binary A, int start, int len) | 返回长度为len的A从start位置开始直到字符串A结束的字节数组的子字符串或切片。例如，substr(‘foobar’, 4, 1) 将返回 ‘b’(参见这里)。位置从1开始。 |
| string | substring_index(string A, string delim, int count) | 返回在分隔符delim出现之前字符串A的子字符串(从Hive 1.3.0开始)。如果count为正数，则返回第count个分隔符左侧的所有内容(从左侧开始计数)。如果count为负数，则返回第count分隔符(从右开始计数)右侧的所有内容。Substring_index在搜索delim时执行区分大小写的匹配。例如:substring_index(‘www.apache.org’, ‘.’ , 2) = ‘www.apache’。substring_index(‘www.apache.org’, ‘.’ , -1) = ‘org’。 |
| string | translate(string|char|varchar input, string|char|varchar from, string|char|varchar to) | 通过将’ from ‘字符串中的字符替换为’ to ‘字符串中的对应字符来转换输入字符串。字符与字符一一对应，这类似于PostgreSQL中的’ translate ‘函数。如果这个UDF的任何参数都是NULL，那么结果也是NULL。(对于string类型从Hive 0.10.0开始可用，Char/varchar支持从Hive 0.14.0增加)。如translate(‘abcde’,‘ace’,‘12’)=‘1b2d’，1替换a ， 2替换c，’'替换e。 |
| string | trim(string A) | 返回字符串A的两端去掉空格后的字符串。例如，trim(’ f oobar ‘) 返回’f oobar’ |
| string | upper(string A) ucase(string A) | 返回将字符串A中的所有字符转换为大写的结果字符串。例如，upper(‘fOoBaR’) 结果为 ‘FOOBAR’。 |
| string | initcap(string A) | 返回字符串，每个单词的首字母为大写，其他字母均为小写。单词由空格分隔。(从Hive 1.1.0开始)，如：initcap(‘hello WORLD’)=‘Hello World’。 |
| int | levenshtein(string A, string B) | 返回两个字符串之间的编辑距离(Levenshtein距离)(从Hive 1.2.0开始)。例如，levenshtein(‘kitten’, ‘sitting’)结果为 3。Levenshtein距离为利用字符操作，把字符串A转换成字符串B所需要的最少操作数。允许删除一个字符 ，插入一个字符 b，修改一个字符 c。 |
| string | soundex(string A) | 返回字符串A的soundex值(从Hive 1.2.0开始)。例如，soundex(‘Miller’) 结果为 M460。soundex(‘Hello’)=H400。 |
1.7 数据屏蔽函数
Hive支持以下内置的数据屏蔽功能
| 返回类型 | 函数 | 描述 |
|---|---|---|
| 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]) | 返回str的屏蔽后的数据，只屏蔽后n个值(自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) | hash值是一致固定的，可以用于跨表级联join被屏蔽的值。对于非字符串类型，这个函数返回null。 |
1.8 加密等其他函数
| 返回类型 | 函数 | 描述 |
|---|---|---|
| varies | java_method(class, method[, arg1[, arg2…]]) | Synonym for reflect. (As of Hive 0.9.0.) |
| varies | reflect(class, method[, arg1[, arg2…]]) | Calls a Java method by matching the argument signature, using reflection. (As of Hive 0.7.0.) See Reflect (Generic) UDF for examples. |
| int | hash(a1[, a2…]) | 返回参数的hash值。(从Hive 0.4开始) |
| string | current_user() | 从配置的身份验证管理器返回当前用户名(从Hive 1.2.0开始)。可能与连接时提供的用户相同，但对于一些身份验证管理器(例如HadoopDefaultAuthenticator)，可能是不同的。 |
| string | logged_in_user() | 从会话状态返回当前用户名(从Hive 2.2.0开始)。这是连接Hive时提供的用户名。 |
| string | current_database() | 返回当前数据库名(从Hive 0.13.0开始)。 |
| string | md5(string/binary) | 计算字符串或二进制文件(从Hive 1.3.0)的MD5 128位校验和。该值以32位十六进制数字的字符串形式返回，如果参数为NULL则返回NULL。示例: md5(‘ABC’) = ‘902fbdd2b1df0c4f70b4a5d23525e932’。 |
| string | sha1(string/binary)sha(string/binary) | 计算字符串或二进制的SHA-1 digest加密并以十六进制字符串的形式返回值(从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)。第一个参数是要算hash值的字符串或二进制数。第二个参数表示结果所需的位长度，其值必须为224、256、384、512或0(相当于256)。从Java 8开始就支持SHA-224。如果任意一个参数为NULL或散列长度不是允许的值之一，则返回值为NULL。例如: sha2(‘ABC’, 256) = ‘b5d4045c3f466fa91fe2cc6abe79232a1a57cdf104f7a26e716e0a1e2789df78’。 |
| binary | aes_encrypt(input string/binary, key string/binary) | 使用AES加密输入(从Hive 1.3.0)。密钥长度可以是128位、192位或256位。如果安装了Java加密扩展(JCE)无限强度权限策略文件，则可以使用192位和256位密钥。如果任意一个参数为NULL或键长度不是允许的值之一，则返回值为NULL。示例:base64(aes_encrypt(‘ABC’, ‘1234567890123456’)) = ‘y6Ss+zCYObpCbgfWfyNWTw==’。 |
| binary | aes_decrypt(input binary, key string/binary) | 使用AES 解密输入(从 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个字段，第一个是构建号，第二个是构建hash值。例如:“select version();” 或许返回"2.1.0.2.5.0.0-1245 r027527b9c5ce1a3d7d0b6d2e6de2378fb0c39232"。实际结果将取决于您的构建。 |
| bigint | surrogate_key([write_id_bits, task_id_bits]) | 在向表中输入数据时，自动为行生成数字id。只能作为acid或仅插入表的默认值。 |
| string | uuid() | 返回一个普遍唯一的标识符（uuid）字符串。 |
xpath
LanguageManual XPathUDF中描述了以下功能：
- xpath, xpath_short, xpath_int, xpath_long, xpath_float, xpath_double, xpath_number, xpath_string
get_json_object
字符串函数中get_json_object(string json_string, string path)函数
支持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
2 内置聚合函数UDAF
UDAF英文全称 User-Defined Aggregate Functions
个人理解：进去多行，出来一行
Hive支持以下内置的聚合函数:
| 返回类型 | 函数 | 描述 |
|---|---|---|
| BIGINT | count(*), count(expr), count(DISTINCT expr[, expr…]) | count(*) -返回检索到的行总数，包括包含空值的行。count(expr) -返回所提供的表达式非空的行数。count(DISTINCT expr[， expr]) -返回所提供的表达式是唯一的和非空的行数。可以使用hive.optimize.distinct.rewrite来优化它的执行。 |
| DOUBLE | sum(col), sum(DISTINCT col) | 返回组中col的和或组中col的不同值的和。 |
| DOUBLE | avg(col), avg(DISTINCT col) | 返回组中col的平均值或组中col的不同值的平均值。 |
| DOUBLE | min(col) | 返回组中col的最小值。 |
| DOUBLE | max(col) | 返回组中col的最大值。 |
| DOUBLE | variance(col), var_pop(col) | 返回组中数字col的总体方差。方差分母为n |
| DOUBLE | var_samp(col) | 返回组中数字col的样本方差。样本方差分母为n-1 |
| DOUBLE | stddev_pop(col) | 返回组中数字col的标准偏差(标准差)。方差开平方根 |
| DOUBLE | stddev_samp(col) | 返回组中数字col的样本标准偏差。样本方差开平方根 |
| DOUBLE | covar_pop(col1, col2) | 返回组中一对数字列的总体协方差。 |
| DOUBLE | covar_samp(col1, col2) | 返回组中一对数字列的样本协方差。 |
| DOUBLE | corr(col1, col2) | 返回组中一对数字列的皮尔逊相关系数。 |
| DOUBLE | percentile(BIGINT col, p) | 返回组中col的第p个百分点的值(不适用浮点类型)。p必须在0和1之间。注意:真正的百分位数只能计算整数值。如果输入是非整数，请使用percentile_approx函数。 |
| array | percentile(BIGINT col, array(p1 [, p2]…)) | Returns the exact percentiles p1, p2, … of a column in the group (does not work with floating point types). pi must be between 0 and 1. NOTE: A true percentile can only be computed for integer values. Use PERCENTILE_APPROX if your input is non-integral. |
| DOUBLE | percentile_approx(DOUBLE col, p [, B]) | Returns an approximate pth percentile of a numeric column (including floating point types) in the group. The B parameter controls approximation accuracy at the cost of memory. Higher values yield better approximations, and the default is 10,000. When the number of distinct values in col is smaller than B, this gives an exact percentile value. |
| array | percentile_approx(DOUBLE col, array(p1 [, p2]…) [, B]) | Same as above, but accepts and returns an array of percentile values instead of a single one. |
| double | regr_avgx(independent, dependent) | 相当于 avg(dependent).从Hive 2.2.0。 |
| double | regr_avgy(independent, dependent) | 相当于 avg(independent).从Hive 2.2.0。 |
| double | regr_count(independent, dependent) | Returns the number of non-null pairs used to fit the linear regression line. As of Hive 2.2.0. |
| double | regr_intercept(independent, dependent) | Returns the y-intercept of the linear regression line, i.e. the value of b in the equation dependent = a * independent + b. As of Hive 2.2.0. |
| double | regr_r2(independent, dependent) | Returns the coefficient of determination for the regression. As of Hive 2.2.0. |
| double | regr_slope(independent, dependent) | Returns the slope of the linear regression line, i.e. the value of a in the equation dependent = a * independent + b. As of Hive 2.2.0. |
| double | regr_sxx(independent, dependent) | Equivalent to regr_count(independent, dependent) * var_pop(dependent). As of Hive 2.2.0. |
| double | regr_sxy(independent, dependent) | Equivalent to regr_count(independent, dependent) * covar_pop(independent, dependent). As of Hive 2.2.0. |
| double | regr_syy(independent, dependent) | Equivalent to regr_count(independent, dependent) * var_pop(independent). As of Hive 2.2.0. |
array<struct {'x','y'}> | histogram_numeric(col, b) | Computes a histogram of a numeric column in the group using b non-uniformly spaced bins. The output is an array of size b of double-valued (x,y) coordinates that represent the bin centers and heights |
| array | collect_set(col) | 返回去掉重复元素对象的集合。 和group by一起使用 |
| array | collect_list(col) | 返回具有重复对象的集合。(截止到Hive 0.13.0。) 和group by一起使用 |
| INTEGER | ntile(INTEGER x) | Divides an ordered partition into x groups called buckets and assigns a bucket number to each row in the partition. This allows easy calculation of tertiles, quartiles, deciles, percentiles and other common summary statistics. (As of Hive 0.11.0.) |
3 内置表生成函数UDTF
UDTF全称User-Defined Table-Generating Functions
普通用户定义函数，如concat()，接受单个输入行并输出单个输出行。相反，表生成函数将单个输入行转换为多个输出行。
UDTF用法描述
| 多行列的类型 | 函数 | 描述 |
|---|---|---|
| T | explode(ARRAY a) | 将数组a分解为多行。返回一个具有单列（col）的多行集合，数组中每个元素对应一行。 |
| Tkey,Tvalue | explode(MAP<Tkey,Tvalue> m) | 将映射分解为多行。返回一个有两列(*key,value)*的行集，一行对应输入映射中的每个键-值对。(截止到Hive 0.8.0)。 |
| int,T | posexplode(ARRAY a) | pos explode将数组扩展为多行，并添加int类型的位置索引列(原始数组a中元素的位置，从0开始)。返回一个包含两列(pos,val)的多行，一行对应数组中的一个元素位置索引和一个元素。 |
| T1,…,Tn | inline(ARRAY<STRUCTf1:T1,...,fn:Tn> a) | 将类型为结构体的数组分解为多行。返回一个有N列的多行(N 等于结构体中顶级元素的数量)，数组中每个结构一行。(自Hive 0.10开始)。各个结构体中顶级元素数量要一致。 |
| T1,…,Tn/r | stack(int r,T1 V1,…,Tn/r Vn) | 把n个V1,…,Vn分解成r行。每一行有n/r列。r必须是常数。 |
| string1,…,stringn | json_tuple(string jsonStr,string k1,…,string kn) | 它使用一组名称（键）和一个JSON字符串，并使用一个函数返回值的元组。这是get_json_objectUDF的更有效版本，因为它可以通过一个调用获得多个结果。 |
| string 1,…,stringn | parse_url_tuple(string urlStr,string p1,…,string pn) | 这类似于parse_url()UDF，但可以一次从一个URL中提取多个部分。有效的部分名称是:HOST, PATH, QUERY, REF, PROTOCOL, AUTHORITY, FILE, USERINFO, QUERY。 |
UDTF用法示例
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.key,tf.value 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 |
LateralView
点击查看LateralView用法
lateralview 与用户定义的表生成功能（例如）结合使用explode()。如内置表生成函数中所述，UDTF为每个输入行生成零个或多个输出行。lateralview 首先将UDTF应用于基础表的每一行，然后将结果输出行与输入行连接起来以形成具有提供的表别名的虚拟表。
Lateral View 用法
lateralView: LATERAL VIEW udtf(expression) tableAlias AS columnAlias (',' columnAlias)*
fromClause: FROM baseTable (lateralView)*
SELECT pageid, adid
FROM pageAds LATERAL VIEW explode(adid_list) adTable AS adid;
创造测试数据测试Lateral View和explode
创建一个包含数组类型字段的表，且格式为textfile
字段间分隔符为空格，数组元素间分隔符为逗号
create table xtable(name string,age string,subject array<string>) row format delimited fields terminated by ' ' collection items terminated by ',' stored as textfile;
查看表所在位置
0: jdbc:hive2://hadoop91:10000> desc formatted xtable;
OK
| Location: | hdfs://hadoop90:9000/user/hive/warehouse/xtable | NULL |
创造数据
vi xtable.txt
# 存入以下数据
xhx 15 math,english,history
bjx 20 physical,biological
将数据加载到表中
[root@hadoop91 ~]# hdfs dfs -put /root/xtable.txt hdfs://hadoop90:9000/user/hive/warehouse/xtable/
查看表
0: jdbc:hive2://hadoop91:10000> select * from xtable;
+--------------+-------------+-------------------------------+--+
| xtable.name | xtable.age | xtable.subject |
+--------------+-------------+-------------------------------+--+
| xhx | 15 | ["math","english","history"] |
| bjx | 20 | ["physical","biological"] |
+--------------+-------------+-------------------------------+--+
查询中添加一个explode
0: jdbc:hive2://hadoop91:10000> select explode(subject) from xtable;
+-------------+--+
| col |
+-------------+--+
| math |
| english |
| history |
| physical |
| biological |
+-------------+--+
5 rows selected (0.402 seconds)
如果想要把name和id也加上，则结果如下，报错了
0: jdbc:hive2://hadoop91:10000> select name,age,explode(subject) from xtable;
Error: Error while compiling statement: FAILED: SemanticException [Error 10081]: UDTF's are not supported outside the SELECT clause, nor nested in expressions (state=42000,code=10081)
所以这个时候就需要用到Lateral View了
subtable为虚拟表名 subcol为表中对应字段
0: jdbc:hive2://hadoop91:10000> select name,age,subcol from xtable lateral view explode(subject) subtable as subcol;
+-------+------+-------------+--+
| name | age | subcol |
+-------+------+-------------+--+
| xhx | 15 | math |
| xhx | 15 | english |
| xhx | 15 | history |
| bjx | 20 | physical |
| bjx | 20 | biological |
+-------+------+-------------+--+
5 rows selected (0.302 seconds)
0: jdbc:hive2://hadoop91:10000> select name,age,subtable.* from xtable lateral view explode(subject) subtable ;
+-------+------+---------------+--+
| name | age | subtable.col |
+-------+------+---------------+--+
| xhx | 15 | math |
| xhx | 15 | english |
| xhx | 15 | history |
| bjx | 20 | physical |
| bjx | 20 | biological |
+-------+------+---------------+--+
5 rows selected (0.417 seconds)
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 |
inline (array of structs)
select inline(array(struct('A',10,'2015-01-01'),struct('B',20,'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 |
json_tuple
Hive 0.7中引入了新的json_tuple（）UDTF。它使用一组名称（键）和一个JSON字符串，并使用一个函数返回值的元组。这比调用GET_JSON_OBJECT从单个JSON字符串中检索多个密钥要有效得多。在任何情况下，单个JSON字符串都会被解析多次，如果您解析一次JSON_TUPLE，查询将更加高效。由于JSON_TUPLE是UDTF，因此您需要使用LATERAL VIEW
例如，
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的多个部分，以元组形式返回数据。可以通过将冒号和键附加到partToExtract参数来提取QUERY中特定键的值，例如parse_url_tuple（‘http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1’ ，‘QUERY：k1’，‘QUERY：k2’）返回值为’v1’，'v2’的元组。这比多次调用parse_url（）更有效。所有输入参数和输出列类型都是字符串。
SELECT b.*
FROM src LATERAL VIEW parse_url_tuple(fullurl, 'HOST', 'PATH', 'QUERY', 'QUERY:id') b as host, path, query, query_id LIMIT 1;
UDTF其他说明
使用语法“ 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
另请参阅编写UDTF
explode
explode()接受数组（或地图）作为输入，并将数组（地图）的元素作为单独的行输出。UDTF可以在SELECT表达式列表中使用，也可以作为LATERAL VIEW的一部分使用。
作为explode()在SELECT表达式列表中使用的示例 ，请考虑一个名为myTable的表，该表具有单列（myCol）和两行：
| Array myCol |
|---|
| [100,200,300] |
| [400,500,600] |
然后运行查询：
SELECT explode(myCol) AS myNewCol FROM myTable;
将产生：
| （int）myNewCol |
|---|
| 100 |
| 200 |
| 300 |
| 400 |
| 500 |
| 600 |
Maps的用法类似：
SELECT explode(myMap) AS (myMapKey, myMapValue) FROM myMapTable;
explode 版本 自Hive 0.13.0起可用。参见HIVE-4943。
posexplode
posexplode 类似于 explode
作为posexplode()在SELECT表达式列表中使用的示例 ，请考虑一个名为myTable的表，该表具有单列（myCol）和两行：
| Array myCol |
|---|
| [100,200,300] |
| [400,500,600] |
然后运行查询：
SELECT posexplode(myCol) AS pos, myNewCol FROM myTable;
将产生：
| （int）pos | （int）myNewCol |
|---|---|
| 1 | 100 |
| 2 | 200 |
| 3 | 300 |
| 1 | 400 |
| 2 | 500 |
| 3 | 600 |
4 窗口分析函数
4.1 窗口函数
| 中文易懂 | 函数 | 描述 |
|---|---|---|
| LEAD(字段名,N) over(partition by 分组字段 order by 排序字段 排序方式) | LEAD (scalar_expression [,offset] [,default]) OVER ([query_partition_clause] order_by_clause) | lead括号里有两个参数，第一个是字段名，第二个是数量N，这里的意思是，取分组排序后比该条记录序号大N个的对应记录的对应字段的值，如果字段名为field，N为1，就是取分组排序后下一条记录的field值，会有一个新的字段来作为这个函数的值。 |
| LAG(字段名,N) over(partition by 分组字段 order by 排序字段 排序方式) | LAG (scalar_expression [,offset] [,default]) OVER ([query_partition_clause] order_by_clause) | lag括号里里有两个参数，第一个是字段名，第二个是数量N，这里的意思是，取分组排序后比该条记录序号小N个的对应记录的指定字段的值，如果字段名为field，N为1，就是取分组排序后上一条记录的field值，会有一个新的字段来作为这个函数的值。 |
| FIRST_VALUE(字段名,N) over(partition by 分组字段 order by 排序字段 排序方式) | FIRST_VALUE(col[,Boolean]) OVER ([query_partition_clause] order_by_clause) | 这最多需要两个参数。第一个参数是你想要的第一个值的列，第二个(可选)参数必须是一个布尔值，默认为false。如果设置为true，则跳过空值。FIRST_VALUE 取分组内排序后，截止到当前行，第一个值。 |
| LAST_VALUE(字段名,N) over(partition by 分组字段 order by 排序字段 排序方式) | LAST_VALUE(col[,Boolean) OVER ([query_partition_clause] order_by_clause) | 这最多需要两个参数。第一个参数是你想要的最后一个值的列，第二个(可选)参数必须是一个布尔值，默认为false。如果设置为true，则跳过空值。LAST_VALUE 取分组内排序后，截止到当前行，最后一个值。 |
4.2 分析函数
| 函数 | 描述 |
|---|---|
| RANK() OVER ([query_partition_clause] order_by_clause) | 生成数据项在分组中的排名，排名相等会在名次中留下空位 |
| ROW_NUMBER() OVER ([query_partition_clause] order_by_clause) | 从1开始，按照顺序，生成分组内记录的序列,row_number()的值不会存在重复，当排序的值相同时，按照表中记录的顺序进行排列 |
| DENSE_RANK() OVER ([query_partition_clause] order_by_clause) | 生成数据项在分组中的排名，排名相等会在名次中不会留下空位 |
| CUME_DIST() OVER ([query_partition_clause] order_by_clause) | 小于等于当前值的行数/分组内总行数 |
| PERCENT_RANK() OVER ([query_partition_clause] order_by_clause) | 分组内当前行的RANK值-1/ 分组内总行数-1 |
| NTILE() OVER ([query_partition_clause] order_by_clause) | 把有序的数据集合 平均分配 到 指定的数量（num）个桶中, 将桶号分配给每一行。如果不能平均分配，则优先分配较小编号的桶，并且各个桶中能放的行数最多相差1，也就是将分组数据按照顺序切分成n片，返回当前切片值。 |
4.3 over和聚合函数搭配使用
聚合函数+over(partition by 分组字段 order by 排序字段 排序方式)
| 函数 | 描述 |
|---|---|
| COUNT(col) OVER ([query_partition_clause] [order_by_clause]) | 返回分区内col到当前行的数量，如果未指定分区则为全表统计，如果未指定排序则为全组统计 |
| SUM(col) OVER ([query_partition_clause] [order_by_clause]) | 返回分区内col到当前行的和，如果未指定分区则为全表统计，如果未指定排序则为全组统计 |
| MIN(col) OVER ([query_partition_clause] [order_by_clause]) | 返回分区内col到当前行的最小值，如果未指定分区则为全表统计，如果未指定排序则为全组统计 |
| MAX(col) OVER ([query_partition_clause] [order_by_clause]) | 返回分区内col到当前行的最大值，如果未指定分区则为全表统计，如果未指定排序则为全组统计 |
| AVG(col) OVER ([query_partition_clause] [order_by_clause]) | 返回分区内col到当前行的平均值，如果未指定分区则为全表统计，如果未指定排序则为全组统计 |
也可以指定从哪儿行到哪儿行
AVG，MIN，MAX，和SUM等用法一样
COUNT(col) OVER ([query_partition_clause] [order_by_clause] ROWS BETWEEN 3 PRECEDING AND CURRENT ROW)
ROWS BETWEEN 3 PRECEDING AND CURRENT ROW 表示从当前行前三行到当前行
PARTITION BY col ORDER BY col ROWS UNBOUNDED PRECEDING
如果不指定ROWS BETWEEN，默认统计窗口为从起点到当前行
ROWS BETWEEN也就是window子句：
PRECEDING：往前
FOLLOWING：往后
CURRENT ROW：当前行
UNBOUNDED PRECEDING： 表示从最前面的起点开始
UNBOUNDED FOLLOWING：表示到最后面的终点
5 函数补充说明
对function(column)进行分组和排序
典型的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);
DISTRIBUTE BY, DISTRIBUTE BY + SORT BY, CLUSTER BY
The context of a UDF’s evaluate method is one row at a time. A simple invocation of a UDF like
SELECT length(string_col) FROM table_name;
would evaluate the length of each of the string_col’s values in the map portion of the job. The side effect of the UDF being evaluated on the map-side is that you can’t control the order of rows which get sent to the mapper. It is the same order in which the file split sent to the mapper gets deserialized. Any reduce side operation (such as SORT BY, ORDER BY, regular JOIN, etc.) would apply to the UDFs output as if it is just another column of the table. This is fine since the context of the UDF’s evaluate method is meant to be one row at a time.
If you would like to control which rows get sent to the same UDF (and possibly in what order), you will have the urge to make the UDF evaluate during the reduce phase. This is achievable by making use of DISTRIBUTE BY, DISTRIBUTE BY + SORT BY, CLUSTER BY. An example query would be:
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
However, one could argue that the very premise of your requirement to control the set of rows sent to the same UDF is to do aggregation in that UDF. In such a case, using a User Defined Aggregate Function (UDAF) is a better choice. You can read more about writing a UDAF here. Alternatively, you can user a custom reduce script to accomplish the same using Hive’s Transform functionality. Both of these options would do aggregations on the reduce side.
6 创建自定义函数
7 内置运算符
7.1 运算符优先级
| Example | Operators | Description |
|---|---|---|
| A[B] , A.identifier | bracket_op([]), dot(.) | element selector, dot |
| -A | unary(+), unary(-), unary(~) | unary prefix operators |
| A IS [NOT] (NULL|TRUE|FALSE) | IS NULL,IS NOT NULL, … | unary suffix |
| A ^ B | bitwise xor(^) | bitwise xor |
| A * B | star(*), divide(/), mod(%), div(DIV) | multiplicative operators |
| A + B | plus(+), minus(-) | additive operators |
| A || B | string concatenate(||) | string concatenate |
| A & B | bitwise and(&) | bitwise and |
| A | B | bitwise or(|) | bitwise or |
7.2 关系运算符
以下运算符比较如A和B两个表达式，并根据比较的结果是否成立来返回TRUE或FALSE值。
| 运算符 | 表达式的类型 | 描述 |
|---|---|---|
| A = B | 所有基本类型 | 如果表达式A等于表达式B，则为TRUE，否则为FALSE。 |
| A == B | 所有基本类型 | 等同于=运算符 |
| A <=> B | 所有基本类型 | 对于非空操作数，等同于=运算符，但是如果两个均为NULL，则返回TRUE，如果其中之一为NULL，则返回FALSE。（从0.9.0版开始。） |
| A <> B | 所有基本类型 | 如果A或B有至少一个为NULL，则为NULL，如果表达式A不等于表达式B，则为TRUE，如果表达式A等于表达式B，则为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。 |
| A [NOT] BETWEEN B AND C | 所有基本类型 | 如果A，B或C有至少一个为NULL，则为NULL；如果A大于或等于B，而A小于或等于C，则为TRUE，否则为FALSE。可以使用NOT关键字将其反转。（从0.9.0版开始。） |
| A IS NULL | 所有类型 | 如果表达式A的计算结果为NULL，则为TRUE，否则为FALSE。 |
| A IS NOT NULL | 所有类型 | 如果表达式A的计算结果为NULL，则为FALSE，否则为TRUE。 |
| A IS [NOT] (TRUE | FALSE) | 布尔类型 | 仅当A满足条件时评估为TRUE。（从3.0.0 版本开始）注意：NULL为UNKNOWN（不是TRUE也不是FALSE），因此（UNKNOWN IS TRUE）和（UNKNOWN IS FALSE）都评估为FALSE。0也为FALSE，其他数字为true。 |
| A [NOT] LIKE B | 字符串类型 | 如果A或B有至少一个为NULL，则为NULL，如果字符串A匹配SQL简单正则表达式B ，则为TRUE，否则为FALSE。比较是逐字进行的。B中的_字符匹配A中的任何单个字符(类似于posix正则表达式中的.)，而B中的%字符匹配A中的任意数量的字符，任意字符的长度(类似于posix正则表达式中的.*)。例如，‘foobar’ like 'foo’的结果为FALSE，而 ‘foobar’ like ‘foo_ _ _’ 的结果为TRUE， ‘foobar’ like ‘foo%’ 的结果为TRUE。 |
| A RLIKE B | 字符串类型 | 如果A或B有至少一个为NULL，则为NULL，如果A的任何子字符串（可能为空）匹配Java正则表达式B，则为TRUE，否则为FALSE。例如，‘foobar’ RLIKE 'foo’的计算结果为TRUE，‘foobar’ RLIKE '^f.*r$'的计算结果也为TRUE。 |
| A REGEXP B | 字符串类型 | 与RLIKE相同。 |
7.3 算术运算符
以下运算符支持对表达式的各种常见算术运算。所有返回数字类型；如果任何一个为NULL，则结果也为NULL。
| 运算符 | 表达式的类型 | 描述 |
|---|---|---|
| A + B | 所有数字类型 | 给出将A和B相加的结果。计算结果的类型与表达式类型的公共父级（在类型层次结构中）相同。例如，由于每个integer都是float类型，因此float包含integer类型，因此float和integer类型进行+运算符会返回float类型。 |
| A - B | 所有数字类型 | 给出从A减去B的结果。计算结果的类型与表达式类型的公共父级（在类型层次结构中）相同。 |
| A * B | 所有数字类型 | 给出将A和B相乘的结果。计算结果的类型与表达式类型的公共父级（在类型层次结构中）相同。请注意，如果乘法导致溢出，则必须将其中一个运算符强制转换为类型层次结构中较高的类型。 |
| A / B | 所有数字类型 | 给出将A除以B的结果。在大多数情况下，该结果为双精度double类型。当A和B都是整数时，结果是double类型，除非将hive.compat配置参数设置为“ 0.13”或“ latest”，在这种情况下，结果是小数类型。 |
| A DIV B | 整数类型 | 给出A除以B得到的整数部分，例如17 div 3的结果是5。 |
| A % B | 所有数字类型 | 给出A除以B的余数部分。计算结果的类型与表达式类型的公共父级（在类型层次结构中）相同。 |
| A & B | 所有数字类型 | 给出A和B的按位与的结果。计算结果的类型与表达式类型的公共父级（在类型层次结构中）相同。 |
| A | B | 所有数字类型 | 给出A和B的按位或的结果。计算结果的类型与表达式类型的公共父级（在类型层次结构中）相同。 |
| A ^ B | 所有数字类型 | 给出A和B的按位异或结果。计算结果的类型与表达式类型的公共父级（在类型层次结构中）相同。 |
| ~A | 所有数字类型 | 给出A的按位非的结果。计算结果的类型与A的类型相同。 |
7.4 逻辑运算符
以下运算符提供了对逻辑表达式的支持。它们都返回布尔值TRUE、FALSE或NULL，这取决于表达式的布尔值。NULL作为“未知”标志，所以如果结果取决于未知的状态，那么返回结果也就是未知的。
| 运算符 | 表达式的类型 | 描述 |
|---|---|---|
| A AND B | 布尔值 | 如果A和B均为TRUE，则为TRUE，否则为FALSE。如果A或B有至少一个为NULL，则为NULL。 |
| A OR B | 布尔值 | 如果A或B或两者均为TRUE，则为TRUE，FALSE or NULL为NULL，否则为FALSE。 |
| NOT A | 布尔值 | 如果A为FALSE，则为TRUE；如果A为NULL，则为NULL。否则为FALSE。 |
| ! A | 布尔值 | 与NOT A相同。 |
| A IN（val1，val2，…） | 布尔值 | 如果A等于任何值，则为TRUE。从Hive开始，IN语句支持0.13子查询。 |
| A NOT IN (val1, val2, …) | 布尔值 | 如果A不等于任何值，则为TRUE。从Hive开始，NOT IN语句支持0.13子查询。 |
| [NOT] EXISTS (subquery) | 如果子查询返回至少一行，则为TRUE。从Hive 0.13开始受支持。 |
7.5 字符串运算符
| 运算符 | 表达式的类型 | 描述 |
|---|---|---|
| A || B | 字符串类型 | 连接表达式的简写concat(A,B)。从Hive 2.2.0开始受支持。 |
7.6 复杂类型构造函数
以下函数构造复杂类型的实例。
| 构造函数 | 运算对象 | 描述 |
|---|---|---|
| map | (key1, value1, key2, value2, …) | 使用给定的键/值对创建一个map。 |
| struct | (val1, val2, val3, …) | 使用给定字段值创建一个struct。Struct字段的名称将为col1，col2，…。 |
| named_struct | (name1, val1, name2, val2, …) | 使用给定的字段名和值创建一个struct。（从Hive 0.8.0开始） |
| array | (val1, val2, …) | 使用给定的元素创建一个array。 |
| create_union | (tag, val1, val2, …) | 使用标记参数指向的值创建一个联合类型。 |
7.7 复杂类型上的运算符
以下操作符提供了访问复杂类型元素的机制。
| Operator | Operand types | Description |
|---|---|---|
| A[n] | A is an Array and n is an int | Returns the nth element in the array A. The first element has index 0. For example, if A is an array comprising of [‘foo’, ‘bar’] then A[0] returns ‘foo’ and A[1] returns ‘bar’. |
| M[key] | M is a Map<K, V> and key has type K | Returns the value corresponding to the key in the map. For example, if M is a map comprising of {‘f’ -> ‘foo’, ‘b’ -> ‘bar’, ‘all’ -> ‘foobar’} then M[‘all’] returns ‘foobar’. |
| S.x | S is a struct | Returns the x field of S. For example for the struct foobar {int foo, int bar}, foobar.foo returns the integer stored in the foo field of the struct. |
317
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
