Interview on My Learning Notes

【二】HiveSQL 排名中取他值

Sun, 07 Jun 2026 20:03:05 +0800

我先给一个统一的示例表，后面所有 SQL 都基于它讲：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


create table abc_test(
 a string,
 b int,
 c int
) 
row format delimited fields terminated by '\t'
stored as textfile;

insert into abc_test values
('A',10,100),
('A',20,200),
('A',30,300),
('A',40,400),
('B',15,150),
('A',25,250),
('A',35,350)

select * from abc_test;

a	b	c
A	10	100
A	20	200
A	30	300
A	40	400
B	15	150
B	25	250
B	35	350

一、按 a 分组，取 b 最小 / 最大时对应的 c 字段

1. 取 b 最小时对应的 c——row_number()

1
2
3
4
5
6
7
8


select 
 a as group_a,b as min_b,c 
from
(
 select a,b,c,row_number() over(partition by a order by b asc) as rn 
 from abc_test
)as tmp
where rn = 1;

group_a	min_b	c
A	10	100
B	15	150

含义：

PARTITION BY a 每个 a 分组内部单独排序。

ORDER BY b ASC 表示按 b 从小到大排序。

rn = 1 表示取每组中 b 最小的那一行。

2. 取 b 最大时对应的 c

1
2
3
4
5
6
7
8


select 
 a as group_a,b as maz_b,c 
from
(
 select a,b,c,row_number() over(partition by a order by b desc) as rn 
 from abc_test
)as tmp
where rn = 1;

group_a	maz_b	c
A	40	400
B	35	350

3. 如果 b 有重复值怎么办？

例如：

a	b	c
A	10	100
A	10	999

1
2
3


insert into abc_test values
('A',10,999),
('A',20,999);

如果你用：row_number() 只会随机/按额外排序规则取其中一条。

如果你希望 所有 b 最小的记录都取出来，应该用：rank()同排名的下一个跳号，或 dense_rank()同排名的下一个不跳号

1
2
3
4
5
6
7
8


select 
 a as group_a,b as maz_b,c 
from
(
 select a,b,c,rank() over(partition by a order by b asc) as rn 
 from abc_test
)as tmp
where rn = 1;

group_a	maz_b	c
A	10	100
A	10	999
B	15	150

二、按 a 分组，取 b 字段第二小 / 第二大时对应的 c 字段

1. 取 b 第二小时对应的 c

1
2
3
4
5
6
7
8


select 
 a as group_a,b as maz_b,c 
from
(
 select a,b,c,dense_rank() over(partition by a order by b asc) as rn 
 from abc_test
)as tmp
where rn = 2;

group_a	maz_b	c
A	20	200
A	20	999
B	25	250

2. 取 b 第二大时对应的 c

1
2
3
4
5
6
7
8


select 
 a as group_a,b as maz_b,c 
from
(
 select a,b,c,dense_rank() over(partition by a order by b desc) as rn 
 from abc_test
)as tmp
where rn = 2;

group_a	maz_b	c
A	30	300
B	25	250

3. 第二小到底是“第二行”还是“第二个不同的 b 值”？

这是面试/实际开发中非常重要的区别。

假设数据：

a	b	c
A	10	100
A	10	101
A	20	200
A	30	300

情况一：取排序后的第二行

用row_number()结果可能是：

a	b	c
A	10	101

因为它只是第 2 行。

情况二：取第二个不同的 b 值

应该用：dense_rank()

结果是：

a	b	c
A	20	200

三、按 a 分组，取 b 字段前二小 / 前二大时对应的 c 字段

1. 取 b 前二小对应的 c

1
2
3
4
5
6
7
8


select 
 a as group_a,b as min_b,c 
from
(
 select a,b,c,row_number() over(partition by a order by b asc) as rn 
 from abc_test
)as tmp
where rn <= 2;

group_a	min_b	c
A	10	100
A	10	999
B	15	150
B	25	250

2. 取 b 前二大对应的 c

1
2
3
4
5
6
7
8


select 
 a as group_a,b as min_b,c 
from
(
 select a,b,c,row_number() over(partition by a order by b desc) as rn 
 from abc_test
)as tmp
where rn <= 2;

group_a	min_b	c
A	40	400
A	30	300
B	35	350
B	25	250

3. 如果要取前两个不同的 b 值

1
2
3
4
5
6
7
8


select 
 a as group_a,b as min_b,c 
from
(
 select a,b,c,dense_rank() over(partition by a order by b asc) as rn 
 from abc_test
)as tmp
where rn <= 2;

group_a	min_b	c
A	10	100
A	10	999
A	20	200
A	20	999
B	15	150
B	25	250

四、按 a 分组，b 字段排序，对 c 做累计和

先恢复为初始数据

1
2
3
4
5
6


insert overwrite table abc_test
select *
from interview.abc_test
where c != 999;

select * FROM abc_test;

a	b	c
A	10	100
A	20	200
A	30	300
A	40	400
B	15	150
B	25	250
B	35	350

这是典型的窗口聚合题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


SELECT 
 a,
 b,
 c,
 -- 窗口函数正确语法：聚合函数(字段) OVER(窗口定义)
 SUM(c) OVER(
 PARTITION BY a 
 ORDER BY b ASC -- 必须指定排序字段，否则累计和无意义！
 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
 ) AS sum_c
FROM abc_test;

PARTITION BY a ，每个 a 分组内计算。

ORDER BY b ASC，按照 b 从小到大定义累计顺序。

ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW：窗口范围是：从当前分组第一行，到当前行。

结果：

a	b	c	sum_c
A	10	100	100
A	20	200	300
A	30	300	600
A	40	400	1000
B	15	150	150
B	25	250	400
B	35	350	750

五、按 a 分组，b 字段排序，对 c 做累计平均值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


SELECT 
 a,
 b,
 c,
 -- 窗口函数正确语法：聚合函数(字段) OVER(窗口定义)
 avg(c) OVER(
 PARTITION BY a 
 ORDER BY b ASC -- 必须指定排序字段，否则累计和无意义！
 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
 ) AS sum_c
FROM abc_test;

a	b	c	avg_c
A	10	100	100.0
A	20	200	150.0
A	30	300	200.0
A	40	400	250.0
B	15	150	150.0
B	25	250	200.0
B	35	350	250.0

六、按 a 分组，b 字段排序，对 c 做累计排名比例

这里要先明确：累计排名比例 通常有几种理解。

1. 当前行在组内的排名比例

当前行排名 / 当前组总行数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


SELECT 
 a,
 b,
 c,
 -- 以a分组，按b升序，生成行号
 row_number() OVER(
 PARTITION BY a 
 ORDER BY b ASC
 ) AS rn,
 -- a分组的元素数
 count(*) OVER ( 
 PARTITION BY a 
 ) AS total_cnt, 
 -- 计算排名比例rank_ratio=排名/总元素数
    -- 在 Hive 中整数除法可能导致结果不符合预期，建议转成 double：
 cast(row_number() OVER ( 
 PARTITION BY a 
 ORDER BY b ASC 
 )AS double) 
 /
 count(*) OVER ( 
 PARTITION BY a 
 ) AS rank_ratio
FROM abc_test;

a	b	c	rn	total_cnt	rank_ratio
A	10	100	1	4	0.25
A	20	200	2	4	0.5
A	30	300	3	4	0.75
A	40	400	4	4	1.0
B	15	150	1	3	0.3333333333333333
B	25	250	2	3	0.6666666666666666
B	35	350	3	3	1.0

2. Hive 内置函数：`percent_rank()`

percent_rank() 的公式：(rank - 1) / (总行数 - 1)，所以第一行是 0，最后一行是 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


-- 正确写法：percent_rank() 不需要ROWS BETWEEN子句
SELECT 
 a,
 b,
 c,
 percent_rank() OVER(
 PARTITION BY a 
 ORDER BY b ASC
 ) AS percent_rank_value
FROM abc_test;

a	b	c	percent_rank_value
A	10	100	0.0
A	20	200	0.3333333333333333
A	30	300	0.6666666666666666
A	40	400	1.0
B	15	150	0.0
B	25	250	0.5
B	35	350	1.0

3. Hive 内置函数：`cume_dist()`

cume_dist() 更接近“累计分布比例” = 当前行及之前的行数 / 总行数

1
2
3
4
5
6
7
8
9


SELECT 
 a,
 b,
 c,
 cume_dist() OVER(
 PARTITION BY a 
 ORDER BY b ASC
 ) AS cume_dist_value
FROM abc_test;

a	b	c	cume_dist_value
A	10	100	0.25
A	20	200	0.5
A	30	300	0.75
A	40	400	1.0
B	15	150	0.3333333333333333
B	25	250	0.6666666666666666
B	35	350	1.0

七、按 a 分组，b 字段排序，对 c 做累计和比例

当前累计 c 之和 / 当前组 c 总和

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


SELECT 
 a,
 b,
 c,
 -- 窗口函数正确语法：聚合函数(字段) OVER(窗口定义)
 sum(c) OVER(
 PARTITION BY a 
 ORDER BY b asc
 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
 ) AS current_sum_value,
 sum(c) OVER ( 
 PARTITION BY a 
 ) AS total_sum_value, 
 cast(sum(c) OVER(
 PARTITION BY a 
 ORDER BY b asc
 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
 )AS double)
 /
 sum(c) OVER ( 
 PARTITION BY a 
 ) as sum_percent
FROM abc_test;ercent
FROM abc_test;

a	b	c	current_sum_value	total_sum_value	sum_percent
A	10	100	100	1000	0.1
A	20	200	300	1000	0.3
A	30	300	600	1000	0.6
A	40	400	1000	1000	1.0
B	15	150	150	750	0.2
B	25	250	400	750	0.5333333333333333
B	35	350	750	750	1.0

八、按 a 分组，b 字段排序，对 c 取前后各一行的和

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


SELECT 
 a,
 b,
 c,
 -- 前一行的值
 lag(c,1,0) OVER( 
 PARTITION BY a 
 ORDER BY b asc
 ) AS pre_value,
 -- 后一行的值
 lead(c,1,0) OVER(
 PARTITION BY a 
 ORDER BY b asc
 ) AS after_value,
 -- 前一行+后一行的值
 lag(c,1,0) OVER(
 PARTITION BY a 
 ORDER BY b asc
 )+
 lead(c,1,0) OVER(
 PARTITION BY a 
 ORDER BY b asc
 ) as sum_pre_after
FROM abc_test;

a	b	c	pre_value	after_value	sum_pre_after
A	10	100	0	200	200
A	20	200	100	300	400
A	30	300	200	400	600
A	40	400	300	0	300
B	15	150	0	250	250
B	25	250	150	350	500
B	35	350	250	0	250

如果需要包含当前值，则可以使用ROWS BETWEEN 1 PRECEDING AND 1 following

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


SELECT 
 a,
 b,
 c,
 -- 窗口函数正确语法：聚合函数(字段) OVER(窗口定义)
 sum(c) OVER(
 PARTITION BY a 
 ORDER BY b asc
 ROWS BETWEEN 1 PRECEDING AND 1 following
 ) AS current_sum_value
FROM abc_test;

a	b	c	current_sum_value
A	10	100	300
A	20	200	600
A	30	300	900
A	40	400	700
B	15	150	400
B	25	250	750
B	35	350	600

九、按 a 分组，b 字段排序，对 c 取平均值

情况一：取整个 a 分组内 c 的平均值

每个 a 分组内，所有 c 的平均值。

1
2
3
4
5
6
7
8


SELECT 
 a, 
 b, 
 c, 
 AVG(c) OVER ( 
     PARTITION BY a 
 ) AS avg_c_in
FROM abc_test;

a	b	c	avg_c_in
A	10	100	250.0
A	20	200	250.0
A	30	300	250.0
A	40	400	250.0
B	15	150	250.0
B	25	250	250.0
B	35	350	250.0

情况二：按 b 排序后，取当前行及之前所有行的累计平均值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


SELECT 
 a, 
 b, 
 c, 
 AVG(c) OVER ( 
 PARTITION BY a 
 ORDER BY b asc
 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
 ) AS avg_pre_curr
FROM abc_test;

a	b	c	avg_c_in
A	10	100	100.0
A	20	200	150.0
A	30	300	200.0
A	40	400	250.0
B	15	150	150.0
B	25	250	200.0
B	35	350	250.0

情况三：按 b 排序后，取当前行、上一行、下一行，三行的滑动平均值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


SELECT 
 a, 
 b, 
 c, 
 AVG(c) OVER ( 
 PARTITION BY a 
 ORDER BY b asc
 ROWS BETWEEN 1 PRECEDING AND 1 following
 ) AS avg_pre_curr_follow
FROM abc_test;

a	b	c	avg_pre_curr
A	10	100	150.0
A	20	200	200.0
A	30	300	300.0
A	40	400	350.0
B	15	150	200.0
B	25	250	250.0
B	35	350	300.0

情况四：按 b 排序后，取上一行、当前行、两行的滑动平均值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


SELECT 
 a, 
 b, 
 c, 
 AVG(c) OVER ( 
 PARTITION BY a 
 ORDER BY b asc
 ROWS BETWEEN 1 PRECEDING AND current row
 ) AS avg_pre_curr
FROM abc_test;

a	b	c	avg_pre_curr_follow
A	10	100	100.0
A	20	200	150.0
A	30	300	250.0
A	40	400	350.0
B	15	150	150.0
B	25	250	200.0
B	35	350	300.0

十、核心函数总结

1. 排名类窗口函数

函数	作用	是否跳号	典型场景
`row_number()`	每行生成唯一序号	不涉及并列	每组取第一行、第二行、TopN
`rank()`	并列同名次	会跳号	需要保留并列排名
`dense_rank()`	并列同名次	不跳号	取第 N 个不同值
`percent_rank()`	排名百分比	-	排序位置比例
`cume_dist()`	累积分布比例	-	当前值及之前占比

2. 偏移类窗口函数

函数	作用	典型场景
`lag(c, 1)`	取上一行 c	环比、差值、前值比较
`lead(c, 1)`	取下一行 c	后值比较、区间结束值
`first_value(c)`	当前窗口第一行 c	取首个值
`last_value(c)`	当前窗口最后一行 c	取末尾值，注意窗口范围

3. 聚合类窗口函数

函数	作用	典型场景
`sum(c) over (...)`	窗口内求和	累计和、占比
`avg(c) over (...)`	窗口内平均	累计均值、滑动均值
`count(*) over (...)`	窗口内计数	排名比例、总行数
`max(c) over (...)`	窗口内最大	组内最大值
`min(c) over (...)`	窗口内最小	组内最小值

十一、最重要的规律总结

规律一：只要题目里出现“按 a 分组”

大概率写：

1

PARTITION BY a

规律二：只要题目里出现“按 b 排序”

大概率写：

1
2
3


ORDER BY b ASC
- 或：
ORDER BY b DESC

规律三：只要题目里出现“第几小 / 第几大 / 前几名”

优先考虑：

1
2
3


row_number()
rank() 
dense_rank()

选择规则：

需求	推荐函数
只要一行，严格第 N 行	`row_number()`
并列同名次，并且允许跳号	`rank()`
按不同值排名，不跳号	`dense_rank()`

规律四：只要题目里出现“累计”

优先考虑 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

1
2
3
4
5


SUM(c) OVER ( 
PARTITION BY a 
ORDER BY b 
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW 
)

规律五：只要题目里出现“前一行 / 后一行”

优先考虑：

1
2


lag() 
lead()

规律六：只要题目里出现“占比”

通常是：

当前值 / 总值 c / SUM(c) OVER (PARTITION BY a) 或者：累计值 / 总值

1
2
3
4
5
6
7


SUM(c) OVER ( 
    PARTITION BY a 
    ORDER BY b 
    ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW 
) 
/ 
SUM(c) OVER (PARTITION BY a)

【一】Hive表行列之间相互转换

Thu, 04 Jun 2026 21:37:42 +0800

一、多行转多列（ Pivot / 透视转换）

假设原始表stu_score是这样：

stu_id	subject	score
1	math	90
1	english	80
1	chinese	70
2	math	88
2	english	95

现在希望变成：

stu_id	math_score	english_score	chinese_score
1	90	80	70
2	88	95	NULL

这就是 行转列。

本质是：

原来 subject 的不同取值是“行里的值”，现在把这些值变成“列名”。多行明细数据变成一行宽表数据

先按主键分组，再用条件判断把不同类别的数据筛到不同列里，最后用聚合函数把多行压成一行。

1.1 模板

1
2
3
4
5
6
7
8
9


GROUP BY 分组字段
+
聚合函数(
 CASE WHEN 条件 THEN 值 END
)
或
GROUP BY 分组字段
+
SUM(IF(条件, 值, 0))

Hive 中行转列通常使用 GROUP BY 配合条件聚合实现。

核心写法是 MAX/SUM/COUNT(CASE WHEN ... THEN ... ELSE ... END)。

如果每个分组下某个类别只有一条记录，一般用 MAX 或 MIN；
如果需要累计金额或次数，就用 SUM；
如果需要统计条件次数，可以用 SUM(CASE WHEN 条件 THEN 1 ELSE 0 END)。

例如按用户把不同事件类型转成行为指标列，可以写 SUM(CASE WHEN event_type='click' THEN 1 ELSE 0 END) AS click_cnt。

如果类别是动态的，Hive 本身不适合直接做完全动态 Pivot，通常通过脚本动态拼 SQL，或者用 map 类型保存动态键值。

1.2 原理

1、Hive 中最常见的行转列写法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


select stu_id,
	max(if(subject='math',score,NULL)) math_score,
 max(if(subject='english',score,null)) english_score,
 max(if(subject='chinese',score,NULL)) chinese_score
from stu_score
group by stu_id;
-- 或
select 
	stu_id,
	max(case when subject='math' then score end) math_score,
	max(case when subject='english' then score end) english_score,
	max(case when subject='chinese' then score end) chinese_score
from stu_score
group by stu_id;

1) 为什么需要 GROUP BY？

因为行转列通常是：同一个 user_id 的多行合并成一行

user_id	subject	score
1	math	90
1	english	80
1	chinese	70

要变成同一个 user_id 的一行：

user_id	math_score	english_score	chinese_score
1	90	80	70

所以必须：GROUP BY user_id

2）为什么需要 CASE WHEN / IF？

因为你要判断：

如果 subject = ‘math’，那这一行的 score 就放到 math_score
如果 subject = ’english’，那这一行的 score 就放到 english_score
如果 subject = ‘chinese’，那这一行的 score 就放到 chinese_score

所以必须：CASE WHEN subject = 'math' THEN score END

1.3 题目

题目1_模板

将一个用户一天内多次消费转为列显示

user_id	category	amount
1	food	20
1	food	30
1	game	100

即

user_id	food_amount	game_amount
1	50	100

1
2
3
4
5
6


SELECT
 user_id,
 SUM(CASE WHEN category = 'food' THEN amount ELSE 0 END) AS food_amount,
 SUM(CASE WHEN category = 'game' THEN amount ELSE 0 END) AS game_amount
FROM user_consume
GROUP BY user_id;

题目2_加列

原表 user_event：

user_id	event_type	amount
1	view	NULL
1	click	NULL
1	buy	100
1	buy	200
2	view	NULL
2	click	NULL

要求输出每个用户每种行为的次数和金额：

user_id	view_cnt	click_cnt	buy_cnt	buy_amount
1	1	1	2	300
2	1	1	0	0

1
2
3
4
5
6
7
8


SELECT
 user_id,
 SUM(CASE WHEevent_typey = 'view' THEN 1 ELSE 0 END) AS view_cnt,
 SUM(CASE WHEevent_typey = 'click' THEN 1 ELSE 0 END) AS click_cnt,
    SUM(CASE WHEevent_typey = 'buy' THEN 1 ELSE 0 END) AS buy_cnt,
    SUM(CASE WHEN event_type = 'buy' THEN amount ELSE 0 END) AS buy_amount
FROM user_consume
GROUP BY user_id;

题目3_汇总统计

原表 orders：

user_id	category	order_id	amount
1	food	o1	20
1	food	o2	30
1	game	o3	100
2	food	o4	50
2	travel	o5	500

要求统计每个用户在不同品类下的订单数和消费金额：

user_id	food_order_cnt	food_amount	game_order_cnt	game_amount	travel_order_cnt	travel_amount
1	2	50	1	100	0	0
2	1	50	0	0	1	500

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


SELECT 
 user_id,
 COUNT(IF(category='food',1,0)) food_order_cnt,
 SUM(IF(category='food',amount,0)) food_amount,

 COUNT(IF(category='game',1,0)) game_order_cnt,
 SUM(IF(category='game',amount,0)) game_amount,

 COUNT(IF(category='food',1,0)) travel_order_cnt,
 SUM(IF(category='travel',amount,0)) travel_amount
FROM orders
GROUP BY user_id;
-- 或
SELECT
 user_id,
 COUNT(CASE WHEN category = 'food' THEN order_id END) AS food_order_cnt,
 SUM(CASE WHEN category = 'food' THEN amount ELSE 0 END) AS food_amount,

 COUNT(CASE WHEN category = 'game' THEN order_id END) AS game_order_cnt,
 SUM(CASE WHEN category = 'game' THEN amount ELSE 0 END) AS game_amount,

 COUNT(CASE WHEN category = 'travel' THEN order_id END) AS travel_order_cnt,
 SUM(CASE WHEN category = 'travel' THEN amount ELSE 0 END) AS travel_amount
FROM orders
GROUP BY user_id;

题目4_合并统计(不汇总)

假设原始表stu_score是这样：系统记录出现问题，同一个科目出现了两个分数score

stu_id	subject	score
1	math	90
1	english	80
1	math	70
2	math	88
2	english	95

现在希望变成：将相同科目的多个分数合并

stu_id	math_score	english_score
1	90,70	80
2	88	95

思路：行转列 + 同一分组同一科目的多个值合并成一个字符串。也就是说：不再用 MAX(score) 取一个分数，而是用 collect_list(score) 把多个分数收集起来，再用concat_ws(',', ...) 拼成 “90,70” 这种字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


SELECT
 stu_id,
 concat_ws(
 ',',
 collect_list(
 CASE WHEN subject = 'math' THEN cast(score AS string) END
 )
 ) AS math_score,
 concat_ws(
 ',',
 collect_list(
 CASE WHEN subject = 'english' THEN cast(score AS string) END
 )
 ) AS english_score
FROM stu_score
GROUP BY stu_id;

concat_ws 拼接字符串数组，所以最好显式写：cast(score AS string)

collect_list 收集出来的顺序在分布式执行中不一定绝对稳定。如果你想去重，用 collect_set

如果像保证顺序，可以加一个sort_arra，但如果转成字符串排序，会按字符串字典序排序，字符串排序可能不是你想要的数值顺序

1
2
3
4
5
6



sort_array(
 collect_list(
 CASE WHEN subject = 'math' THEN cast(score AS string) END
 )
 )

写法2：先聚合再行转列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


WITH subject_score AS (
 SELECT
 stu_id,
 subject,
 concat_ws(',', collect_list(cast(score AS string))) AS score_list
 FROM stu_score
 GROUP BY stu_id, subject
)
SELECT
 stu_id,
 MAX(CASE WHEN subject = 'math' THEN score_list END) AS math_score,
 MAX(CASE WHEN subject = 'english' THEN score_list END) AS english_score
FROM subject_score
GROUP BY stu_id;

对比项	写法一：一步到位	写法二：先聚合再行转列
聚合次数	通常 1 次	通常 2 次
Shuffle 次数	通常较少	可能更多
SQL 长度	较短	较长
小数据性能	可能更好	可能略慢
大数据重复多	不一定好	通常更稳
科目很多	CASE WHEN 很多，较重	更清晰
内存压力	一个 `stu_id` 下维护多个 list	按 `stu_id, subject` 拆分，通常更稳
可维护性	一般	更好
数仓生产推荐	一般	推荐

题目5_动态行转列思路

前面的例子都有一个特点：统计列的种类是提前知道的，比如math、english、chinese ，这种叫 静态行转列

但是如果类别很多，而且不固定，不可能手写几百个

方案1：报表层的字段一般是确定的，不会无限动态变化，通常只取 Top N 类别
方案2：可以不强行转成很多列，而是转成一个 map 字段。用 MAP 保存动态键值。例如：

user_id tag score

1 tag_a 10

1 tag_b 20

2 tag_c 30

变成：

user_id tag_score_map

1 {“tag_a”:10,“tag_b”:20}

2 {“tag_c”:30}
1 2 3 4 5 6 7 8 9

SELECT user_id, map_from_entries( collect_list( named_struct('key', tag, 'value', score) ) ) AS tag_score_map FROM user_tag_score GROUP BY user_id;
方案3：用脚本动态生成 SQL
- 先查出所有类别；
- 用 Python / Shell / 调度系统生成 SQL；
- 动态拼接 CASE WHEN；
- 提交 Hive SQL 执行。

二、多列转多行（Unpivot / 反透视转换）

假设原始表 student_score_wide

user_id	math_score	english_score	chinese_score
1	90	80	70
2	88	95	NULL

转成

user_id	subject	score
1	math	90
1	english	80
1	chinese	70
2	math	88
2	english	95

现在希望变就是 列转行，跟上面讲的恰好相反

本质是：

一行宽表数据拆成多行明细数据

2.1 模板

Hive 中常见有三种写法：

写法	特点	推荐程度
`UNION ALL`	最容易理解，适合新手	高
`LATERAL VIEW + explode`	更像 Hive 风格，适合数组/map 拆行	高
`stack`	专门用于列转行，写法简洁	高

2.2 原理

1
2
3


math_score -> subject='math', score=90
english_score -> subject='english', score=80
chinese_score -> subject='chinese', score=70

所以列转行的关键是：

列名转成行值
列值转成统一字段值
一行拆多行

Hive 中列转行通常有三种做法：UNION ALL、LATERAL VIEW stack、LATERAL VIEW explode。

最常用的是 stack，它可以把一行中的多组列值拆成多行。

如果列很多但逻辑固定，用 stack 更简洁；
如果要处理数组、map、struct，通常用 explode；
如果是新手或兼容性要求高，也可以用 UNION ALL。

方法1：UNION ALL

手动将所有非主键的列一一拆除，现在有3种枚举值，则写三个SELECT 拆解 english_score，最后将结果UNION ALL （UNION会做去重，可能额外引入开销，而且有时会错误去掉你想保留的重复行）

如果需要排序，可以再套一层SELECT

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


SELECT
 user_id,
 'math' AS subject,
 math_score AS score
FROM student_score_wide
WHERE math_score IS NOT NULL

UNION ALL

SELECT
 user_id,
 'english' AS subject,
 english_score AS score
FROM student_score_wide
WHERE english_score IS NOT NULL

UNION ALL

SELECT
 user_id,
 'chinese' AS subject,
 chinese_score AS score
FROM student_score_wide
WHERE chinese_score IS NOT NULL;

方法2：LATERAL VIEW stack

stack 行级构造，把一行数据拆成 n 行，每行输出一组 key/value（强类型）。

每一“行”字段数一致
n 为key/value对的个数
stack 会在编译阶段统一列类型，数据类型必须完全一致，通常需要统一成 string（Hive 会尝试统一类型，失败就直接抛异常ClassCastException: LazyInteger cannot be cast to IntWritable）

基本语法

1

stack(n, key1, value1, key2, value2, ..., keyn, valuen)

示例：

stu_id	math_score	english_score	chinese_score
1	90	80	70
2	88	95	NULL

这里的key是’math’，value是score，string+int 无法安全转换，触发 SerDe 层类型不匹配，所以是需要显式将score这个int转为string

因为 stack()会把 一行变成多行，属于“行生成函数”，Hive 规定这类函数必须通过 lateral view使用。这里的 stack 和 explode 类似，都是 UDTF，都会把一行拆成多行，都必须配合 lateral view

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


SELECT
 stu_id,
 subject,
 score
FROM interview.stu_score_wide
LATERAL VIEW stack(
 3,
 'math', cast(math_score as string),
 'english', cast(english_score as string),
 'chinese', cast(chinese_score as string)
) t AS subject, score;

表示一行拆成 3 行：

stu_id	subject	score
1	math	90
1	english	80
1	chinese	70
2	math	88
2	english	95
2	chinese	NULL

方法3：LATERAL VIEW explode

先把多个列构造成一个数组：

1
2
3
4
5


[
 {subject: 'math', score: math_score},
 {subject: 'english', score: english_score},
 {subject: 'chinese', score: chinese_score}
]

然后 explode 数组，把数组中的每个元素拆成一行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


SELECT
 stu_id,
 subject_score.subject AS subject,
 subject_score.score AS score
FROM interview.stu_score_wide
LATERAL VIEW explode(array(
 named_struct('subject', 'math', 'score', math_score),
 named_struct('subject', 'english', 'score', english_score),
 named_struct('subject', 'chinese', 'score', chinese_score)
)) tmp AS subject_score;

执行过程对比

UNION ALL：多分支、多扫描、最后 Union

1
2
3
4
5


 ┌─ TableScan -> Filter math -> Select ┐
 │ │
student table ├─ TableScan -> Filter english -> Select ├─ Union -> Output
 │ │
 └─ TableScan -> Filter chinese -> Select ┘

stack：单扫描、直接展开、不需要 Union

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


stu_score_wide table
 ↓
TableScan
 ↓
Select 原始列
 ↓
UDTF stack，一行变三行
 ↓
Lateral View Join，拼回 user_id
 ↓
Filter score IS NOT NULL
 ↓
Output

explode：单扫描、先构造复杂类型、再展开

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


student table
 ↓
TableScan
 ↓
Select 原始列
 ↓
构造 array<struct> （较stack多了这步）
 ↓
UDTF explode，一行变多行
 ↓
Lateral View Join，拼回 user_id
 ↓
Filter score IS NOT NULL
 ↓
Output

对比点	`UNION ALL`	`stack`	`explode(array(named_struct))`
扫描原表	可能多次	通常一次	通常一次
核心算子	`Union Operator`	`UDTFOperator + Lateral View`	`UDTFOperator + Lateral View`
是否构造复杂对象	否	否/较少	是，构造 array/struct
SQL 可读性	新手最好懂	简洁	稍复杂
大表性能	通常较差	通常较好	通常较好
列很多时	SQL 很长，计划复杂	更适合	可用但对象构造更重
处理复杂类型	不适合	一般	最适合
推荐场景	学习、少量列、兼容性	固定列转行首选	array/map/struct 拆行

a	b	c	pre_value	after_value	sum_pre_after
A	10	100	0	200	200
A	20	200	100	300	400
A	30	300	200	400	600
A	40	400	300	0	300
B	15	150	0	250	250
B	25	250	150	350	500
B	35	350	250	0	250

a	b	c	current_sum_value
A	10	100	300
A	20	200	600
A	30	300	900
A	40	400	700
B	15	150	400
B	25	250	750
B	35	350	600

a	b	c	pre_value	after_value	sum_pre_after
A	10	100	0	200	200
A	20	200	100	300	400
A	30	300	200	400	600
A	40	400	300	0	300
B	15	150	0	250	250
B	25	250	150	350	500
B	35	350	250	0	250

a	b	c	current_sum_value
A	10	100	300
A	20	200	600
A	30	300	900
A	40	400	700
B	15	150	400
B	25	250	750
B	35	350	600