hive数组巨详细解析

一、Hive 数组是什么？

Hive 的数组（ARRAY）用于在一个字段中保存多个同类型元素，类似 Java 的List或 Python 的list。

例如：

user_id | tags --------|---------------------- 1 | ["java", "hive"] 2 | ["spark", "flink"]

数组中的元素必须是相同类型，例如：

ARRAY<STRING> ARRAY<INT> ARRAY<DOUBLE>

Hive 还支持复杂类型：

ARRAY<STRUCT<name:STRING, age:INT>> ARRAY<MAP<STRING, STRING>>

二、创建数组

1. 使用array()函数

SELECTARRAY('java','hive','spark')AStags;

结果逻辑上是：

["java", "hive", "spark"]

数值数组：

SELECTARRAY(10,20,30)ASnumbers;

字符串和数字不能直接混合成普通数组：

-- 不建议或可能报类型错误SELECTARRAY('java',10);

2. 使用split()把字符串转换成数组

如果表中保存的是逗号分隔字符串：

user_id | tags --------|---------------- 1 | java,hive,spark 2 | flink,spark

可以使用：

SELECTuser_id,SPLIT(tags,',')AStag_arrayFROMuser_tags;

结果：

user_id | tag_array --------|---------------------- 1 | ["java", "hive", "spark"] 2 | ["flink", "spark"]

注意，split()的第二个参数是正则表达式。如果分隔符是竖线，需要转义：

SELECTSPLIT(tags,'\\|')FROMuser_tags;

三、创建包含数组字段的表

CREATETABLEuser_tags(user_idBIGINT,tags ARRAY<STRING>)STOREDASPARQUET;

数组也可以作为分区表中的普通字段：

CREATETABLEuser_profile(user_idBIGINT,interests ARRAY<STRING>,scores ARRAY<INT>)PARTITIONEDBY(dt STRING)STOREDASORC;

建表时常见复杂类型写法：

CREATETABLEexample(idBIGINT,names ARRAY<STRING>,attributes MAP<STRING,STRING>,users ARRAY<STRUCT<name:STRING,age:INT>>)STOREDASPARQUET;

四、访问数组元素

Hive 数组下标从0开始：

SELECTuser_id,tags[0]ASfirst_tag,tags[1]ASsecond_tagFROMuser_tags;

例如：

tags = ["java", "hive", "spark"]

访问结果：

tags[0] = java tags[1] = hive tags[2] = spark

下标超过数组范围时，通常返回NULL：

SELECTtags[100]FROMuser_tags;

可以先判断数组长度：

SELECTuser_id,SIZE(tags)AStag_count,CASEWHENSIZE(tags)>0THENtags[0]ENDASfirst_tagFROMuser_tags;

五、常用数组函数

1.size()：获取数组长度

SELECTuser_id,SIZE(tags)AStag_countFROMuser_tags;

结果：

user_id | tag_count --------|---------- 1 | 3 2 | 2

对于NULL数组，结果通常为NULL；对于空数组，长度为0。

2.array_contains()：判断数组是否包含元素

SELECTuser_id,ARRAY_CONTAINS(tags,'hive')AShas_hiveFROMuser_tags;

也可以用于过滤：

SELECTuser_idFROMuser_tagsWHEREARRAY_CONTAINS(tags,'hive');

3.sort_array()：数组排序

升序排序：

SELECTSORT_ARRAY(ARRAY(5,2,8,1))ASsorted_numbers;

结果：

[1, 2, 5, 8]

降序排序可以使用第二个参数：

SELECTSORT_ARRAY(ARRAY(5,2,8,1),FALSE)ASsorted_numbers;

不同 Hive 版本对排序参数的支持可能存在差异，生产环境中应以当前集群版本为准。

4.array_join()或concat_ws()：数组转字符串

如果需要把数组拼接成字符串，可以使用：

SELECTuser_id,CONCAT_WS(',',tags)AStag_stringFROMuser_tags;

结果：

user_id | tag_string --------|---------------- 1 | java,hive,spark 2 | flink,spark

某些 Hive 版本支持array_join：

SELECTARRAY_JOIN(tags,',')FROMuser_tags;

通常使用CONCAT_WS兼容性更好。

5.concat()：拼接数组

SELECTCONCAT(ARRAY('java','hive'),ARRAY('spark','flink'))ASall_tags;

结果：

["java", "hive", "spark", "flink"]

用于表字段时：

SELECTuser_id,CONCAT(tags,ARRAY('new_tag'))ASnew_tagsFROMuser_tags;

六、数组转行：explode()

这是 Hive 中最常用的数组操作之一。

原始数据：

user_id | tags --------|---------------------- 1 | ["java", "hive"] 2 | ["spark", "flink"]

使用explode()：

SELECTuser_id,tagFROMuser_tags LATERALVIEWEXPLODE(tags)tAStag;

结果：

user_id | tag --------|------ 1 | java 1 | hive 2 | spark 2 | flink

数据变化为：

一行数组 ↓ explode 多行普通字段

explode()是一个 UDTF，通常需要配合LATERAL VIEW使用。

七、保留数组位置：posexplode()

如果还需要知道元素在数组中的下标，可以使用posexplode()：

SELECTuser_id,pos,tagFROMuser_tags LATERALVIEWPOSEXPLODE(tags)tASpos,tag;

结果：

user_id | pos | tag --------|-----|------ 1 | 0 | java 1 | 1 | hive 2 | 0 | spark 2 | 1 | flink

适合以下场景：

• 保留原始数组顺序；
• 获取数组元素的位置；
• 两个数组按照下标一一对应；
• 需要重新排序或进行位置匹配。

八、空数组和LATERAL VIEW OUTER

普通的explode()在数组为空或为NULL时，可能不会输出原始行：

SELECTuser_id,tagFROMuser_tags LATERALVIEWEXPLODE(tags)tAStag;

如果希望保留数组为空的用户，可以使用OUTER：

SELECTuser_id,tagFROMuser_tags LATERALVIEWOUTEREXPLODE(tags)tAStag;

此时没有数组元素的用户仍会保留，展开出来的tag通常为NULL。

这在统计用户数、订单数时很重要，否则空数组对应的主表记录可能被过滤掉。

九、数组中保存结构体

Hive 数组的元素也可以是STRUCT。

例如用户购买商品数组：

[ {"product":"apple", "price":5}, {"product":"banana", "price":8} ]

表结构：

CREATETABLEuser_orders(user_idBIGINT,orders ARRAY<STRUCT<product:STRING,price:DOUBLE>>)STOREDASPARQUET;

先展开数组，再访问结构体字段：

SELECTuser_id,order_item.productASproduct,order_item.priceASpriceFROMuser_orders LATERALVIEWEXPLODE(orders)tASorder_item;

结果：

user_id | product | price --------|---------|------ 1 | apple | 5.0 1 | banana | 8.0

也可以直接访问数组中某个结构体元素的字段：

SELECTuser_id,orders[0].productASfirst_product,orders[0].priceASfirst_priceFROMuser_orders;

十、数组与collect_list、collect_set

1. 多行聚合成数组

原始订单商品表：

order_id | product ---------|-------- 1001 | apple 1001 | banana 1001 | orange 1002 | milk

使用collect_list：

SELECTorder_id,COLLECT_LIST(product)ASproductsFROMorder_productGROUPBYorder_id;

结果：

order_id | products ---------|---------------------- 1001 | ["apple", "banana", "orange"] 1002 | ["milk"]

collect_list会保留重复值。

2. 使用collect_set去重

SELECTorder_id,COLLECT_SET(product)ASproductsFROMorder_productGROUPBYorder_id;

如果原始数据为：

apple apple banana

结果逻辑上是：

["apple", "banana"]

需要注意：

collect_set不保证数组元素顺序。分布式执行下，也不要默认依赖collect_list的最终顺序，除非业务明确处理了排序逻辑。

3. 同时保留多个字段

不建议分别聚合多个字段后再依赖数组下标对应：

-- 需要谨慎使用SELECTorder_id,COLLECT_LIST(product)ASproducts,COLLECT_LIST(price)ASpricesFROMorder_productGROUPBYorder_id;

更稳妥的方式是先构造结构体：

SELECTorder_id,COLLECT_LIST(NAMED_STRUCT('product',product,'price',price))ASproduct_infoFROMorder_productGROUPBYorder_id;

这样商品名和价格会被保存在同一个结构体元素中，不容易出现字段错位。

十一、数组与字符串的相互转换

字符串转数组

SELECTSPLIT('java,hive,spark',',')AStags;

数组转字符串

SELECTCONCAT_WS(',',ARRAY('java','hive','spark'))AStags;

完整示例：

WITHsourceAS(SELECT1ASuser_id,'java,hive,spark'AStag_string)SELECTuser_id,SPLIT(tag_string,',')AStag_array,CONCAT_WS('|',SPLIT(tag_string,','))AStag_textFROMsource;

结果逻辑上是：

user_id | tag_array | tag_text --------|------------------------|---------------- 1 | [java,hive,spark] | java|hive|spark

十二、两个数组按位置匹配

假设一行中有两个数组：

user_id | subjects | scores --------|-------------------|-------- 1 | [math, english] | [90, 85]

目标是得到：

user_id | subject | score --------|---------|------ 1 | math | 90 1 | english | 85

可以分别使用posexplode()，再按数组位置关联：

WITHsubject_dataAS(SELECTuser_id,pos,subjectFROMuser_score LATERALVIEWPOSEXPLODE(subjects)tASpos,subject),score_dataAS(SELECTuser_id,pos,scoreFROMuser_score LATERALVIEWPOSEXPLODE(scores)tASpos,score)SELECTa.user_id,a.subject,b.scoreFROMsubject_data aJOINscore_data bONa.user_id=b.user_idANDa.pos=b.pos;

这里的关键是：

不能只展开两个数组，否则容易产生笛卡尔积； 应该使用 pos 把相同位置的元素对应起来。

十三、数组常见应用

1. 判断用户是否拥有某个标签

SELECTuser_idFROMuser_tagsWHEREARRAY_CONTAINS(tags,'vip');

2. 统计用户标签数量

SELECTuser_id,SIZE(tags)AStag_countFROMuser_tags;

3. 展开标签进行统计

SELECTtag,COUNT(*)ASuser_countFROMuser_tags LATERALVIEWEXPLODE(tags)tAStagGROUPBYtag;

4. 统计数组中不同元素

如果数组内部可能有重复值，可以先展开后去重：

SELECTuser_id,COUNT(DISTINCTtag)ASdistinct_tag_countFROMuser_tags LATERALVIEWEXPLODE(tags)tAStagGROUPBYuser_id;

5. 数组为空时保留用户

SELECTuser_id,tagFROMuser_tags LATERALVIEWOUTEREXPLODE(tags)tAStag;

十四、使用数组时的注意事项

1. 数组元素类型必须统一

例如应该使用：

ARRAY<STRING> ARRAY<INT>

不要在同一个数组中混合保存完全不同类型的数据。

2. 不要让数组无限增长

如果一个用户的数组可能包含数百万个元素，使用collect_list可能造成：

• Reducer 内存不足；
• 单行数据过大；
• 查询性能下降；
• 数据倾斜；
• 任务失败。

这种情况下，应该考虑拆成明细表，而不是把所有明细塞进一个数组字段。

3.explode会放大数据量

一行数组展开后可能变成很多行：

100 万行 × 每行 100 个元素 ≈ 1 亿行输出

因此展开前需要评估数据量和下游计算成本。

4. 注意NULL、空数组和空字符串

这几种值的语义不同：

NULL ：没有数组值 [] ：数组存在，但没有元素 [''] ：数组中有一个空字符串

数据清洗时需要根据业务分别处理。

5. 不要默认依赖聚合数组的顺序

以下函数的结果顺序需要谨慎处理：

COLLECT_LIST()COLLECT_SET()

尤其是collect_set，明确不应该依赖其元素顺序。

6. 文件格式影响复杂类型性能

数组、Map、Struct 等复杂类型通常更适合保存到：

Parquet ORC

相比 CSV、JSON，列式格式通常更适合 Hive 查询和压缩。

十五、快速记忆

创建数组

ARRAY('a','b','c')

字符串转数组

SPLIT(str,',')

访问数组元素

arr[0]

获取数组长度

SIZE(arr)

判断是否包含元素

ARRAY_CONTAINS(arr,'a')

数组转行

LATERALVIEWEXPLODE(arr)tASitem

数组转行并保留下标

LATERALVIEWPOSEXPLODE(arr)tASpos,item

多行聚合成数组

COLLECT_LIST(value)COLLECT_SET(value)

数组转字符串

CONCAT_WS(',',arr)

总结

Hive 数组主要用于保存一组同类型的数据，常见操作可以概括为：

创建数组：ARRAY() 字符串转数组：SPLIT() 访问元素：arr[index] 获取长度：SIZE() 判断元素：ARRAY_CONTAINS() 数组转多行：EXPLODE() 数组转多行并保留下标：POSEXPLODE() 多行聚合成数组：COLLECT_LIST() / COLLECT_SET() 数组转字符串：CONCAT_WS()

最核心的使用模式是：

-- 多行聚合成数组SELECTuser_id,COLLECT_LIST(tag)AStagsFROMuser_tag_detailGROUPBYuser_id;

-- 数组展开成多行SELECTuser_id,tagFROMuser_tags LATERALVIEWEXPLODE(tags)tAStag;

可以把 Hive 数组理解为：用一列保存多个相关值，再根据查询需要进行访问、过滤、聚合或展开。