1、数据仓库是企业发展到一定的阶段,现有的发展状况不能满足企业的需求,需要基于企业和行业历史数据来进行智能化的统计分析,通过分析挖掘出有价值的东西,为决策者或者领导层提供科学的决策支持,用于改善企业的业务流程,运行成本,企业效益、提高客户的体验度。
2、数仓中的数据是来自各种各样的数据源,为了分析,不择手段,只要有利于分析的数据,都可以集成到数仓中
3、目前,我们以为数据数仓中的数据是存在HDFS上的
HDFS:文件 ----> 数仓管理工具 ----->数据库表 ----> HiveSQL/SparkSQL
面向主题的(Subject-Oriented )
我们分析一般都是泛泛而谈,一定是由一个或者主题:销售角度、客户角度、商家角度、产品的角度,数仓中的数据一定是要划分主题的
集成的(Integrated)
数仓的数据可以来自各种四面八方的数据,都集成在一起,集成之后,数据之间会存在格式上的差异,我们通过ETL机制来消除这种差异
稳定的(Non-Volatile)
1、离线数仓中的数据都是历史数据(历史不容更改)
2、在下一个采集周期到来之前,数仓中的数据是不变的(HiveSQL不支持update和delete命令)
时变的(Time-Variant )
当下一个采集周期到来之前,数仓中的数据要及时的更新(T+1机制)
1、数据库的数据是面向业务,面向事务(OLTP)的,面向客户的,如果数据丢了,整个企业的业务就无法开展,数据库是为了让企业活下来
2、数据仓库是面向分析(OLAP)的,面向大数据工程师的,数据仓库是让企业活的更好
3、数据库一般是存放业务数据,数据状态都是最新的
4、数仓一般存放是历史数据,数据不是最新的
5、数据库的表在设计是避免出现冗余:ER图、 三大范式
6、数仓为了分析允许数据出现冗余,怎么便于分析就怎么来
7、数据库强调时效性,要求请求和响应之间的时间在毫秒级别
8、数仓具有延时性,一般处理过程比较长
9、数据库面向客户,必须保证安全性,一旦有问题就是大问题
10、数据仓库是面向内部人员,安全级别较低
#关系
数仓的数据可以来自数据库
#数据分析为什么需要单独搞一个数仓,不在业务数据库上直接分析
1、业务数据库本身需要消耗服务器资源,数据分析不能去抢占业务的资源
2、数据库只是数仓其中一种数据源,数仓可以是多种数据源的集合
3、业务数据库就是为业务而生的,不具备很多大数据分析所需要的的体系结构
概念
1、数仓分层实际上描述的是数据在数仓中不同的处理阶段
2、数仓的分层没有统一的标准,每一个公司可能都不一样
3、通用的数仓分层
DA层/APP层 存放分析后的结果数据 数据结果
dw层 存放ods层预处理过的数据 数据干净 可以直接用于分析
DWS层
DWB层
DWD层
ods源数据层 存放最原始的结构化数据 数据原始
抽取(extract)
从数据源根据需求采集需要的指定数据:Sqoop 、Kettle、 Flume
转换(transform)
将抽取后的数据进行前期的分离处理,格式转换,字典表翻译、数据质量的空值
加载(load)
将转换后的数据加载数仓中
1、Hive是数仓管理工具,用来管理数仓
2、Hive可以将数仓存在HDFS上的文件变成一张张的表
3、Hive提供一种HiveSQL可以表进行分析处理
4、HiveSQL底层默认是MapReduce,以后可以换成其他的引擎(Spark),我们写HiveSQL会去匹配底层的MR模板,匹配上则执行,否则不能执行
1、Hive本身只是一个工具,它不存任何数据: Hive的表数据存在HDFS上,Hive的元数据(表结构和HDFS文件之间的映射关系)存在第三方的数据库中(MySQL)
select * from itheima_order_goods;
2、Hive底层引擎默认是MapReduce,你也可以换成其他引擎(Tez,Spark)
方式1
hive #个人测试
方式2(生产环境)
hive -e "show databases;" #直接执行HiveSQL命令
hive -f test1.sql #直接执行HiveSQL脚本 (生产环境)
方式3-beeline
1、beenline是Hive的第二代客户端 #个人测试
2、操作方式
[root@node3 ~]# beeline
beeline> !connect jdbc:hive2://node3:10000
Connecting to jdbc:hive2://node3:10000
Enter username for jdbc:hive2://node3:10000: root
Enter password for jdbc:hive2://node3:10000:123456
3、我们可以使用expect脚本来实现一键进入beenline
1、当我们在hive中创建一个数据库,则Hive默认会自动会在/user/hive/warehouse/目录下创建一个数据库目录
create database if not exists myhive; #/user/hive/warehouse/myhive.db
2、当我们在Hive中创建一个数据库,则Hive会在MySQL中记录一条元数据
-- 1、创建数据库
create database if not exists myhive;
-- 2、创建数据库并手动指定数据库存放目录
create database if not exists myhive2 location '/myhive2'
--3、查看数据库的元数据信息
desc database myhive;
--4、删除数据库
drop database mytest; -- 只能删除空数据库
drop database myhive2 cascade ; -- 可以删除任何数据库(强删)
Hive中常见的数据类型有三种:string、int/tinyint 、 double/decimal(10,2)
前置内容
1、Hive表文件默认的分隔符是'\001'
2、Hive默认不允许对数据进行删除和修改,不支持update和delete
delete from stu where id = 2; #报错
update stu set name = 'ls2' where id = 2; #报错
truncate table stu; #不会报错,支持
3、Hive中创建表,自动在HDFS的数据库目录创建对应的表目录(如果加了location关键字则除外),默认表目录的名字和表名一样
内部表
1、内部表是私有表,一旦给表加载数据之后,内部表认为这份数据就是他独占的,表一旦删除,表数据文件会跟着全部删除,如果在应用中,数据是部门内部的,或者个人的,则表可以设置为内部表,不会对其他人造成影响。
2、外部表创建语法: create table 表
use myhive;
-- 1、创建内部表-使用默认分隔符:'\001'
create table stu(id int, name string);
-- 加载数据
insert into stu values (1,'zs');
insert into stu values (2,'ls');
select * from stu;
-- 2、创建内部表-使用指定分隔符: ','
create table stu2(id int, name string)
row format delimited fields terminated by ',';
insert into stu2 values (1,'zs');
insert into stu2 values (2,'ls');
-- 开启本地模式
set hive.stats.column.autogather=false;
set hive.exec.mode.local.auto=true; --开启本地mr
-- 3、通过复制表结构来建表
create table stu3 as select * from stu2; -- 即复制表结构,又复制数据
create table stu4 like stu2; -- 仅复制表结构
-- 4、查看表的元数据信息
desc stu2; -- 查看字段信息(简单)
desc formatted stu2; -- 查看详细的元数据信息
-- 5、删除表
-- 内部表删除,将表数据和元数据全部删除
drop table stu2;
select * from stu;
-- 6、给表加载数据(最正式的) - 本地 -复制
create table stux(id int, name string)
row format delimited fields terminated by '\t';
-- 从本地加载--复制
load data local inpath '/export/data/hivedatas/1.txt' into table stux;
select * from stux;
-- 6、给表加载数据(最正式的) - HDFS - 剪切
create table stuy(id int, name string)
row format delimited fields terminated by '\t';
load data inpath '/input/hivedatas/1.txt' into table stuy;
select * from stuy;
外部表
1、外部表是公有表,一旦给表加载数据之后,外部表认为这份数据大家的,表一旦删除,表数据文件不会删除,只删除表和文件之间的映射关系,如果在应用中,数据是各部门共享,则可以设置为外部表,你的表只是对文件有访问权。
2、外部表创建语法: create external table 表...
-- 1、创建外部表
create external table teacher
(
tid string,
tname string
) row format delimited fields terminated by '\t';
create external table student
(
sid string,
sname string,
sbirth string,
ssex string
) row format delimited fields terminated by '\t';
-- 加载数据
load data local inpath '/export/data/hivedatas/student.txt' into table student;
load data local inpath '/export/data/hivedatas/teacher.txt' into table teacher;
select * from student;
select * from teacher;
-- 删除表,只删除元数据,不会删除表数据
drop table teacher;
多个外部表共享数据
-- 模拟多张表共享一份数据
drop table covid1;
create external table covid1(
date_val string,
country string,
state string,
code string,
cases int,
deaths int
)
row format delimited fields terminated by ','
location '/input/covid';
select * from covid1;
create external table covid2(
date_val string,
country string,
state string,
code string,
cases int,
deaths int
)
row format delimited fields terminated by ','
location '/input/covid';
select * from covid2;
-- 删除covid1
drop table covid1;
select * from covid2;
-- 删除covid2
drop table covid2;
select * from covid2;
array类型
-- 1、准备数据
zhangsan beijing,shanghai,tianjin,hangzhou
wangwu changchun,chengdu,wuhan,beijing
-- 2、创建表
create external table hive_array
(
name string,
work_locations array<string>
)
row format delimited fields terminated by '\t'
collection items terminated by ',';
-- 3、加载数据
load data local inpath '/export/data/hivedatas/work_locations.txt' into table hive_array;
select * from hive_array;
-- 4、查询数据
-- 查询所有数据
select * from hive_array;
-- 查询work_locations数组中第一个元素
select name, work_locations[0] location from hive_array;
-- 查询location数组中元素的个数
select name, size(work_locations) location_size from hive_array;
-- 查询location数组中包含tianjin的信息
select * from hive_array where array_contains(work_locations,'tianjin');
map类型
-- 1、准备数据
1,zhangsan,father:xiaoming#mother:xiaohuang#brother:xiaoxu,28
2,lisi,father:mayun#mother:huangyi#brother:guanyu,22
3,wangwu,father:wangjianlin#mother:ruhua#sister:jingtian,29
4,mayun,father:mayongzhen#mother:angelababy,26
-- 2、建表
create table hive_map
(
id int,
name string,
members map<string,>,
age int
)
row format delimited fields terminated by ','
collection items terminated by '#'
map keys terminated by ':';
-- 3、加载数据
load data local inpath '/export/data/hivedatas/hive_map.txt' into table hive_map;
select * from hive_map;
-- 4、查询操作
select * from hive_map;
-- 根据键找对应的值
select id, name, members['father'] father, members['mother'] mother, age from hive_map;
-- 获取所有的键
select id, name, map_keys(members) as relation from hive_map;
-- 获取所有的值
select id, name, map_values(members) as relation from hive_map;
-- 获取键值对个数
select id,name,size(members) num from hive_map;
-- 获取有指定key的数据
-- 判断亲属关系中哪一个包含brother
select * from hive_map where array_contains(map_keys(members), 'brother');
-- 查找包含brother这个键的数据,并获取brother键对应的值
select id,name, members['brother'] brother from hive_map where array_contains(map_keys(members), 'brother');
struct类型
class 类名{
String name,
int age ,
double score
}
-- 1、准备数据
192.168.1.1#zhangsan:40
192.168.1.2#lisi:50
192.168.1.3#wangwu:60
192.168.1.4#zhaoliu:70
-- 2、创建表
create table hive_struct(
ip string,
info struct<name:string, age:int>
)
row format delimited fields terminated by '#'
collection items terminated by ':';
-- 3、给表加载数据
load data local inpath '/export/data/hivedatas/hive_struct.txt' into table hive_struct;
select * from hive_struct;
-- 4、查询表数据
select ip,info.name,info.age from hive_struct;
select ip,info from hive_struct;
介绍
1、分区表就是对一个表的文件数据进行分类管理,表现形式就是有很多的文件夹(dt=2019-02-27)
2、分区表的作用是以后查询时,我们可以手动指定对应分区的数据,避免全表扫描,提高查询效率
3、专业的介绍
所谓的分区表,指的就是将数据按照表中的某一个字段进行统一归类,并存储在表中的不同的位置,也就是说,一个分区就是一类,这一类的数据对应到hdfs存储上就是对应一个目录。当我们需要进行处理的时候,可以通过分区进行过滤,从而只取部分数据,而没必要取全部数据进行过滤,从而提升数据的处理效率。且分区表是可以分层级创建。
select * from 表 where dt = '2019-03-13'
4、分区表的关键字是Partition,这里的分区是MR中的分区没有关系
5、分区表可以有内部分区表,也可以有外部分区表
6、什么时候表数据不用分区:
1)几乎在实际应用中所有的表数据都要分区
2)如果你的数据量很小,而且数据很单一,此时可以不用分区
静态分区
----------------------单级分区----------------------------------
-- 1、创建单分区表
create table score
(
sid string,
cid string,
sscore int
)
partitioned by (dt string) -- 这个dt是分区字段和表字段没有关系,理论上可以随便写
row format delimited fields terminated by '\t';
-- 2、给分区表加载数据
-- 第一件事:在HDFS的表目录下创建文件夹:dt=2022-10-13 第二件事:将score.txt复制到该文件夹下
load data local inpath '/export/data/hivedatas/score.txt' into table score partition (dt='2022-10-13');
select * from score;
-- 再添加一个分区
load data local inpath '/export/data/hivedatas/score2.txt' into table score partition (dt='2022-10-14');
select * from score;
-- 3、查询数据
-- 查找dt=2022-10-13分区数据
select * from score where dt='2022-10-13';
-- 查找dt=2022-10-14分区数据
select * from score where dt='2022-10-14';
desc score; -- 查看哪个是分区列
----------------------多级分区----------------------------------
-- 1、创建多级分区表
create table score2
(
sid string,
cid string,
sscore int
)
partitioned by (year string, month string ,dt string) -- 这个dt是分区字段和表字段没有关系,理论上可以随便写
row format delimited fields terminated by '\t';
-- 2、给分区表加载数据
-- 第一件事:在HDFS的表目录下创建三级文件夹:year=2022/month=10/dt=13 第二件事:将score.txt复制到该文件夹下
load data local inpath '/export/data/hivedatas/score.txt'
into table score2 partition (year='2022',month='10',dt='13');
select * from score2;
-- 再添加一个分区
load data local inpath '/export/data/hivedatas/score2.txt'
into table score2 partition (year='2022',month='11',dt='13');
-- 再添加一个分区
load data local inpath '/export/data/hivedatas/score2.txt'
into table score2 partition (year='2023',month='11',dt='13');
select * from score2;
-- 3、查询分区数据:查询 2022年 10月13号数据
select * from score2 where year='2022' and month = '10' and dt = '13';
----------------------分区相关的SQL----------------------------------
show partitions score; -- 查看表所有分区情况
alter table score add partition(dt='2022-01-01'); -- 手动添加一个分区
alter table score drop partition(dt='2022-01-01'); -- 手动删除一个分区
动态分区
-- -----------------------单级分区:按照日进行分区---------------------------------
-- 1、开启动态分区
set hive.exec.dynamic.partition=true; -- 开启动态分区
set hive.exec.dynamic.partition.mode=nonstrict;-- 设置为非严格格式
-- 2、模拟数据
/*
1 2022-01-01 zhangsan 80
2 2022-01-01 lisi 70
3 2022-01-01 wangwu 90
1 2022-01-02 zhangsan 90
2 2022-01-02 lisi 65
3 2022-01-02 wangwu 96
1 2022-01-03 zhangsan 91
2 2022-01-03 lisi 66
3 2022-01-03 wangwu 96
*/
-- 3、创建一个中间普通表(该表用来存入原始数据)
create table test1
(
id int,
date_val string,
name string,
score int
)
row format delimited fields terminated by '\t';
-- 4、给普通表加载数据
load data local inpath '/export/data/hivedatas/partition.txt' into table test1;
-- 5、来创建最终的分区表
create table test2
(
id int,
name string,
score int
)
partitioned by (dt string) -- 这个分区字段的名字随便写,它来决定HDFS上文件夹的名字:day=2022-01-01
row format delimited fields terminated by ',';
-- 6、查询普通表,将数据插入到分区表
insert overwrite table test2 partition (dt)
select id, name, score, date_val from test1;
select * from test2;
-- -----------------------单级分区:按照月进行分区---------------------------------
1 2022-01-01 zhangsan 80
2 2022-01-01 lisi 70
3 2022-01-01 wangwu 90
1 2022-01-02 zhangsan 90
2 2022-01-02 lisi 65
3 2022-01-02 wangwu 96
1 2022-01-03 zhangsan 91
2 2022-01-03 lisi 66
3 2022-01-03 wangwu 96
1 2022-02-01 zhangsan 80
2 2022-02-01 lisi 70
3 2022-02-01 wangwu 90
1 2022-02-02 zhangsan 90
2 2022-02-02 lisi 65
3 2022-02-02 wangwu 96
1 2022-02-03 zhangsan 91
2 2022-02-03 lisi 66
3 2022-02-03 wangwu 96
load data local inpath '/export/data/hivedatas/partition2.txt' overwrite into table test1;
drop table test2_1;
create table test2_1
(
id int,
date_val string,
name string,
score int
)
partitioned by (month string) -- 这个分区字段的名字随便写,它来决定HDFS上文件夹的名字:day=2022-01-01
row format delimited fields terminated by ',';
-- 6、查询普通表,将数据插入到分区表
insert overwrite table test2_1 partition (month)
select id, date_val,name, score, substring(date_val,1,7) from test1;
-- 1、创建普通表
drop table if exists test3;
create table test3
(
id int,
date_val string,
name string,
sex string,
score int
)
row format delimited fields terminated by '\t';
;
-- 2、给普通表加载数据
load data local inpath '/export/data/hivedatas/partition3.txt' overwrite into table test3;
select * from test3;
-- 3、创建最终的分区表
drop table test4;
create table test4
(
id int,
name string,
score int
)
partitioned by (xxx string, yyy string)
row format delimited fields terminated by '\t'
;
-- 4、去普通表查询,将查询后的结果插入到最终的分区表
insert overwrite table test4
select id, name, score,date_val,sex from test3; -- 这里的动态分区是看最后的两个字段
概念
1、分桶就是MR的分区
2、分桶表的表现形式就是分文件,可以通俗的理解为将一个大的表文件拆分成多个小文件
3、分桶的作用有两个:
作用1:主要是来提高多张表join的效率
作用2:主要是用于数据的抽样
4、分桶的方式就是拿到分桶字段的值,然后取hash值对分桶的个数取模
专业说法:
在表或者分区中使用分桶通常有两个原因,一个是为了高效的join查询,另一个则是为了高效的抽样。
桶其实是在表中加入了特殊的结构,hive在查询的时候可以利用这些结构来提高查询效率。比如,
如果两个表根据相同的字段进行分桶,则在对这两个表进行join关联的时候可以使用map-side关联高效实现。
分桶表的操作
-- 1、创建分桶表
create table course
(
cid string,
c_name string,
tid string
)
clustered by (cid) into 3 buckets
row format delimited fields terminated by '\t';
-- 解释:
clustered by (cid) into 3 buckets 表示按照cid 这一列进行分桶,并且将表数据分到3个桶中(3个文件中)
-- 2、创建普通表
create table course_common
(
cid string,
c_name string,
tid string
) row format delimited fields terminated by '\t';
-- 3、给普通表加载数据
load data local inpath '/export/data/hivedatas/course.txt' into table course_common;
select * from course_common;
-- 4、将普通表的数据进行查询插入到普通表
insert overwrite table course
select * from course_common cluster by (cid);
select * from course;
作用2 -可以用于数据的抽样
1、有时候在大数据分析时,我们并不需要全部的数据参与分析,而只需要抽取一部分具有代表性的数据参与分析,这样可以提高分析的效率,此时就可以使用分桶表来完成
1 zs
2 ls
3 ww
4 zl
5 zq
6 mb
7 lf
8 we
9 zz
10 qw
-- 1、创建分桶表
drop table sample_test;
create table sample_test
(
sid int,
s_name string
)
clustered by (sid) into 6 buckets
row format delimited fields terminated by '\t';
-- 2、创建普通表
create table sample_common
(
sid int,
s_name string
) row format delimited fields terminated by '\t';
-- 3、给普通表加载数据
load data local inpath '/export/data/hivedatas/sample.txt' overwrite into table sample_common;
select * from sample_common;
set hive.stats.column.autogather=false;
set hive.exec.mode.local.auto=true; --开启本地mr
-- 4、将普通表的数据进行查询插入到普通表
insert overwrite table sample_test
select * from sample_common cluster by (sid);
select * from course;
-- 5、对数据进行抽样(先保留)
-- TABLESAMPLE (BUCKET x OUT OF y [ON colname]) 6 / 2 = 3
select * from sample_test tablesample ( bucket 1 out of 2 on sid);
/*
select * from student tablesample(bucket x out of y on id);
n:总桶数
x:从第几个桶开始抽取
y:必须是总桶数的因数或倍数(自定义)
z:共需抽取出的桶数(z=n/y)
select * from student tablesample(bucket 1 out of 2 on id);
z 数据属于第几个桶
1 第1个分桶的数据(1)
2 第3个分桶的数据(1+y)
3 第5个分桶的数据(3+y)
4 第7个分桶的数据(5+y)
5 第9个分桶的数据(7+y)
*/
-- 删表
drop table score4; #内部表和外部表的删除是不一样的
-- 清空表数据
truncate table score4; #只能清空内部表(管理表)
1、方式1:
insert into table score3 partition(dt ='2022-10-01') values ('001','002',100);
2、方式2 -(重要)
insert overwrite table score4 partition(dt ='2022-10-01')
select sid,cid,sscore from score;
3、方式3 -(重要)
load data local inpath '/export/data/hivedatas/score.txt' overwrite into table score5 partition(dt ='2022-10-01');
4、方式4
create table score5 as select * from score;
5、方式5 -(重要)
create external table score6 (sid string,cid string,sscore int) row format delimited fields terminated by '\t' location '/myscore6';
6、方式6
hadoop fs -put stu.txt /user/hive/warehouse/myhive.db/stu
7、方式7 -(重要)
sqoop框架将数据直接导入hive
-- 将sql查询的结果导出到本地磁盘
insert overwrite local directory '/export/data/exporthive'
row format delimited fields terminated by '\t'
select * from score where sscore > 85;
-- 将sql查询的结果导出到HDFS —(重要)
insert overwrite directory '/export/data/exporthive'
row format delimited fields terminated by '\t'
select * from score where sscore > 85;
-- 将Hive -e 命令的执行结果导出本地目录文件
hive -e "select * from myhive.score;" > /export/data/exporthive/score.txt
-- 将一张表的数据全部导出到HDFS
export table score to '/export/exporthive/score';
1、聚合函数对null的态度
create table test11(
id int,
score int
);
insert into test11 values (1,50);
insert into test11 values (2,50);
insert into test11 values (3,null);
insert into test11 values (4,50);
select * from test11;
select sum(score) from test11; // 150
select avg(score) from test11; // 150 / 3
select avg(if(score is null, 0, score)) from test11; // 150 / 4
select avg(coalesce(score,0)) from test11; // 150 / 4
2、limit关键字
select * from student limit 3;
select * from student limit 2,3; --从索引为2(从0开始)显示,显示3行
3、where条件查询
select * from score where sscore not in(80,90); -- 成绩不是80或者90
select * from score where not sscore in(80,90);-- 成绩不是80或者90
4、like关键字
select * from student where sname like '赵%'; -- 姓赵的
select * from student where sname like '%雷'; -- 名字最后一个字是 雷
select * from student where sname like '%雷%'; -- 名字中包含 雷
select * from student where sname like '_雷%'; -- 名字第二个字是 雷\
5、分组-group by
-- 分组之后每一组只剩下一条数据,所以select后边只能跟分组字段和聚合函数
select sid, sum(sscore) from score group by sid;
-- 分组之后的条件筛选是having,不是where
select sid, sum(sscore) as total_score from score group by sid having total_score > 450
内连接
-- 1、内连接:求交集
select * from teacher;
insert into teacher values ('04','赵六');
select * from teacher inner join course c on teacher.tid = c.tid;
select * from teacher join course c on teacher.tid = c.tid;
select * from teacher , course where teacher.tid = course.tid;
左外连接
-- 2、左外连接
-- 左外是以左表为主,把左表的数据全部输出,右表有对应的数据就输出,没有对应的数据就输出NULL
select * from teacher left join course c on teacher.tid = c.tid;
右外连接
-- 3、右外连接
select * from course;
insert into course values ('04','政治','05');
-- 右外是以右表为主,把右表的数据全部输出,左表有对应的数据就输出,没有对应的数据就输出NULL
select * from teacher right join course c on teacher.tid = c.tid;
满外连接
-- 4、满外连接
-- 查询左外连接和右外连接的并集
select * from teacher full join course c on teacher.tid = c.tid;
order by (重点)
1、order by 用于全局排序,要求只能有一个Reduce
2、如果有多个Reduce,则不能使用order by
3、order by 的使用方法和MySQL是一样的
select * from score order by sscore ; -- 升序排序
select * from score order by sscore desc; -- 降序排序
sort by
1、 sort by 会做两件事情:
1)会将表文件拆分成多个文件(默认的分区)
2)保证每一个输出的文件内容都有序
1)设置reduce个数
set mapreduce.job.reduces=3;
2)查询成绩按照成绩降序排列
select * from score sort by sscore;
3)将查询结果导入到文件中(按照成绩降序排列)
insert overwrite local directory '/export/data/exporthive/sort' select * from score sort by sscore;
distributed by + sort by(重点)
1、distributed by 会按照某个字段进行分区,sort by 会给每个分区的数据进行排序
1)设置reduce的个数,将我们对应的sid划分到对应的reduce当中去
set mapreduce.job.reduces=7;
2)通过distribute by进行数据的分区
insert overwrite local directory '/export/data/exporthive/distribute' select * from score distribute by sid sort by sscore;
cluster by
1、当distributed by 和 sort by字段相同时:cluster by 等价于 distributed by + sort by
cluster by id => distributed by id sort by id
2、当reduce个数 < id的个数时,排序有意义
id有100个 rduce 100个
set mapreduce.job.reduces=2;
insert overwrite local directory '/export/data/exporthive/cluster_by'
select * from score cluster by sid;
数学函数
-- 四舍五入函数
select round(3.1415926,4); -- 四舍五入 保留4位小数 3.1416
-- 获取 [1,100]之间的随机数
select `floor`(rand() * 100) + 1;
-- 向下取整
select floor(2.8999); -- 2
字符串函数
-- 字符串拼接
select concat(rand(),'-',sid) as sid, sname from student;
select concat(rand(),'-',sid) as sid, sname from student;
-- 字符串拼接,带分隔符
select concat_ws('-','2022','10','15');
select log10(100)
-- 字符串截取
select substr('2022-12-23 10:13:45',1,4); -- 2022
select substr('2022-12-23 10:13:45',6,6); -- 12
-- 字符串替换
select regexp_replace('foobar', 'oo|ar', '');
-- 解析URL
select parse_url('http://www.facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'HOST');
select parse_url('http://www.facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'PATH');
select parse_url('http://www.facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'QUERY');
select parse_url('http://www.facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'QUERY','k1');
select parse_url('http://www.facebook.com/path1/p.php?k1=v1&k2=v2#Ref1', 'QUERY','k2');
-- 字符串切割
select split('2022-12-23','-');
日期函数
-- 获取当前的时间
select `current_date`(); -- 2022-10-25
-- 将日期转为指定的格式
select date_format('2022-1-1 1:1:1','yyyy-MM-dd HH:mm:ss') -- 2022-01-01 01:01:01
select to_date('2022-01-01 01:01:01'); -- 年月日
select year('2022-01-01 01:01:01'); -- 年
select month('2022-01-01 01:01:01'); -- 月
select day('2022-01-01 01:01:01'); -- 日
select hour('2022-01-01 01:01:01'); -- 小时
select minute('2022-01-01 01:01:01'); -- 分钟
select second('2022-01-01 01:01:01'); -- 秒
select quarter('2022-10-15 01:01:01'); -- 季度
select weekofyear('2022-10-15 01:01:01'); -- 获取今年的第几周
select `dayofweek`('2022-10-16 01:01:01'); -- 获取今天是周几(1-7)
select date_add('2022-10-15',10); -- 将日期向后推10天
select date_add('2022-10-15',-10);-- 将日期向前推10天
select date_sub('2022-10-15',10); -- 将日期向前推10天
select abs(datediff('2022-02-13','2022-10-15')); -- 求日期之间的差值
if语句
-- 标记每个学生的及格和不及格的情况
select *, if(sscore >= 60,'及格','不及格') as flag from score;
-- 同时计算及格和不及格的平均分
select avg(if(sscore>=60,sscore,null)) as avg1,avg(if(sscore<60,sscore,null)) as avg2 from score
case when 语句
格式1
/*
订单号 金额 支付方式
order_id amount payment_type payment_name
1001 50 1 支付宝支付
1002 80 2 微信支付
1003 60 3 余额支付
1004 40 4 货到付款
*/
select
case payment_type
when 1
then '支付宝支付'
when 2
then '微信支付'
when 3
then '余额支付'
else '货到付款'
end as payment_name;
格式2
select
*,
case when sscore >= 90 and sscore <= 100
then '优秀'
when sscore >= 80
then '良好'
when sscore >= 60
then '一般'
else
'及格'
end as flag
from score;
select cast(12.35 as int);
select cast('123' as int);
select cast('2020-12-05' as date);
-- 1、准备数据
20 SMITH
30 ALLEN
30 WARD
20 JONES
30 MARTIN
30 BLAKE
10 CLARK
20 SCOTT
10 KING
30 TURNER
20 ADAMS
30 JAMES
20 FORD
10 MILLER
-- 2、创建表
create table emp(
deptno int,
ename string
) row format delimited fields terminated by '\t';
-- 3、加载数据
load data local inpath "/export/data/hivedatas/emp.txt" into table emp;
-- 4、实现功能
-- collect_set(去重)/collect_list(不去重) 可以将每一组的ename存入一个集合中(set集合,list集合)
select deptno, collect_list(ename) from emp group by deptno;
select deptno,concat_ws("|",collect_set(ename)) as ems from emp group by deptno;
select deptno, collect_set(ename)[0] from emp group by deptno; -- 用索引访问
概念
数据
10 CLARK|KING|MILLER|SCOTT|KING
20 SMITH|CLARK|JONES|SCOTT|ADAMS|FORD
30 ALLEN|WARD|CLARK|MARTIN|BLAKE|TURNER|JAMES
实现步骤
-- 创建表
create table myhive.emp2(
deptno int,
names array<string>
)
row format delimited fields terminated by '\t'
collection items terminated by '|';
-- 加载数据
load data local inpath '/export/data/hivedatas/emp2.txt' overwrite into table myhive.emp2;
use myhive;
-- 最终SQL,该SQL可以处理任何数据重复的情况
select * from emp2 lateral view explode(names) tmp_tb as name;
-- lateral view是一个侧视图关键字,后边一般跟UDTF函数(一进多出函数)
-- 格式: select 字段 from 原表 lateral view UDTF函数
select deptno,name from emp2 lateral view explode(names) tmp_tb as name;
概念
该函数可以调用Java中的静态方法,必须是静态的,而且是JDK自带的
用法
select col1,col2,reflect('java.lang.Math','max',col1,col2) as max_v from test_reflect;
select concat(reflect('java.util.UUID','randomUUID'),'-',sid) ,* from student;
分组排序函数
代码
-- partition by 类似 group by
-- order by 排序
select
*,
row_number() over (partition by userid order by pv desc) as rk1,
rank() over (partition by userid order by pv desc) as rk2,
dense_rank() over (partition by userid order by pv desc) rk3
from test_window_func1;
-- 如果没有partition by,则整张表就是一组
select
*,
dense_rank() over (order by pv desc) rk
from test_window_func1;
-- row_number() over() 如果没有order by ,则可以对数据进行去重
select
*,
row_number() over (partition by userid) rk
from test_window_func1;
-- 分组求 Top3
-- 子查询包裹的表必须有别名
select * from
(
select
*,
dense_rank() over (partition by userid order by pv desc) rk
from test_window_func1
)t
where rk <=3;
-- with语句用法
/*
with t1 as(
select 语句
), -- 这里不加逗号
t2 as (
select 语句
), -- 这里加逗号
t3 as (
select 语句
) -- 这里不加逗号
select
*
from t1 left join t2 on 条件
left jon t3 on 条件 ; -- 这里加分号
*/
with t1 as (
select
*,
dense_rank() over (partition by userid order by pv desc) rk
from test_window_func1
)
select * from t1 where rk <= 3;
聚合统计开窗函数(sum,avg,max,min)
-- sum
-- 默认从开头累加到当前行
select userid,createtime,pv,
sum(pv) over(partition by userid order by createtime) as pv1
from test_window_func1;
-- 从开头累加到当前行
select userid,createtime,pv,
sum(pv) over(partition by userid order by createtime rows between unbounded preceding and current row) as pv2
from test_window_func1;
--如果没有order by排序语句 默认把分组内的所有数据进行sum操作
select userid,createtime,pv,
sum(pv) over(partition by userid) as pv3
from test_window_func1;
-- 从当前行向上推三行 累加 到当前行
select userid,createtime,pv,
sum(pv) over(partition by userid order by createtime rows between 3 preceding and current row) as pv4
from test_window_func1;
-- 从当前行向上推三行 累加 到当前行的下一行
select userid,createtime,pv,
sum(pv) over(partition by userid order by createtime rows between 3 preceding and 1 following) as pv5
from test_window_func1;
-- 从当前行累加到最后
select userid,createtime,pv,
sum(pv) over(partition by userid order by createtime rows between current row and unbounded following) as pv6
from test_window_func1;
-- 从上一行 累加到最后
select userid,createtime,pv,
sum(pv) over(partition by userid order by createtime rows between 1 preceding and unbounded following) as pv6
from test_window_func1;
-- max
-- 从开头累加到当前行
select userid,createtime,pv,
max(pv) over(partition by userid order by createtime rows between unbounded preceding and current row) as pv2
from test_window_func1;
-- avg
select userid,createtime,pv,
avg(pv) over(partition by userid order by createtime rows between unbounded preceding and current row) as pv2
from test_window_func1;
-- count
select userid,createtime,pv,
count(pv) over(partition by userid order by createtime rows between unbounded preceding and current row) as pv2
from test_window_func1;
什么时候需要开窗函数
当我们需要对数据进行分组统计的同时,还想保留表的明细数据, 则此时就可以用开窗
常见的开窗函数
-- 聚合开窗函数
count(); -- 窗口内总条数
sum(); -- 窗口内数据的和
min(); -- 窗口内最小值
max(); -- 窗口内最大值
avg(); -- 窗口内的平均值
-- 排序开窗函数
row_number(); -- 从1开始,按照顺序,生成分组内记录的序列
rank(); -- 生成数据项在分组中的排名,排名相等会在名次中留下空位
dense_rank(); -- 生成数据项在分组中的排名,排名相等会在名次中不会留下空位
ntile(n); -- 将分区中已排序的行划分为大小尽可能相等的指定数量的排名的组,
-- 并返回给定行所在的组的排名。
percent_rank(); -- 计算给定行的百分比排名。可以用来计算超过了百分之多少的人。(当前行的rank值-1)/(分组内的总行数-1)
-- 如360小助手开机速度超过了百分之多少的人。
cume_dist(); -- 计算某个窗口或分区中某个值的累积分布。假定升序排序,则使用以下公式确定累积分布:
-- 小于等于当前值x的行数 / 窗口或partition分区内的总行数。其中,x 等于 order by 子句中指定的列的当前行中的值。
-- 其他窗口函数
FIRST_VALUE(); -- 返回分区中的第一个值。
LAST_VALUE(); -- 返回分区中的最后一个值。
LAG(col,n,default); -- 用于统计窗口内往上第n个值。
LEAD(col,n,default);-- 用于统计窗口内往下第n个值。
UDF
pom.xml
<dependencies>
<dependency>
<groupId>org.apache.hivegroupId>
<artifactId>hive-execartifactId>
<version>3.1.2version>
dependency>
<dependency>
<groupId>org.apache.hadoopgroupId>
<artifactId>hadoop-commonartifactId>
<version>3.3.0version>
dependency>
dependencies>
代码
/*
需求:
UDF --> 1行进来 一行出去
15812345678 ---> 158****5678
*/
@SuppressWarnings("all") //压制警告
public class MyUDF extends UDF {
public String evaluate(String phoneStr){
String str1 = phoneStr.substring(0,3); //158
String str2 = phoneStr.substring(7); //5678
return str1 + "****" + str2; //158****5678
}
}
转临时函数
1、将代码打包
2、将jar包上传到 /export/server/hive/lib目录,并重命名我们的jar包名称
cd /export/server/hive-3.1.2/lib
mv day19_udf-1.0-SNAPSHOT.jar my_udf.jar
3、hive的客户端添加我们的jar包
add jar /export/server/ hive-3.1.2 /lib/my_udf.jar
4、设置函数与我们的自定义函数关联-临时函数
create temporary function my_jiami as 'cn.itcast.udf.MyUDF';
5、使用自定义的临时函数
select my_jiami('15812345678') from test_user;
转永久函数
1、将代码打包
2、将jar包上传到/export/server/hive-3.1.2/lib目录,并重命名我们的jar包名称
cd /export/server/hive-3.1.2/lib
mv day19_udf-1.0-SNAPSHOT.jar my_udf.jar
3、把自定义函数的jar上传到hdfs中.
hadoop fs -mkdir /hive_func
hadoop fs -put my_udf.jar /hive_func
4. 创建永久函数
create function my_jiami2 as 'cn.itcast.udf.MyUDF'
using jar 'hdfs://node1:8020/hive_func/my_udf.jar';
5、 验证
select my_jiami2('15812345678') from test_user;
-- 特别强调;
DataGrip对永久函数支持不够友好,如果希望DataGrip能够永远识别永久函数,则需要重启Hadoop,重启Hive的两个RunJar
UDTF-单列
代码
public class MyUDTF extends GenericUDTF {
private final transient Object[] forwardListObj = new Object[1];
/**
1、该函数只会执行一次,主要完成初始化工作
*/
@Override
public StructObjectInspector initialize(StructObjectInspector argOIs) throws UDFArgumentException {
// 该集合用来指定转换之后出来的每一列叫什么名字(列名)
List<String> fieldNames = new ArrayList<>();
fieldNames.add("my_col1");
//fieldNames.add("my_col2");
// 该集合用来指定转换之后出来的每一列是什么类型(列类型) - String
List<ObjectInspector> fieldOIs = new ArrayList<ObjectInspector>() ;
fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
//fieldOIs.add(PrimitiveObjectInspectorFactory.javaIntObjectInspector);
return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs);
}
/**
* 每转换一行,该方法就会执行一次
* select my_udtf("zookeeper,hadoop,hdfs,hive,MapReduce",",") word;
* select my_udtf("张三:19,李四:20",":",",")
*
*
* @param objects
* @throws HiveException
*/
@Override
public void process(Object[] objects) throws HiveException {
//1:获取原始数据
String args = objects[0].toString(); // "zookeeper,hadoop,hdfs,hive,MapReduce"
//2:获取数据传入的第二个参数,此处为分隔符
String splitKey = objects[1].toString(); //","
//3.将原始数据按照传入的分隔符进行切分
String[] fields = args.split(splitKey); // ["zookeeper","hadoop","hdfs","hive","MapReduce"]
//4:遍历切分后的结果,并写出
for (String field : fields) {
//将每一个单词添加值对象数组
forwardListObj[0] = field;
//forwardListObj[1] = field;
//将对象数组内容写出 ,每调用一次forward,就会多出一行
forward(forwardListObj);
}
}
@Override
public void close() throws HiveException {
}
}
测试
这里的测试和UDF一模一样
select my_udtf("zookeeper,hadoop,hdfs,hive,MapReduce",",") word;
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;
import java.util.List;
public class MyUDTF2 extends GenericUDTF {
private final transient Object[] forwardListObj = new Object[2];
/**
1、该函数只会执行一次,主要完成初始化工作
*/
@Override
public StructObjectInspector initialize(StructObjectInspector argOIs) throws UDFArgumentException {
// 该集合用来指定转换之后出来的每一列叫什么名字(列名)
List<String> fieldNames = new ArrayList<>();
fieldNames.add("name");
fieldNames.add("age");
// 该集合用来指定转换之后出来的每一列是什么类型(列类型) - String , Int
List<ObjectInspector> fieldOIs = new ArrayList<ObjectInspector>() ;
fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
fieldOIs.add(PrimitiveObjectInspectorFactory.javaIntObjectInspector);
return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs);
}
/**
* 每转换一行,该方法就会执行一次
* select my_udtf("张三:19,李四:20,王五:21",",",":")
* @param objects
* @throws HiveException
*/
@Override
public void process(Object[] objects) throws HiveException {
//1:获取原始数据
String line = objects[0].toString(); // "张三:19,李四:20,王五:21"
//2:获取数据传入的第二个参数,此处逗号隔符
String splitKey1 = objects[1].toString(); //","
//3:获取数据传入的第二个参数,此处冒号分隔符
String splitKey2 = objects[2].toString(); //":"
//4:使用逗号将数据切分成一个个的键值对
String[] array1 = line.split(splitKey1); //["张三:19","李四:20","王五:21"]
//5:遍历数组
for (String kv : array1) {
String[] array2 = kv.split(splitKey2); // ["张三",19]
forwardListObj[0] = array2[0]; // "张三"
forwardListObj[1] = Integer.parseInt(array2[1]); //19
forward(forwardListObj);
}
}
@Override
public void close() throws HiveException {
}
}
select my_udtf("张三:19,李四:20",",",":")
概念
1、Hive底层默认是MaReduce,Hive的压缩实际上就是MapReduce的压缩
2、MapReduce压缩分为Map端结果文件压缩和Reduce端结果文件压缩
参数设置
-- 开启Map端压缩
set hive.exec.compress.intermediate=true;
set mapreduce.map.output.compress=true;
set mapreduce.map.output.compress.codec= org.apache.hadoop.io.compress.SnappyCodec;
-- 1)开启hive最终输出数据压缩功能
set hive.exec.compress.output=true;
-- 2)开启mapreduce最终输出数据压缩
set mapreduce.output.fileoutputformat.compress=true;
-- 3)设置mapreduce最终数据输出压缩方式
set mapreduce.output.fileoutputformat.compress.codec = org.apache.hadoop.io.compress.SnappyCodec;
-- 4)设置mapreduce最终数据输出压缩为块压缩
set mapreduce.output.fileoutputformat.compress.type=BLOCK;
行存储
列存储
ORC
1:orc格式采用更加合理的数据的摆放方式,让元数据存储空间更小
2:orc格式默认内部是有压缩的,使用的压缩算法是ZLIB
PARQUET
1、注意,我们以后几乎所有的表存储都是列存储,因为列存储更符合我们的需求
2、我们项目中使用的列存储时ORC格式
3、一般的列存储在内部会有一些索引,可以提高查询的效率
SQL实现
-- 创建文本表
create table log_text (
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
STORED AS TEXTFILE ;
-- 给文本表加载数据
load data local inpath '/export/data/hivedatas/log.data' into table log_text;
select * from log_text; -- Text表文件的大小是: 18.13M
-- 创建ORC表
create table log_orc(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
stored as orc;
load data local inpath '/export/data/hivedatas/log.data' into table log_orc;
-- 查询文本表,并将查询的数据插入到ORC格式的表
insert overwrite table log_orc select * from log_text;
select * from log_orc; -- ORC表文件的大小是: 2.78M
-- 创建PARQUET表
create table log_parquet(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
stored as parquet ;
-- 查询文本表,并将查询的数据插入到PARQUET格式的表
insert overwrite table log_parquet select * from log_text;
select * from log_orc; -- PARQUET表文件的大小是: 13.09M
概念
理论上Hive支持的任何一个存储格式都可以和hive支持的任何一个压缩方式进行结合
SQL
-- 使用纯ORC,不使用任何的压缩算法
create table log_orc_none(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
STORED AS orc tblproperties ("orc.compress"="NONE");
insert overwrite table log_orc_none select * from log_text;
select * from log_orc_none ; -- 7.69M
-- 使用ORC,使用ORC默认的压缩算法ZLIB
create table log_orc_zlib(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
STORED AS orc tblproperties ("orc.compress"="ZLIB");
insert overwrite table log_orc_zlib select * from log_text;
select * from log_orc_none ; -- 2.78M
-- 使用ORC,使用SNAPPY压缩算法!!!!!!!!!!!!!!!!!!!!
create table log_orc_snappy(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
STORED AS orc tblproperties ("orc.compress"="SNAPPY");
insert overwrite table log_orc_snappy select * from log_text;
select * from log_orc_snappy ; -- 3.75 MB
create table log_parquet_snappy(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
STORED AS parquet tblproperties ("orc.compress"="SNAPPY");
insert overwrite table log_parquet_snappy select * from log_text;
select * from log_parquet_snappy ; -- 13.09 MB
结论
普通查询
select * from 表A a left join 表B b on a.id = b.id where 过滤a表和b表的最新数据
高效率查询-谓词下推
select * from 表A a where 过滤a表的最新数据
select * from 表B b where 过滤b表的最新数据
select * from (select * from 表A a where 过滤a表的最新数据) a left join (select * from 表B b where 过滤b表的最新数据) b on a.id = b.id
set hive.exec.reducers.bytes.per.reducer=32123456;
set mapreduce.job.reduces=7;
INSERT OVERWRITE TABLE jointable
SELECT a.*
FROM nullidtable a
LEFT JOIN ori b ON CASE WHEN a.id IS NULL THEN concat('hive', rand()) ELSE a.id END = b.id;
1 2022-01-01 zhangsan 80
1 2022-01-01 zhangsan 80
1 2022-01-01 zhangsan 80
2 2022-01-01 lisi 70
2 2022-01-01 lisi 70
2 2022-01-01 lisi 70
------------去重--------------
1 2022-01-01 zhangsan 80
2 2022-01-01 lisi 70
1、distinct
select distinct * from 表
注意,在Hive中distinct必须只有一个reduce才能完成整体的去重,效率极低,千万不要用
2、group by 去重
select sid,sname,sbirth,ssex from student2 group by sid,sname,sbirth,ssex;
3、row_number() over()去重
with t as (
select
*,
row_number() over (partition by sid ) rk
from student2
)
select * from t where rk = 1;
注意,生产环境就用该方式进行去重,这里不能使用rank和dense_rank()
set hive.exec.reducers.bytes.per.reducer=32123456;
set mapreduce.job.reduces=7;
INSERT OVERWRITE TABLE jointable
SELECT a.*
FROM nullidtable a
LEFT JOIN ori b ON CASE WHEN a.id IS NULL THEN 'hive' ELSE a.id END = b.id;
select * from A表 where 条件
union all
select * from B表 where 条件
union all
select * from C表 where 条件
当多个SQL之间没有依赖关系,则可以让他们同时执行
set hive.exec.parallel=true; -- 开启并行执行
set hive.exec.parallel.thread.number=16; -- 最多允许有多少个SQL可以并行执行
select * from (select * from (select * from )) -- 该SQL不能使用并行执行,因为有依赖关系
#在严格模式下,会对你的很多SQL做一定的约束,约束一些你的低效率SQL
set hive.mapred.mode = strict; -- 开启严格模式
set hive.mapred.mode = nostrict; -- 开启非严格模式
select * from score where dt='2022-10-13'; -- 在严格模式下,分区表必须加分区条件
select * from score where dt='2022-10-13' order by sscore limit 10; -- order by 必须加limit
select * from (select * from score where dt='2022-10-13') a
join (select * from score where dt='2022-10-13')b
on a.sid = b.sid; -- join时必须加on条件
1、 distinct
2、 order by