Hive常用函数

已于 2023-03-08 16:48:42 修改
阅读量207 收藏
点赞数 1
分类专栏： Hive 大数据 文章标签： hive 大数据
于 2022-07-23 11:03:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/holiday0520/article/details/125944818
版权

Hive常用函数

文章目录

Hive 常用函数
关系运算
// 等值比较 = == <=>
// 不等值比较 != <>
// 区间比较： select * from default.students where id between 1500100001 and 1500100010;
// 空值/非空值判断：is null、is not null、nvl()、isnull()
// like、rlike、regexp用法
// and or not
数值计算
取整函数(四舍五入)：round
向上取整：ceil
向下取整：floor
条件函数
  • if： if(表达式,如果表达式成立的返回值,如果表达式不成立的返回值)
select if(1>0,1,0); 
select if(1>0,if(-1>0,-1,1),0);
select score,if(score>120,'优秀',if(score>100,'良好',if(score>90,'及格','不及格'))) as pingfen from score limit 20;
  • COALESCE
select COALESCE(null,'1','2'); // 1 从左往右 一次匹配 直到非空为止
select COALESCE('1',null,'2'); // 1
  • case when
select  score
        ,case when score>120 then '优秀'
              when score>100 then '良好'
              when score>90 then '及格'
        else '不及格'
        end as pingfen
from score limit 20;

select  name
        ,case name when "施笑槐" then "槐ge"
                  when "吕金鹏" then "鹏ge"
                  when "单乐蕊" then "蕊jie"
        else "算了不叫了"
        end as nickname
from students limit 10;

注意条件的顺序

日期函数
select from_unixtime(1610611142,'YYYY/MM/dd HH:mm:ss');

select from_unixtime(unix_timestamp(),'YYYY/MM/dd HH:mm:ss');

// '2021年01月14日' -> '2021-01-14'
select from_unixtime(unix_timestamp('2021年01月14日','yyyy年MM月dd日'),'yyyy-MM-dd');
// "04牛2021数加16逼" -> "2021/04/16"
select from_unixtime(unix_timestamp("04牛2021数加16逼","MM牛yyyy数加dd逼"),"yyyy/MM/dd");
字符串函数
concat('123','456'); // 123456
concat('123','456',null); // NULL

select concat_ws('#','a','b','c'); // a#b#c
select concat_ws('#','a','b','c',NULL); // a#b#c 可以指定分隔符，并且会自动忽略NULL
select concat_ws("|",cast(id as string),name,cast(age as string),gender,clazz) from students limit 10;

select substring("abcdefg",1); // abcdefg HQL中涉及到位置的时候 是从1开始计数
// '2021/01/14' -> '2021-01-14'
select concat_ws("-",substring('2021/01/14',1,4),substring('2021/01/14',6,2),substring('2021/01/14',9,2));
// 建议使用日期函数去做日期
select from_unixtime(unix_timestamp('2021/01/14','yyyy/MM/dd'),'yyyy-MM-dd');

select split("abcde,fgh",","); // ["abcde","fgh"]
select split("a,b,c,d,e,f",",")[2]; // c

select explode(split("abcde,fgh",",")); // abcde
										//  fgh

// 解析json格式的数据
select get_json_object('{"name":"zhangsan","age":18,"score":[{"course_name":"math","score":100},{"course_name":"english","score":60}]}',"$.score[0].score"); // 100
Hive中的wordCount
create table words(
    words string
)row format delimited fields terminated by '|';

// 数据
hello,java,hello,java,scala,python
hbase,hadoop,hadoop,hdfs,hive,hive
hbase,hadoop,hadoop,hdfs,hive,hive

select word,count(*) from (select explode(split(words,',')) word from words) a group by a.word;

// 结果
hadoop	4
hbase	2
hdfs	2
hello	2
hive	4
java	2
python	1
scala	1
Hive 开窗函数

好像给每一份数据 开一扇窗户 所以叫开窗函数

在sql中有一类函数叫做聚合函数,例如sum()、avg()、max()等等,这类函数可以将多行数据按照规则聚集为一行,一般来讲聚集后的行数是要少于聚集前的行数的.但是有时我们想要既显示聚集前的数据,又要显示聚集后的数据,这时我们便引入了窗口函数.

测试数据
111,69,class1,department1
112,80,class1,department1
113,74,class1,department1
114,94,class1,department1
115,93,class1,department1
121,74,class2,department1
122,86,class2,department1
123,78,class2,department1
124,70,class2,department1
211,93,class1,department2
212,83,class1,department2
213,94,class1,department2
214,94,class1,department2
215,82,class1,department2
216,74,class1,department2
221,99,class2,department2
222,78,class2,department2
223,74,class2,department2
224,80,class2,department2
225,85,class2,department2
建表语句
create table new_score(
    id  int
    ,score int
    ,clazz string
    ,department string
) row format delimited fields terminated by ",";
row_number：无并列排名
  • 用法： select xxxx, row_number() over(partition by 分组字段 order by 排序字段 desc) as rn from tb group by xxxx
dense_rank：有并列排名，并且依次递增
rank：有并列排名，不依次递增
percent_rank：(rank的结果-1)/(分区内数据的个数-1)
cume_dist：计算某个窗口或分区中某个值的累积分布。

假定升序排序，则使用以下公式确定累积分布： 小于等于当前值x的行数 / 窗口或partition分区内的总行数。其中，x 等于 order by 子句中指定的列的当前行中的值。

NTILE(n)：对分区内数据再分成n组，然后打上组号
max、min、avg、count、sum：基于每个partition分区内的数据做对应的计算
窗口帧：用于从分区中选择指定的多条记录，供窗口函数处理

Hive 提供了两种定义窗口帧的形式：ROWS 和 RANGE。两种类型都需要配置上界和下界。例如，ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW 表示选择分区起始记录到当前记录的所有行；SUM(close) RANGE BETWEEN 100 PRECEDING AND 200 FOLLOWING 则通过 字段差值 来进行选择。如当前行的 close 字段值是 200，那么这个窗口帧的定义就会选择分区中 close 字段值落在 100 至 400 区间的记录。以下是所有可能的窗口帧定义组合。如果没有定义窗口帧，则默认为 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW。

只能运用在max、min、avg、count、sum、FIRST_VALUE、LAST_VALUE这几个窗口函数上

(ROWS | RANGE) BETWEEN (UNBOUNDED | [num]) PRECEDING AND ([num] PRECEDING | CURRENT ROW | (UNBOUNDED | [num]) FOLLOWING)
(ROWS | RANGE) BETWEEN CURRENT ROW AND (CURRENT ROW | (UNBOUNDED | [num]) FOLLOWING)
(ROWS | RANGE) BETWEEN [num] FOLLOWING AND (UNBOUNDED | [num]) FOLLOWING
range between 3 PRECEDING and 11 FOLLOWING

SELECT id
        ,score
        ,clazz
        ,SUM(score) OVER w as sum_w
        ,round(avg(score) OVER w,3) as avg_w
        ,count(score) OVER w as cnt_w
FROM new_score
WINDOW w AS (PARTITION BY clazz ORDER BY score rows between 2 PRECEDING and 2 FOLLOWING);

111	69	class1	217	72.333	3
113	74	class1	297	74.25	4
216	74	class1	379	75.8	5
112	80	class1	393	78.6	5
215	82	class1	412	82.4	5
212	83	class1	431	86.2	5
211	93	class1	445	89.0	5
115	93	class1	457	91.4	5
213	94	class1	468	93.6	5
114	94	class1	375	93.75	4
214	94	class1	282	94.0	3
124	70	class2	218	72.667	3
121	74	class2	296	74.0	4
223	74	class2	374	74.8	5
222	78	class2	384	76.8	5
123	78	class2	395	79.0	5
224	80	class2	407	81.4	5
225	85	class2	428	85.6	5
122	86	class2	350	87.5	4
221	99	class2	270	90.0	3


select  id
        ,score
        ,clazz
        ,department
        ,row_number() over (partition by clazz order by score desc) as rn_rk
        ,dense_rank() over (partition by clazz order by score desc) as dense_rk
        ,rank() over (partition by clazz order by score desc) as rk
        ,percent_rank() over (partition by clazz order by score desc) as percent_rk
        ,round(cume_dist() over (partition by clazz order by score desc),3) as cume_rk
        ,NTILE(3) over (partition by clazz order by score desc) as ntile_num
        ,max(score) over (partition by clazz order by score desc range between 3 PRECEDING and 11 FOLLOWING) as max_p
from new_score;


id  score   clazz   department  rn_rk  ds_rk  rk  percent_rk  cume_rk ntile_num max_p
114	 94	    class1	department1	  1	     1	   1	  0.0	    0.273	   1	94
214	 94	    class1	department2	  2	     1	   1	  0.0	    0.273	   1	94
213	 94	    class1	department2	  3	     1	   1	  0.0	    0.273	   1	94
211	 93	    class1	department2	  4	     2	   4	  0.3	    0.455	   1	94
115	 93	    class1	department1	  5	     2	   4	  0.3	    0.455	   2	94
212	 83	    class1	department2	  6	     3	   6	  0.5	    0.545	   2	83
215	 82	    class1	department2	  7	     4	   7	  0.6	    0.636	   2	83
112	 80	    class1	department1	  8	     5	   8	  0.7	    0.727	   2	83
113	 74	    class1	department1	  9	     6	   9	  0.8	    0.909	   3	74
216	 74	    class1	department2	  10	 6	   9	  0.8	    0.909	   3	74
111	 69	    class1	department1	  11	 7	   11	  1.0	    1.0        3    69
221	 99	    class2	department2	  1	     1	   1	  0.0	    0.111	   1	99
122	 86	    class2	department1	  2	     2	   2	  0.125	    0.222	   1	86
225	 85	    class2	department2	  3	     3	   3	  0.25	    0.333	   1	86
224	 80	    class2	department2	  4	     4	   4	  0.375	    0.444	   2	80
123	 78	    class2	department1	  5	     5	   5	  0.5	    0.667	   2	80
222	 78	    class2	department2	  6	     5	   5	  0.5	    0.667	   2	80
121	 74	    class2	department1	  7	     6	   7	  0.75	    0.889	   3	74
223	 74	    class2	department2	  8	     6	   7	  0.75	    0.889	   3	74
124	 70	    class2	department1	  9	     7	   9	  1.0	    1.0        3    70
LAG(col,n)：往前第n行数据
LEAD(col,n)：往后第n行数据
FIRST_VALUE：取分组内排序后，截止到当前行，第一个值
LAST_VALUE：取分组内排序后，截止到当前行，最后一个值，对于并列的排名，取最后一个
select  id
        ,score
        ,clazz
        ,department
        ,lag(id,2) over (partition by clazz order by score desc) as lag_num
        ,LEAD(id,2) over (partition by clazz order by score desc) as lead_num
        ,FIRST_VALUE(id) over (partition by clazz order by score desc) as first_v_num
        ,LAST_VALUE(id) over (partition by clazz order by score desc) as last_v_num
        ,NTILE(3) over (partition by clazz order by score desc) as ntile_num
from new_score;


id  score   clazz   department  lag_num lead_num  first_v_num last_v_num  ntile_num
114	 94	    class1	department1	  NULL	   213	    114	          213	      1
214	 94	    class1	department2	  NULL	   211	    114	          213	      1
213	 94	    class1	department2	  114	   115	    114	          213	      1
211	 93	    class1	department2	  214	   212	    114	          115	      1
115	 93	    class1	department1	  213	   215	    114	          115	      2
212	 83	    class1	department2	  211	   112	    114	          212	      2
215	 82	    class1	department2	  115	   113	    114	          215	      2
112	 80	    class1	department1	  212	   216	    114	          112	      2
113	 74	    class1	department1	  215	   111	    114	          216	      3
216	 74	    class1	department2	  112	   NULL	    114	          216	      3
111	 69	    class1	department1	  113	   NULL	    114	          111	      3
221	 99	    class2	department2	  NULL	   225	    221	          221	      1
122	 86	    class2	department1	  NULL	   224	    221	          122	      1
225	 85	    class2	department2	  221	   123	    221	          225	      1
224	 80	    class2	department2	  122	   222	    221	          224	      2
123	 78	    class2	department1	  225	   121	    221	          222	      2
222	 78	    class2	department2	  224	   223	    221	          222	      2
121	 74	    class2	department1	  123	   124	    221	          223	      3
223	 74	    class2	department2	  222	   NULL	    221	          223	      3
124	 70	    class2	department1	  121	   NULL	    221	          124	      3

https://blog.csdn.net/qq_26937525/article/details/54925827

Hive 行转列

lateral view explode

create table testArray2(
    name string,
    weight array<string>
)row format delimited 
fields terminated by '\t'
COLLECTION ITEMS terminated by ',';

卡莎	"150","170","180"
亚索	"150","180","190"



select name,col1  from testarray2 lateral view explode(weight) t1 as col1;

卡莎	150
卡莎	170
卡莎	180
亚索	150
亚索	180
亚索	190

select key from (select explode(map('key1',1,'key2',2,'key3',3)) as (key,value)) t;

key1
key2
key3

select name,col1,col2  from testarray2 lateral view explode(map('key1',1,'key2',2,'key3',3)) t1 as col1,col2;
卡莎	key1	1
卡莎	key2	2
卡莎	key3	3
亚索	key1	1
亚索	key2	2
亚索	key3	3


select name,pos,col1  from testarray2 lateral view posexplode(weight) t1 as pos,col1;

卡莎	0	150
卡莎	1	170
卡莎	2	180
亚索	0	150
亚索 1	180
亚索	2	190
Hive 列转行
// testLieToLine
name col1
卡莎	150
卡莎	170
卡莎	180
亚索	150
亚索	180
亚索	190

create table testLieToLine(
    name string,
    col1 int
)row format delimited 
fields terminated by '\t';


select name,collect_list(col1) from testLieToLine group by name;

// 结果
亚索	["150","180","190"]
卡莎	["150","170","180"]

select  t1.name
        ,collect_list(t1.col1) 
from (
    select  name
            ,col1 
    from testarray2 
    lateral view explode(weight) t1 as col1
) t1 group by t1.name;
Hive自定义函数UserDefineFunction
UDF：一进一出
  • 创建maven项目，并加入依赖
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>1.2.1</version>
        </dependency>
  • 编写代码，继承org.apache.hadoop.hive.ql.exec.UDF，实现evaluate方法，在evaluate方法中实现自己的逻辑
import org.apache.hadoop.hive.ql.exec.UDF;

public class HiveUDF extends UDF {
    // hadoop => #hadoop$
    public String evaluate(String col1) {
    // 给传进来的数据左边加上#，右边加上$
        String result = "#" + col1 + "$";
        return result;
    }
}
  • 打成jar包并上传至Linux虚拟机
  • 在hive shell中，使用 add jar 路径将jar包作为资源添加到hive环境中
add jar /usr/local/soft/jars/HiveUDF2-1.0.jar;
  • 使用jar包资源注册一个临时函数，fxxx1是你的函数名，'MyUDF’是主类名
create temporary function fxxx1 as 'MyUDF';
  • 使用函数名处理数据
select fxx1(name) as fxx_name from students limit 10;

#施笑槐$
#吕金鹏$
#单乐蕊$
#葛德曜$
#宣谷芹$
#边昂雄$
#尚孤风$
#符半双$
#沈德昌$
#羿彦昌$
UDTF：一进多出

“key1:value1,key2:value2,key3:value3”

key1 value1

key2 value2

key3 value3

方法一：使用 explode+split
select split(t.col1,":")[0],split(t.col1,":")[1] 
from (select explode(split("key1:value1,key2:value2,key3:value3",",")) as col1) t;
方法二：自定UDTF
  • 代码
import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;

import java.util.ArrayList;

public class HiveUDTF extends GenericUDTF {
    // 指定输出的列名及类型
    @Override
    public StructObjectInspector initialize(StructObjectInspector argOIs) throws UDFArgumentException {
        ArrayList<String> filedNames = new ArrayList<String>();
        ArrayList<ObjectInspector> filedObj = new ArrayList<ObjectInspector>();
        filedNames.add("col1");
        filedObj.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
        filedNames.add("col2");
        filedObj.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
        return ObjectInspectorFactory.getStandardStructObjectInspector(filedNames, filedObj);
    }

    // 处理逻辑 my_udtf(col1,col2,col3)
    // "key1:value1,key2:value2,key3:value3"
    // my_udtf("key1:value1,key2:value2,key3:value3")
    public void process(Object[] objects) throws HiveException {
        // objects 表示传入的N列
        String col = objects[0].toString();
        // key1:value1  key2:value2  key3:value3
        String[] splits = col.split(",");
        for (String str : splits) {
            String[] cols = str.split(":");
            // 将数据输出
            forward(cols);
        }

    }

    // 在UDTF结束时调用
    public void close() throws HiveException {

    }
}
  • SQL
select my_udtf("key1:value1,key2:value2,key3:value3");

字段：id,col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11,col12 共13列

数据：

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

b,11,12,13,14,15,16,17,18,19,20,21,22

c,21,22,23,24,25,26,27,28,29,30,31,32

转成3列：id,hours,value

例如：

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

a,0时,1

a,2时,2

a,4时,3

a,6时,4

…

create table udtfData(
    id string
    ,col1 string
    ,col2 string
    ,col3 string
    ,col4 string
    ,col5 string
    ,col6 string
    ,col7 string
    ,col8 string
    ,col9 string
    ,col10 string
    ,col11 string
    ,col12 string
)row format delimited fields terminated by ',';

代码：

import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;

import java.util.ArrayList;

public class HiveUDTF2 extends GenericUDTF {
    @Override
    public StructObjectInspector initialize(StructObjectInspector argOIs) throws UDFArgumentException {
        ArrayList<String> filedNames = new ArrayList<String>();
        ArrayList<ObjectInspector> fieldObj = new ArrayList<ObjectInspector>();
        filedNames.add("col1");
        fieldObj.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
        filedNames.add("col2");
        fieldObj.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
        return ObjectInspectorFactory.getStandardStructObjectInspector(filedNames, fieldObj);
    }

    public void process(Object[] objects) throws HiveException {
        int hours = 0;
        for (Object obj : objects) {
            hours = hours + 1;
            String col = obj.toString();
            ArrayList<String> cols = new ArrayList<String>();
            cols.add(hours + "时");
            cols.add(col);
            forward(cols);
        }
    }

    public void close() throws HiveException {

    }
}

添加jar资源:

add jar /usr/local/soft/HiveUDF2-1.0.jar;

注册udtf函数：

create temporary function my_udtf as 'MyUDTF';

SQL:

select id,hours,value from udtfData lateral view my_udtf(col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11,col12) t as hours,value;
UDAF：多进一出
Hive Shell
第一种：
hive -e "select * from test1.students limit 10"
第二种：
hive -f hql文件路径

将HQL写在一个文件里，再使用 -f 参数指定该文件

没钳蟹蟹
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
hive常用函数
04-17
hive常用函数，包括时间、类型、udf、udaf等等的归纳。
【hive】中的concat函数
疯狂学PYTHON
12-19 3万+
与concat有关的函数有三个： 1、concat() 2、concat_ws() 3、group_concat() concat(str1,str2,str3,…) 连接参数的函数，返回结果为连接参数的字符串。如果有一个参数为NULL，则返回的结果为NULL。 concat(‘a’,‘b’,‘c’) ---- ‘abc’ concat(’‘a,null,’'c)----null concat_w...
【数据库】HIVE SQL中的字符串连接函数（CONCAT）
J小白的博客
02-11 1万+
众所周知，在MySQL、SQLSERVER中，都有字符串连接函数，那么，HQL也不例外。 在学习、工作中，不可避免的会遇到需要将两个字段合并展示的需要。 最基础的一个方法是：CONCAT('abc','def') 这个函数的用法有一点需要注意，就是当遇到字段为空时，空的形式不同，结果也不同。 eg：SELECT CONCAT('abc',NULL) 结果为NULL SEL...
Hive中的CONCAT、CONCAT_WS与COLLECT_SET函数
weixin_44852067的博客
03-14 1289
concat用于连接字符串。concat_ws用于按照指定的分隔符连接字符串。与group by和concat_ws一起使用可以实现"列转行。
hive中的拼接函数（concat,group_concat,concat_ws,collect_set）
zll_1234的博客
05-25 1万+
1、concat concat() 函数用于将多个字符串连接成一个字符串。 concat(string s1, string s2, string s3,…)表示通过s1、s2和s3连接一起 举例： +----+--------+ | id | name | +----+--------+ | 1 | city | +----+--------+ CONCAT(id,’:’,name) = 1:city 2、concat_ws concat_ws() 指定参数之间的分隔符 concat_ws(s
Hive中的常用concat函数——concat函数、concat_ws函数和group_concat函数
xdx_dili的博客
09-21 2154
Hive中的常用concat函数——concat函数、concat_ws函数和group_concat函数
Hive中实现有序，有序concat拼接，有序集合，hive方法操作命令，与自带方法列表
weixin_42923199的博客
12-04 3719
前言 记得以前用过这个函数，这次开发怎么都找不到了，不常用的原因，也是笔记没做好 方法一 GROUP_CONCAT(distinct id ORDER BY id DESC SEPARATOR ‘_’) 好像是用过的 这个报错：Invalid function GROUP_CONCAT 可能是版本问题：当前hive版本：hive-common-2.1.1-cdh6.2.0 apache-hive-1.2.1-也没有这个函数
Hive常用函数大全.pdf
04-14
hive常用函数大全，日期类别，函数类别等常用函数都可有；
hive常用函数参数手册
10-21
hive常用的函数参考手册，仅供参考，可能版本不一样，函数方法不一致,请以进官方文档为准，https://cwiki.apache.org/confluence/display/Hive/LanguageManual+UDF
Hive concat函数和concat_ws函数和concat_group函数&row_number over()和sum() over()&列转行,行转列
缘字诀的博客
01-03 8003
concat函数,concat_ws函数，concat_group函数 hivesql中的concat函数,concat_ws函数，concat_group函数之间的区别 CONCAT（）函数 CONCAT（）函数用于将多个字符串连接成一个字符串。 使用数据表Info作为示例，其中 SELECT id,name FROM info LIMIT 1;的返回结果为 ±—±-------+ | id ...
hive源码之concat函数
数仓老六
02-07 766
大家好，我是老六。今天和大家一起来看下hive中内置函数concat的源码。hive函数官方文档：LanguageManual UDF - Apache Hive - Apache Software Foundation 四、学习总结
【SQL相关】Hive行列字符串的合并与拆分
cielo的博客
11-24 2070
Hive行列字符串的合并与拆分。
MySQL中行列互转
程序猿集锦的博客
12-01 1042
微信搜索“coder-home”或扫一扫下面的二维码，关注公众号，第一时间了解更多干货分享，还有各类视频教程资源。扫描它，带走我 文章目录行转列与列转行的概念什么是行转列什么是列转行行转列实验示例示例一：使用聚合函数示例二：使用group_concat函数示例三：使用动态SQL语句块列转行实验示例示例一：使用union all功能示例二：使用substring_index函数最后总结 行转列与列转行的概念 这里需要重申一下行转列和列转行的区别。有很多的贴子在介绍的时候没有严格的区分，命名介绍的是列转行.
hive中的contact,concat_ws,collect_set(),explode实现行列互转
热门推荐
仙道Bob的专栏
09-26 3万+
hive工作中用到的一些拼接函数 1. concat(string s1, string s2, string s3) 这个函数能够把字符串类型的数据连接起来，连接的某个元素可以是列值。 如 concat( aa, ':', bb) 就相当于把aa列和bb列用冒号连接起来了，aa:bb。 2. cast 用法：cast(value as type) 功能：将某个列的值显示的转化为某个类型 例...
hive--字符串连接函数concat(),concat_ws()
nuhao的博客
02-28 891
功能：和concat()一样，将多个字符串连接成一个字符串，但是可以一次性指定分隔符～（concat_ws就是concat with separator）语法: concat_ws(string SEP, string A, string B…说明：返回输入字符串连接后的结果，SEP表示各个字符串间的分隔符。语法: concat(string A, string B…说明：返回输入字符串连接后的结果，支持任意个输入字符串。功能：将多个字符串连接成一个字符串。返回值: string。返回值: string。
Hive连接函数 concat 和 concat_ws 使用示例
qq_36382892的博客
03-14 819
CONCAT 函数：适用于简单的字符串拼接操作，将多个字符串连接成一个新的字符串。可以用于创建自定义的文本字段，合并多个字段的内容，或者添加固定的分隔符。适合在SQL查询中进行简单的字符串合并操作，不涉及复杂的逻辑或条件。CONCAT_WS 函数：适用于需要指定分隔符的字符串拼接操作，其中 WS 表示"with separator"。可以指定一个分隔符，将多个字符串连接起来，并在每个字符串之间插入指定的分隔符。
hive中的拼接函数contact,concat_ws,collect_set()及explode()，lateral view函数
mojolang
03-08 6919
hive工作中用到的一些拼接函数。 一， concat(string s1, string s2, string s3) 这个函数能够把字符串类型的数据连接起来，连接的某个元素可以是列值。 如 concat( aa, ‘:’, bb) 就相当于把aa列和bb列用冒号连接起来了，aa:bb。 二， cast 用法：cast(value as type) 功能：将某个列的值显示的转化为某个类型 例...
hive常用开窗函数
最新发布
05-15
Hive是一个基于Hadoop的数据仓库工具，它支持使用开窗函数进行数据分析，以下是Hive中常用的几个开窗函数： 1. ROW_NUMBER()：为每一行数据赋予一个序号，常用于排序和分组。 2. RANK()：计算每个分组内的排名，相同...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

没钳蟹蟹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值