Hive调优

最新推荐文章于 2024-05-15 23:24:14 发布

DevinKim

最新推荐文章于 2024-05-15 23:24:14 发布

阅读量671

点赞数 7

分类专栏： Hive 文章标签： Hive调优

本文链接：https://blog.csdn.net/Yanxu_Jin/article/details/99687488

版权

Hive 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Hive调优

一.Hive的数据压缩

MapReduce当中的数据压缩：MapTask输出的数据可以压缩。ReduceTask输出的数据也可以压缩。

1.MapReduce支持的压缩编码

以下了解，工作中一般只会使用Snappy压缩算法

压缩格式	工具	算法	文件扩展名	是否可切分
DEFAULT	无	DEFAULT	.deflate	否
Gzip	gzip	DEFAULT	.gz	否
bzip2	bzip2	bzip2	.bz2	是
LZO	lzop	LZO	.lzo	否
LZ4	无	LZ4	.lz4	否
Snappy	无	Snappy	.snappy	否

为了支持多种压缩/解压缩算法，Hadoop引入了编码/解码器，如下表所示

压缩格式	对应的编码/解码器
DEFLATE	org.apache.hadoop.io.compress.DefaultCodec
gzip	org.apache.hadoop.io.compress.GzipCodec
bzip2	org.apache.hadoop.io.compress.BZip2Codec
LZO	com.hadoop.compression.lzo.LzopCodec
LZ4	org.apache.hadoop.io.compress.Lz4Codec
Snappy	org.apache.hadoop.io.compress.SnappyCodec

压缩性能的比较

压缩算法	原始文件大小	压缩文件大小	压缩速度	解压速度
gzip	8.3GB	1.8GB	17.5MB/s	58MB/s
bzip2	8.3GB	1.1GB	2.4MB/s	9.5MB/s
LZO	8.3GB	2.9GB	49.3MB/s	74.6MB/s

Snappy的前身是Zippy。Google宣称它在这个库本身及其算法做了数据处理速度上的优化，它可以利用单颗Intel Corei7处理器内核处理至少每秒250MB~500MB的数据流。实际开发中必选Snappy压缩算法。

2.在Hadoop中配置压缩参数

详情还请查阅官网!!!
①core-site.xml配置文件

<!--输入压缩，Hadoop使用文件扩展名判断是否支持某种编解码器。-->
<!--以下为默认值-->
<property>
  <name>hadoop.proxyuser.root.hosts</name>
  <value>org.apache.hadoop.io.compress.DefaultCodec，org.apache.hadoop.io.compress.GzipCodec，org.apache.hadoop.io.compress.BZip2Codec，org.apache.hadoop.io.compress.Lz4Codec</value>
</property>

②mapred-site.xml配置文件

<!--设置map输出时是否启用压缩。默认值false -->
<property>
  <name>mapreduce.map.output.compress</name>
  <value>false</value>
</property>

<!--设置map输出时使用的压缩算法-->
<!--以下为默认值-->
<property>
  <name>mapreduce.map.output.compress.codec</name>
  <value>org.apache.hadoop.io.compress.DefaultCodec</value>
</property>

<!--设置reduce输出时是否启用压缩。默认值false -->
<property>
  <name>mapreduce.output.fileoutputformat.compress</name>
  <value>false</value>
</property>

<!--设置reduce输出时使用的压缩算法-->
<!--以下为默认值-->
<property>
  <name>mapreduce.output.fileoutputformat.compress.codec</name>
  <value>org.apache.hadoop.io.compress. DefaultCodec</value>
</property>

<!--设置reduce输出行式存储文件时使用的压缩算法-->
<!--属性值有: NONE、BLOCK，默认为RECORD-->
<property>
  <name>mapreduce.output.fileoutputformat.compress.type</name>
  <value>RECORD</value>
</property>

3.在Hive客户端配置压缩参数

①开启hive当中map输出的数据压缩

1. 开启hive中间传输数据压缩功能
    set hive.exec.compress.intermediate=true;
2. 开启mapreduce中map输出压缩功能
    set mapreduce.map.output.compress=true;
3. 设置mapreduce中map输出数据的压缩方式
    set mapreduce.map.output.compress.codec=org.apache.hadoop.io.compress.SnappyCodec;
4. 执行查询语句
	select count(1) from score;

②开启hive当中reduce输出的数据压缩

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;
5. 测试一下输出结果是否是压缩文件
    insert overwrite local directory '/export/servers/snappy' select * from score distribute by s_id sort by s_id desc;

二.Hive的数据存储格式

行式存储：textfile（文本文件），sequenceFile(行式存储)
列式存储：orc ，parquet

一般，
ODS层：原始数据层，数据一般都是textFile格式的。
DW层： 数据仓库层，数据一般都是orc格式的。DW层数据一般是从ODS层导入，供公司内部人员使用。

1.列式存储和行式存储(理解)

在这里插入图片描述上图左边为逻辑表，右边第一个为行式存储，第二个为列式存储。

行存储的特点：查询满足条件的一整行数据的时候，列存储则需要去每个聚集的字段找到对应的每个列的值，行存储只需要找到其中一个值，其余的值都在相邻地方，所以此时行存储查询的速度更快。
列存储的特点：因为每个字段的数据聚集存储，在查询只需要少数几个字段的时候，能大大减少读取的数据量；每个字段的数据类型一定是相同的，列式存储可以针对性的设计更好的设计压缩算法。在 select 某些字段时效率更高。
本文补充的第1条对几种文件格式做了详情介绍

2.各种存储格式的对比

使用textFile来存储，数据没有变化。
使用orc格式来存储，原始文件18.1M，存储后变成 2.8M，压缩比大概在6倍左右。一方面orc存储格式占用磁盘空间比较小，还有一个原因是因为orc自带一种压缩算法。
使用parquet格式来存储，原始文件18.1M，存储之后13.1M。
本文补充的第2条测试了几种主流文件存储格式对比实验

三.存储和压缩结合

工作当中，DW层数据存储格式使用ORC，压缩方式snappy

使用orc存储格式，原始文件18.1M，不带任何压缩方式，处理之后只剩下7.7M。
使用orc存储格式，使用snappy压缩方式：原始文件18.1M，处理之后数据3.8M。
本文补充的第3条以ORC文件格式进行了测试

四.Fetch抓取

Hive中对某些情况的查询可以不必使用MapReduce计算。例如:

select * from student;
select name， age from student;
select * from student limit 3;

在hive-default.xml.template文件中hive.fetch.task.conversion默认是more，该属性设置为more后，在全局查找、字段查找、limit查找等都不走MapReduce。如果 hive.fetch.task.conversion 这个参数设置为none，那么所有的查询都会执行MapReduce。

五.本地模式

如果数据量少的话，开启一个mapTask和一个reduceTask来处理整个数据，举例: 10个文件，每个文件2KB 会启动十个mapTask，资源分配的时间，远远大于数据处理的时间。对于大多数这种情况，Hive可以通过本地模式在单台机器上处理所有的任务。对于小数据集，执行时间可以明显被缩短。
开启本地模式：规定如果是数据量小于某一个值，或者文件的个数小于某一个值，就使用本地模式，启动一个maptask，启动一个reduceTask来处理。

#开启本地模式， 默认是不开启的
set hive.exec.mode.local.auto=true;

#设置如果输入的数据量小于某个值就使用本地模式
set hive.exec.mode.local.auto.inputbytes.max=51234560;

#设置输入的文件个数，如果小于某个值就使用本地模式
set hive.exec.mode.local.auto.input.files.max=10;

注意: 以上两个条件，是且的关系，两个条件都需要满足才会使用本地模式。

六.表的优化★

1.表的join：能过滤就过滤，过滤不掉，对于空值，就进行转换，避免数据倾斜。

①多个表关联：尽量多拆成一些中间表，避免SQL关联太多了，不知道哪一块慢了。

②大表join大表：

空key过滤
解释: 优化前是先join后再where进行过滤的，这样并没有减轻reduce的压力，优化后是在map端执行where，过滤器，然后再join的，这样大大降低了计算量。
举例: 有两张表，一张表有空 id，一张表没有空id，关联规则使用id来进行关联
如果空key过滤不掉，大量的null id的数据会发送到同一个reduceTask里面去，造成数据倾斜。
```
#不过滤空key
SELECT a.* FROM nullidtable a JOIN ori b ON a.id = b.id;

#过滤空key
SELECT a.* FROM (SELECT * FROM nullidtable WHERE id IS NOT NULL ) a JOIN ori b ON a.id = b.id;
```
空key转换
有时虽然某个key为空对应的数据很多，但是相应的数据不是异常数据，必须要包含在join的结果中，此时我们可以表a中key为空的字段赋一个随机的值，使得数据随机均匀地分不到不同的reducer上。例如：
```
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;
```

③MapJoin：Hive的组件优化器会寻找哪个表是小表，将小表加载到内存里面去。

set hive.auto.convert.join = true; #默认就是true
#大表小表的阈值设置（默认25M以下认为是小表）：
set hive.mapjoin.smalltable.filesize=25123456;

mapjoin的工作机制：首先先启动一个本地的task，本地的任务去寻找哪个表的数据是小表，然后将小表的数据加载到内存里面去。

2.Group By: 开启Map端聚合
默认情况下，Map阶段同一Key数据分发给一个reduce，当一个key数据过大时就倾斜了。并不是所有的聚合操作都需要在Reduce端完成，很多聚合操作都可以先在Map端进行部分聚合，最后在Reduce端得出最终结果。

1. 是否在Map端进行聚合，默认为True
    set hive.map.aggr = true;
2. 在Map端进行聚合操作的条目数目
    set hive.groupby.mapaggr.checkinterval = 100000;
3. 有数据倾斜的时候进行负载均衡（默认是false）
    set hive.groupby.skewindata = true;

3.Count(Distinct)
由于count(distinct)操作需要用一个Reduce Task来完成，这一个Reduce需要处理的数据量太大，数据量大的情况下，就会导致整个Job很难完成。在这种情况下，可以使用先group by再count的方式替换count(distinct)。例如:

#使用count(distinct)
SELECT count(DISTINCT id) FROM bigtable;

#使用count() ... group by 替换count(distinct)
SELECT count(id) FROM (SELECT id FROM bigtable GROUP BY id) a;

4.任何时候都要避免笛卡尔积
即避免join的时候不加on条件，或者无效的on条件，Hive只能使用1个reducer来完成笛卡尔积。

5.列裁剪
在执行select * 查询时，行式存储的文件格式会比列式存储的文件格式查询效率高，然而，在DW层，文件常以列式存储的形式保存，因此我们要少用select *，尽可能使用select 列名;

6.分区表：
分区：‘表‘ 相当于一个大的目录，分区就是在这个大的目录下面创建一个个的小目录。分区字段不能是表中已经存在的字段，分区的字段不是真实存在的，但查询的时候带上分区字段也可提升查询效率。

分区有静态分区和动态分区两种:

静态分区：在建表的时候指定分区。
动态分区：如果用上述的静态分区，插入的时候必须首先要知道有什么分区类型，而且每个分区写一个load data，太烦人。使用动态分区可解决以上问题，其可以根据查询得到的数据动态分配到分区里。其实动态分区与静态分区区别就是不指定分区目录，由系统自己选择。
使用场景: 查询一个分区表A，将查询结果保存为一个新的分区表B，分区规则和A相同。需要使用Hive的动态分区，要先开启相应的配置。

#开启动态分区功能（默认就是true，开启）
set hive.exec.dynamic.partition=true;
          
#设置动态分区的模式为非严格模式
#默认strict，表示必须指定至少一个分区为静态分区
#nonstrict模式表示允许所有的分区字段都可以使用动态分区
set hive.exec.dynamic.partition.mode=nonstrict;

#设置一共最大可以创建动态分区文件夹1000个
set  hive.exec.max.dynamic.partitions=1000;

#设置每个mr的节点最大可以创建
set hive.exec.max.dynamic.partitions.pernode=100;

#设置整个MR Job中，最大可以创建多少个HDFS文件
set hive.exec.max.created.files=100000;

注意:

举例: 在上述配置的环境下，现在一共有20个节点：最大可以创建多少个分区文件夹? 不是20*100=2000，而是1000，因为受制于最大可以创建动态分区文件夹是1000个。
在linux系统当中，每个linux用户最多可以开启1024个进程，每一个进程最多可以打开2048个文件，即持有2048个文件句柄，hive.exec.max.created.files的属性值越大，可以打开文件句柄越大。
本文补充的第4条做了一个动态分区案例

7.使用分桶表

分桶表是对某一列数据进行哈希取值以将数据打散，然后放到不同文件中存储。
在hive分区表中，分区中的数据量过于庞大时，建议使用桶。
在分桶时，对指定字段的值进行hash运算得到hash值，并使用hash值除以桶的个数做取余运算得到的值进行分桶，保证每个桶中有数据但每个桶中的数据不一定相等。做hash运算时，hash函数的选择取决于分桶字段的数据类型。
分桶后的查询效率比分区后的查询效率更高
只能用insert overwrite 方式给桶表添加数据

七.数据倾斜调优

1.MapTask调优

问题一: MapTask的数量是由什么决定的?
默认是等于文件block块的数量。
MapReduce作业会启动读取数据组件InputFormat（默认TextInputFormat）通过getSplits方法对输入目录中文件进行逻辑切片规划得到splits，通常情况下，有多少个split就对应启动多少个MapTask。split与block的对应关系默认是一对一。

举例:

假设input目录下有1个文件a，大小为780M，那么hadoop会将该文件a分隔成7个块（6个128m的块和1个12m的块），从而产生7个map数。
假设input目录下有3个文件a，b，c大小分别为10m，20m，150m，那么hadoop会分隔成4个块（10m，20m，128m，22m），从而产生4个map数。即，如果文件大于块大小(128m)，那么会拆分，如果小于块大小，则把该文件当成一个块。

问题二: 是不是MapTask数越多越好？
不是。
如果一个任务有很多小文件（远远小于块大小128m），则每个小文件也会被当做一个块，用一个MapTask任务来完成，而一个MapTask任务启动和初始化的时间远远大于逻辑处理的时间，就会造成很大的资源浪费。而且，同时可执行的MapTask数是受限的。
所以，我们要适当减少MapTask的数量。

问题三: 怎么减少MapTask的数量?
在MapTask执行前合并小文件，减少MapTask数。

#参数设置:
    set mapred.max.split.size=112345600;
    set mapred.min.split.size.per.node=112345600;
    set mapred.min.split.size.per.rack=112345600;
    set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat;

参数解析: MapTask执行前对小文件合并，文件块大于128m的，按照128m来分隔；小于128m，大于100m的，按照100m来分隔；把那些小于100m的（包括小文件和分隔大文件剩下的），进行合并。

问题四: 是不是保证每个MapTask处理接近128m的文件块，就高枕无忧了？
不一定。
比如有一个127m的文件，正常会用一个MapTask去完成，但这个文件只有一个或者两个小字段，却有几千万的记录，如果map处理的逻辑比较复杂，用一个map任务去做，肯定也比较耗时。
所以，我们要适当增加MapTask的数量。
如果表a只有一个文件，大小为120M，但包含几千万的记录，如果用1个MapTask去完成这个任务，肯定是比较耗时的，这种情况下，我们要考虑将这一个文件合理的拆分成多个，这样就可以用多个map任务去完成。
set mapreduce.job.reduces =10;
这样会将a表的记录，随机的分散到包含10个文件的a_1表中，再用a_1代替上面sql中的a表，则会用10个MapTask去完成。
综上所述，设置MapTask数量需要遵循两个原则：使大数据量利用合适的MapTask数；使单个MapTask处理合适的数据量；

2.ReduceTask调优

调整ReduceTask个数方法一:

1. 每个ReduceTask处理的数据量默认是256MB
    hive.exec.reducers.bytes.per.reducer=256123456
2. 每个任务最大的ReduceTask数，默认为1009
    hive.exec.reducers.max=1009
3. 计算ReduceTask数的公式
    N=min(参数2，总输入数据量/参数1)

调整ReduceTask个数方法二:

#在hadoop的mapred-default.xml文件中修改， 设置每个job的ReduceTask个数
set mapreduce.job.reduces = 15;

问题: ReduceTask个数是不是越多越好?
不是。
过多的启动和初始化ReduceTask也会消耗时间和资源；
另外，有多少个ReduceTask，就会有多少个输出文件，如果生成了很多个小文件，那么如果这些小文件作为下一个任务的输入，则也会出现小文件过多的问题；
综上所述，设置ReduceTask个数也需要遵循两个原则：处理大数据量利用合适的ReduceTask数；使单个ReduceTask任务处理数据量大小要合适；

八.使用explain查看执行计划

hive在执行的时候会把所对应的SQL语句都会转换成mapreduce代码执行，但是具体的MR执行信息我们怎样才能看出来呢？这里就用到了explain的关键字，他可详细的表示出在执行所对应的语句所对应的MR代码，进而根据执行信息对我们的代码进行优化。

#基本语法: explain [extended | dependency | authorization] query

#查看执行计划
 explain extended select count(*) from course;
 
#查看详细执行计划
 explain extended select count(*) from course;

九.并行执行

Hive会将一个查询转化成一个或者多个阶段。这样的阶段可以是MapReduce阶段、抽样阶段、合并阶段、limit阶段。默认情况下，Hive一次只会执行一个阶段。不过，某个特定的job可能包含众多的阶段，而这些阶段可能并非完全互相依赖的，也就是说有些阶段是可以并行执行的，这样可能使得整个job的执行时间缩短。进行如下设置就可以开启并发执行。不过，在共享集群中，需要注意下，如果Job中并行阶段增多，那么集群利用率就会增加。当然，得是在系统资源比较空闲的时候才有优势，否则，没资源，并行也起不来。

set hive.exec.parallel=true;              //打开任务并行执行
set hive.exec.parallel.thread.number=16;  //同一个sql允许最大并行度，默认为8。

十.Hive严格模式

Hive提供了一个严格模式，可以防止用户执行那些可能意向不到的不好的影响的查询。
通过设置属性hive.mapred.mode值为默认是非严格模式nonstrict 。开启严格模式需要修改hive.mapred.mode值为strict。

<property>
    <name>hive.mapred.mode</name>
    <value>strict</value>
    <description>
      The mode in which the Hive operations are being performed. 
      In strict mode， some risky queries are not allowed to run. They include:
        Cartesian Product.
        No partition being picked up for a query.
        Comparing bigints and strings.
        Comparing bigints and doubles.
        Orderby without limit.
    </description>
  </property>

开启严格模式可以禁止3种类型的查询:

1. 对于分区表，除非where语句中含有分区字段过滤条件来限制范围，否则不允许执行。
2. 对于使用了order by语句的查询，要求必须使用limit语句。
3. 限制笛卡尔积的查询。

十一.jvm重用：

JVM重用可以使得JVM实例在同一个job中重新使用N次，N的值可以在Hadoop的mapred-site.xml文件中进行配置。通常在10-20之间，具体多少需要根据具体业务场景测试得出。

<property>
  <name>mapreduce.job.jvm.numtasks</name>
  <value>10</value>
  <description>How many tasks to run per jvm. If set to -1， there is
  no limit. 
  </description>
</property>

或者，也可以在hive客户端设置:

set  mapred.job.reuse.jvm.num.tasks=10;

十二.推测执行

在分布式集群环境下，因为程序Bug（包括Hadoop本身的bug），负载不均衡或者资源分布不均等原因，会造成同一个作业的多个任务之间运行速度不一致。执行慢的任务会拖慢作业的整体执行进度。
为了避免这种情况发生，Hadoop采用了推测执行（Speculative Execution）机制，它根据一定的法则推测出“拖后腿”的任务，并为这样的任务启动一个备份任务，让该任务与原始任务同时处理同一份数据，并最终选用最先成功运行完成任务的计算结果作为最终结果。
设置开启推测执行参数：Hadoop的mapred-site.xml文件中进行配置

<property>
  <name>mapreduce.map.speculative</name>
  <value>true</value>
  <description>If true， then multiple instances of some map tasks 
               may be executed in parallel.</description>
</property>

<property>
  <name>mapreduce.reduce.speculative</name>
  <value>true</value>
  <description>If true， then multiple instances of some reduce tasks 
               may be executed in parallel.</description>
</property>

不过hive本身也提供了配置项来控制reduce-side的推测执行：

  <property>
    <name>hive.mapred.reduce.tasks.speculative.execution</name>
    <value>true</value>
    <description>Whether speculative execution for reducers should be turned on. </description>
  </property>

关于调优这些推测执行变量，还很难给一个具体的建议。如果用户对于运行时的偏差非常敏感的话，那么可以将这些功能关闭掉。如果用户因为输入数据量很大而需要执行长时间的map或者Reduce task的话，那么启动推测执行造成的浪费是非常巨大大。

补充:

1.Hive常用的存储格式

①TextFile格式
默认格式，数据不做压缩，磁盘开销大，数据解析开销大。可结合Gzip、Bzip2使用(系统自动检查，执行查询时自动解压)，但使用这种方式，hive不会对数据进行切分，从而无法对数据进行并行操作。

②ORC格式
Orc (Optimized Row Columnar)是hive 0.11版里引入的新的存储格式。
可以看到每个Orc文件由1个或多个stripe组成，每个stripe250MB大小，这个Stripe实际相当于RowGroup概念，不过大小由4MB->250MB，这样能提升顺序读的吞吐率。每个Stripe里有三部分组成，分别是Index Data，Row Data，Stripe Footer：
在这里插入图片描述
一个orc文件可以分为若干个Stripe。
一个stripe可以分为三个部分:

indexData：某些列的索引数据
- rowData :真正的数据存储
- StripFooter：stripe的元数据信息

Index Data：一个轻量级的index，默认是每隔1W行做一个索引。这里做的索引只是记录某行的各字段在Row Data中的offset。
Row Data：存的是具体的数据，先取部分行，然后对这些行按列进行存储。对每个列进行了编码，分成多个Stream来存储。
Stripe Footer：存的是各个stripe的元数据信息。

每个文件有一个File Footer，这里面存的是每个Stripe的行数，每个Column的数据类型信息等；
每个文件的尾部是一个PostScript，这里面记录了整个文件的压缩类型以及FileFooter的长度信息等。
在读取文件时，会seek到文件尾部读PostScript，从里面解析到File Footer长度，再读FileFooter，从里面解析到各个Stripe信息，再读各个Stripe，即从后往前读。

③PARQUET格式
Parquet是面向分析型业务的列式存储格式，由Twitter和Cloudera合作开发，2015年5月从Apache的孵化器里毕业成为Apache顶级项目。
Parquet文件是以二进制方式存储的，所以是不可以直接读取的，文件中包括该文件的数据和元数据，因此Parquet格式文件是自解析的。
通常情况下，在存储Parquet数据的时候会按照Block大小设置行组的大小，由于一般情况下每一个Mapper任务处理数据的最小单位是一个Block，这样可以把每一个行组由一个Mapper任务处理，增大任务执行并行度。Parquet文件的格式如下图所示。
在这里插入图片描述上图展示了一个Parquet文件的内容，一个文件中可以存储多个行组，文件的首位都是该文件的Magic Code，用于校验它是否是一个Parquet文件，Footer length记录了文件元数据的大小，通过该值和文件长度可以计算出元数据的偏移量，文件的元数据中包括每一个行组的元数据信息和该文件存储数据的Schema信息。除了文件中每一个行组的元数据，每一页的开始都会存储该页的元数据，在Parquet中，有三种类型的页：数据页、字典页和索引页。数据页用于存储当前行组中该列的值，字典页存储该列值的编码字典，每一个列块中最多包含一个字典页，索引页用来存储当前行组下该列的索引，目前Parquet中还不支持索引页。

2.Hive文件存储格式对比

数据源为ngix服务器日志文件，共10万条，文件大小18.1MB，以下为其中的一条数据:

2017-08-10 13:00:00	http://www.taobao.com/item/962967_14?ref=1_1_52_search.ctg_1	T82C9WBFB1N8EW14YF2E2GY8AC9K5M5P	http://www.yihaodian.com/ctg/s2/c24566-%E5%B1%B1%E6%A5%82%E5%88%B6%E5%93%81?ref=pms_15_78_258	222.78.246.228	134939954	156

TextFile

①创建表，存储数据格式为TextFile；

create database test;

use test;

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/temp/log.data' into table log_text ;

③查看表中数据大小，大小为18.1M。

dfs -du -h /user/hive/warehouse/test.db/log_text;

ORC

①创建表，存储数据格式为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 ;

②向表中加载数据；

insert into table log_orc select * from log_text ;

③查看表中数据大小，大小为2.8M。

dfs -du -h /user/hive/warehouse/test.db/log_orc;

Parquet

①创建表，存储数据格式为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;

②向表中加载数据；

insert into table log_parquet select * from log_text ;

③查看表中数据大小，大小为13.1M。

dfs -du -h /user/hive/warehouse/test.db/log_parquet;

存储文件的查询速度测试

①TextFile

select count(*) as counts from log_text;

#用时21.479秒， 结果如下
+---------+--+
| counts  |
+---------+--+
| 100000  |
+---------+--+
1 row selected (21.479 seconds)

②ORC

select count(*) as counts from log_orc;

#用时11.919秒， 结果如下
+---------+--+
| counts  |
+---------+--+
| 100000  |
+---------+--+
1 row selected (11.919 seconds)

③Parquet

select count(*) as counts from log_parquet; 

#用时10.546秒， 结果如下
+---------+--+
| counts  |
+---------+--+
| 100000  |
+---------+--+
1 row selected (10.546 seconds)

3.存储格式+数据压缩调优测试

①创建一个不使用压缩的ORC存储方式的表: 7.7M

#建表
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 into table log_orc_none select * from log_text;

#查看插入后数据
dfs -du -h /user/hive/warehouse/test.db/log_orc_none;

②创建一个SNAPPY压缩的ORC存储方式: 3.8M

#建表
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 into table log_orc_snappy select * from log_text ;

#查看插入后数据
dfs -du -h /user/hive/warehouse/test.db/log_orc_snappy ;

4.动态分区案例

需求：将ori中的数据按照时间(如：20111231234568)，插入到目标表ori_partitioned的相应分区中。

准备数据原表ori_partitioned

create table ori_partitioned(id bigint, time bigint, uid string, keyword string, url_rank int, click_num int, click_url string) 
PARTITIONED BY (p_time bigint) 
row format delimited fields terminated by '\t';

load data local inpath '/export/temp/small_data' into  table ori_partitioned partition (p_time='20111230000010');

load data local inpath '/export/temp/small_data' into  table ori_partitioned partition (p_time='20111230000011');

创建分区表ori_partitioned_target，查询到的数据存在这个表中

create table ori_partitioned_target(id bigint, time bigint, uid string, keyword string, url_rank int, click_num int, click_url string) PARTITIONED BY (p_time STRING) row format delimited fields terminated by '\t';

设置动态分区功能的参数，执行查询操作

set hive.exec.dynamic.partition = true;
set hive.exec.dynamic.partition.mode = nonstrict;
set hive.exec.max.dynamic.partitions = 1000;
set hive.exec.max.dynamic.partitions.pernode = 100;
set hive.exec.max.created.files = 100000;
set hive.error.on.empty.partition = false;

INSERT overwrite TABLE ori_partitioned_target PARTITION (p_time)
SELECT id, time, uid, keyword, url_rank, click_num, click_url, p_time
FROM ori_partitioned;

查看ori_partitioned_target，验证

show partitions ori_partitioned_target;

#结果如下
+------------------------+--+
|       partition        |
+------------------------+--+
| p_time=20111230000010  |
| p_time=20111230000011  |
+------------------------+--+

DevinKim

关注

7
点赞
踩
35

收藏

觉得还不错? 一键收藏
0
评论
Hive调优

Hive调优一.Hive的数据压缩 mapreduce当中的数据压缩：maptask输出的数据可以压缩。reduceTask输出的数据也可以压缩。①开启hive当中map输出的数据压缩1. 开启hive中间传输数据压缩功能 set hive.exec.compress.intermediate=true;2. 开启mapreduce中map输出压缩功能 set mapr...
复制链接

扫一扫