大数据-Hive

zoukankan html css js c++ java

大数据-Hive
Hive

Hive是一种用于执行离线计算的数据仓库工具，基于Hadoop的HDFS与MR实现。

Hive偏重于数据的分析和处理，使用映射关系将结构化的数据映射为表的结构。

例如：基于数据（1,zhangsan,123456,男）对应生成（id+uname+pwd+sex）的映射

Hive不会直接影响原始数据的结构，而hbase需要将数据存到hbase数据库才能查找数据。

Hive能够实现非Java用户对HDFS数据的MR操作。

官网：http://hive.apache.org

数据仓库
- 分为OLAP联机分析处理，OLTP联机事务处理
- 通过对以往数据的分析，对现有和未来业务提供数据支持
- 对数据处理分为：
  
  OLAP联机事务处理，负责数据事务处理，关系型数据库的主要应用
  
  OLAP联机分析处理，负责数据分析处理，数仓的主要应用
- 数仓中的数据模型包括：
  
  星型模式（单一中心节点）
  
  雪花模型（一个中心节点多个分支节点）
  
  星系模型（多中心节点）
- 数仓基本用于执行对数据的查找和统计，一般不会删除数据或修改数据
- 详细参考：https://zhuanlan.zhihu.com/p/67446501
Hive架构
- client
  
  客户端包括三种方式
  
  命令行模式——直接通过HQL（Hive Sql）执行操作
  
  JDBC/ODBC模式——通过java代码操作，需借助ThriftServer将代码转为HQL
  
  WebUI——通过web端输入HQL，远程执行任务
- MetaStore
  
  元数据存储器，用于存储Hive建表语句，也就是描述Hive与数据的映射关系的数据
  
  元数据包括：表，表的列、分区、属性、表的属性，表的数据所在目录
  
  元数据会存放在关系型数据库中(mysql)
- Driver
  
  解析器——将hql解析为语法树
  
  编译器——将语法树转换为逻辑执行计划
  
  优化器——重写逻辑执行计划实现优化
  
  执行器——将逻辑执行计划转换为物理执行计划（MR-JOB）
- 基于Hadoop-Yarn+Mapredce+Hdfs执行物理执行计划
Hive搭建
- 前提：mysql与Hadoop安装完成
- 在mysql中添加一个库用于存放Hive的映射
  
  create database hive_single;
- 将安装包解压到指定位置
  
  tar -zxvf apache-hive-1.2.1-bin.tar.gz
  
  cp -r apache-hive-1.2.1-bin /opt/sxt/
  
  mv apache-hive-1.2.1-bin hive-1.2.1
- 修改配置文件
  
  cp hive-default.xml.template hive-site.xml
  
  删除原始内容中configuration标签下的内容(3891行)填入如下内容
  
  
  <property>
  <name>hive.metastore.warehouse.dir</name>
  <value>/hive_single</value>
  </property>
  
  <property>
  <name>hive.metastore.local</name>
  <value>true</value>
  </property>
  
  <property>
  <name>javax.jdo.option.ConnectionURL</name>
  <value>jdbc:mysql://localhost:3306/hive_single?createDatabaseIfNotExist=true</value>
  </property>
  
  <property>
  <name>javax.jdo.option.ConnectionDriverName</name>
  <value>com.mysql.jdbc.Driver</value>
  </property>
  <property>
  <name>javax.jdo.option.ConnectionUserName</name>
  <value>root</value>
  </property>
  <property>
  <name>javax.jdo.option.ConnectionPassword</name>
  <value>123456</value>
  </property>
- 拷贝mysql的jar包到lib目录（mysql-connector-java-5.1.32-bin.jar）
- 解决Hadoop与Hive的jar版本差异（将jline文件替换）
  
  cd /opt/sxt/hadoop-2.6.5/share/hadoop/yarn/lib/
  
  rm -rf jline-0.9.94.jar
  
  cp /opt/sxt/hive-1.2.1/lib/jline-2.12.jar ./
- 配置PATH
  
  vim /etc/profile
  
  export HIVE_HOME=/opt/sxt/hive-1.2.1 export PATH=$HIVE_HOME/bin:$PATH（注意加上其他软件的路径）
  
  source /etc/profile
- Hive启动命令：hive
  
  查看库命令show databases；
  
  创建库create database myhive；
  
  使用库use myhive；
  
  创建表create table user；
- 保存快照
Hive-SQL
- HQL语句结尾要加分号；
- 进入命令行 hive
- 清空页面 !clear;
- DDL用于执行数据库组件的定义（创建修改删除）
  
  DDL需要注意库，表字段命名的规范
  
  DDL官方文档https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL
数据类型

基本类型
- 整型
  
  int（4byte） tinyint(1bety) smallint（2byte）bigint（8byte）
- 浮点型
  
  double（8byte） float（4byte）
- 字符型
  
  string char(定长) varchar(不定长)
- boolean型
  
  true/false (1位)
- 时间型
  
  timestamp时间戳 date日期
类型转换
- 自动
  
  整型隐式转为范围大的整型
  
  所有整型，float，string可以隐式转为double
  
  int，tinyint，smallint能转为double
  
  double不能转型为其他数据类型
- 强制
  
  例如：cast('1' as int)
- 表设计时须设置合适的数据类型避免类型转型
引用/复合类型

由基本类型构成，复合类型可以相互嵌套
- Array
  
  存放相同类型的数据
  
  以索引排序，索引从0开始
  
  获取数据的格式为：user[0]
- Map
  
  存储任意数量的键值对，适用属性的数量和类型均不确定的情况
  
  通过key取值，map['key1']
  
  key不能相同，相同的key会相互覆盖
- Struct
  
  结构体，内部的属性与属性的类型固定
  
  通过属性获取值：info.name(获取info结构体中name的属性)
DDL库操作
- 创建数据库
  
  create database sxt;
  
  create database if not exists sxt;
  
  create database sxt location '/hive_single/sxt_path' 指定数据库在hdfs的路径（路径名与数据库名可不同，创建时不会将原路径数据清除）
- 删除数据库
  
  drop database if exists sxt cascade;
  
  删除库，并将库所在文件夹删除
  
  drop database sxt ;
  
  删除空库
- 使用数据库
  
  use sxt ;
- 查看数据库
  
  show databases；查看所有数据库名
  
  show databases like 's*'; 匹配查找数据库
  
  desc database sxt；查看库内的表
- 修改数据库（了解）
  
  无法修改数据库名和数据库所在路径。只能修改其他数据
  
  alter database sxt set dbproperties('createtime'='20170830');
DDL表创建
- external 是否是外部表，不加该关键字则默认内部表
- 定义每一列
  
  所有列在括号内，相互通过逗号分隔
  
  (col_name data_type [COMMENT col_comment], ...)
  
  普通列： name string
  
  数组： books array< string>
  
  map： score map<string,int>
  
  struct: info struct< name:String,age:int>
- COMMENT col_comment 列注释
- COMMENT table_comment 表注释
- 分区
  
  [PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)]
- 分桶
  
  [CLUSTERED BY (col_name, col_name, ...) ]
  
  [SORTED BY (col_name [ASC|DESC], ...)] INTO num_buckets BUCKETS]
- 每一行的数据切分方式
  
  ROW FORMAT row_format
  
  字段分隔，array分隔，结构体与map的K-V分隔符，行分隔符
  
  注意顺序不能改变
  
  默认行以分隔，可以省略
  
  ROW FORMAT delimited
  fields terminated by ','
  collection items terminated by '_'
  map keys terminated by ':'
  lines terminated by ' ';
- 数据存储格式
  
  STORED AS file_format 用于数据压缩等情况
- 数据文件的地址
  
  LOCATION hdfs_path
  
  内部表和外部表均能指定表HDFS路径，LOCATION 是一个文件夹
  
  location '/hive_single/sxt';
```
CREATE [EXTERNAL] TABLE [IF NOT EXISTS] table_name 
(col_name data_type [COMMENT col_comment], ...)
[COMMENT table_comment] 
[PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)] 
[CLUSTERED BY (col_name, col_name, ...) ]
[SORTED BY (col_name [ASC|DESC], ...)] INTO num_buckets BUCKETS] 
[ROW FORMAT row_format] 
[STORED AS file_format] 
[LOCATION hdfs_path]
```
实例：
```
文本格式：
songsong,bingbing_lili,xiao song:18_xiaoxiao song:19,hui long guan_beijing
yangyang,caicai_susu,xiao yang:18_xiaoxiao yang:19,chao yang_beijing

json格式：
{
    "name": "songsong",
    "friends": ["bingbing" , "lili"] ,       //列表Array, 
    "children": {                      //键值Map,
        "xiao song": 18 ,
        "xiaoxiao song": 19
    }
    "address": {                      //结构Struct,
        "street": "hui long guan" ,
        "city": "beijing" 
    }
}
```
```
create table person(
    name string, 
    friends array<String>,
    children map<String,int>,
    address struct<street:string,city:string>
)
row format delimited fields terminated by ',' 
collection items terminated by '_' 
map keys terminated by ':' 
lines terminated by '
' 
```
外部表与内部表

表默认为内部表，使用external则为外部表

表创建时都不会将已有文件夹中的数据清除。

内部表
- 内部表处理独享的数据，适用于单次处理的数据，不适合于其他工具共享数据
- 删除表时表路径中的原始数据也会删除，若指定location的内部表会将location的一级目录删除
外部表
- 定义表可定义location路径，实现和其他表共享数据文件
- 删除外部表时只删除元数据信息，location目录下的数据将被保留
  
  create external table person(name string)
  location '/myhive/sxt';
内外表切换
- alter table sxt set tblproperties('EXTERNAL'='TRUE'); 内转外
- alter table sxt set tblproperties('EXTERNAL'='FALSE'); 外转内
表删除与清空
- 表删除（外部表不清除原始数据）
  
  drop table [if exsits] t_user；
- 清空表数据，直接截断
  
  truncate table_name；
- 查看表结构
  
  desc table_name ；
表修改（了解）
- 改表名
  
  alter table t_oldName rename to t_newName;
  
  内部表会将对应文件目录名修改，若指定了location则将location原目录移动到默认路径下
  
  外部表不会影响location地址的数据，不指定location也不会对默认路径进行修改
- 更新列
  
  alter table table_name change [column] col_oldName col_newName column_type [column col_comment] [FIRST|AFTER column_name];
- 增加替换列
  
  alter table table_name add|replace columns(col_name data_type [备注], ...);
数据载入

load载入

load data [local] inpath '/root/path' [overwrite] into table table_name
- local，表示路径为linux路径，否则默认为HDFS路径
- overwrite，表示覆盖载入，将表文件中原有的数据覆盖，否则默认为追加
- load 加载不执行MR操作
- local文件将被复制到HDFS的表目录中，HDFS文件则剪切到表目录。
insert载入

insert会启动MR操作，一般用于将原表的查询结果插入到新表中。

overwrite(覆盖) 和 into(追加)，可以相互替换

单表插入
- insert overwrite table t2 select xxx from t1；（将表1的xxx字段插入表2中）
多表插入
- from t1
  
  insert overwrite table t2 select xxx1
  
  insert overwrite table t3 select xxx2; （将表1的xxx字段插入表2中）
单记录插入（一般不这么做）
- insert into t1 values ('id','5'),('name','zhangwuji');
表数据导入导出

计算导出

通过insert将查询结果保存为数据文件，执行了MR操作且只保存数据文件
```
insert overwrite local directory '/root/data_out' 
row format delimited fields terminated by '-'
select * from mytable;
```
加入local表示导出到本地 linux的文件路径中，不加location则表示导出到HDFS的文件路径中

row format部分表示输出数据的间隔方式，与表定义类似

直接导出
- 导出，将表数据及表结构指定hdfs路径下，在该路径下保存元数据文件与数据文件夹。
  
  export table t_name to '/hdfs_path'
- 导入，将文件夹导入到命名空间，直接在命名空间下生成导出的表及数据
  
  import from '/hdfs_path'
  
  恢复后的文件夹名与表名相同，表自生属性也被保留(外部表属性，内部字段等)
分区

为了减少全表扫描查询的问题，根据指定字段的值，对数据进行分区存储（分多个文件夹存储）

定义分区表
```
--定义分区表时，可以指定多个分区属性
create table t_name(id int,name string) 
partitioned by (addr string , work string) 
row format delimited fields terminated by ',';
```
分区层级分为：单分区和多分区
- 单分区：只有一种分区。按照单一属性值分区
- 多分区，包含存在父子关系的多种分区。先依据父级属性分区，再依据子级属性分区
分区操作
- 添加分区 alter table t_name add partition(column='xxx');
- 删除分区 alter table t_name drop partition(column='xxx');
- 查询分区 show partitions t_name;
静态分区

数据载入
```
load data [local] inpath '/path' 
into table 't_name' 
partition (column1='xxx',column2='yyy');
```
静态载入的数据，会复制到对应的分组文件夹下，若无则自动创建文件夹。

数据只能载入到一个文件夹中，且查询时hive直接从文件夹中取数据，不再对分组字段处理。若文件中存在分组字段实际数据与分组数据不匹配，也将该字段值视为指定的分组数据。

动态分区
- 开启动态分区指定如下
  
  set hive.exec.dynamic.partition=true;
  
  set hive.exec.dynamic.partition.mode=nonstrict;
- 开启动态分区后再创建主分区表
  
  create table table1( id int, name string ) partitioned by (novel string,sect string) row format delimited fields terminated by ',' ；
- 创建外部临时表，临时表的字段与主分区表字段相同，临时表的location指向数据源
  
  create external table table2 ( id int, name string, novel string, sect string ) row format delimited fields terminated by ',' location '/path' ；
- 使用insert语句通过临时表将数据载入主表，期间执行的MR操作
  
  insert overwriter table table1 partition(novel,sect) select id,name,novel,sect from table2;
分桶

根据指定的列，对列值hash计算，根据结果将数据存入对应桶，能够将数据有效散列到桶中。分桶需要执行MR，桶的数量与reduce相同，计算结果输出到对应的桶文件中。

效果：使得桶中的数据较为均匀，便于统计计算。相同的key必然在一个桶中，降低表连接的数量。

数据插入：依赖于insert方式的数据插入。
- 指定列需要满足：经常被查询，自身散列较好
- 分桶可以在分区的基础上执行
- 分桶的数据需要具备较多的公约数，便于查询（12的公约数：1，2，3，4，6）
分桶建表语句
```
create table table01(
id int ,name string,age int) 
clustered by (name) sorted by (age) into 6 buckets 
ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';
--说明
按照name属性分桶，桶内通过age实现排序
```
分桶表的取样SQL

tablesample(bucket x out of y on 分桶列 )
- 第二个参数表示将桶分为多少组，其为分桶数的公约数
- 第一个参数表示每个组中取几个桶进行计算
- 参数1不大于参数2
```
select * from table01 tablesample(bucket 1 out of 3 on name );
```
复杂映射建表

通过正则将列与复杂数据进行映射，能够匹配复杂文本
```
--基本格式
create table table_name(column type,...) row fromat serde 'org.apache.hadoop.hive.serde2.RegexSerDe' with serdeproperties("input.regex" ="正则"） 
```
正则中每个括号内的部分对应前面定义的列

例子如下：
```
原始文件格式：
192.168.57.4 - - [29/Feb/2016:18:14:35 +0800] "GET /bg-upper.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2016:18:14:35 +0800] "GET /bg-nav.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2016:18:14:35 +0800] "GET /asf-logo.png HTTP/1.1" 304 -
```
```
--建表语句
create table t_log(
host string,
identity1 string,
identity2 string,
time string,
request string,
referer string,
agent string,) 
row fromat serde 'org.apache.hadoop.hive.serde2.RegexSerDe' 
with serdeproperties(
"input.regex" = "([^ ]*) ([^ ]*) ([^ ]*) \[(.*)\] "(.*)" (-|[0-9]*) (-|[0-9]*)"
)
```
```
映射说明：
括号内的内容匹配每个列，对应关系如下
host                        192.168.57.4
identity1                   -
identity2                   -
time                        29/Feb/2016:18:14:35 +0800
request                     GET
referer                     /bg-upper.png HTTP/1.1
agent                       304
```
DQL语句
- SQL 语言大小写不敏感。
- SQL 可以写在一行或者多行
- 关键字不能被缩写也不能分行
- 各子句一般要分行写，注意tab键会导致命令异常
Hive SQL的使用和数据库SQL基本上是一样的

主要语法
- 表连接支持99语法
- 排序
  
  sorted by 对deduce数据的数据进行排序
  
  order by 对全部数据进行排序
- 分页
  
  limit x 展示前x行记录，与排序组合实现展示最大(小)值
  
  limit x,y 展示x-y行记录
- 组函数
  
  max min avg sum count 组函数一般与group by组合使用
- 选择函数
  
  nvl(obj,default) 单行选择函数
  
  相当于obj==null?default:obj，若obj为空则取默认值，否则取自身的值
非关系型数据库DQL

split(column,'-') 将字段分隔为数组，以某个字符串作为间隔

explode(split(column,'-)) 将分割的数组展开，但不能直接与普通列同时使用

lateral view explode(split(column,'-)) typeTable as xxx 将列展开成表，再与普通列出现在一行
```
--数据
nezha js,gx,qq,dm
meirenyu gx,kh,aq
xingjidazhan kh,js
huoyingrenzhe dm,qj,yq,aq
--表
create table t_movie(
name string,type string) 
row format delimited fields terminated by ' ';
--查询
select name,xxx from t_movie
lateral view explode(split(type,',')) tempTable as xxx;
```
内置函数

内置运算符
- 关系运算符
  
  A = B；A is null；A like B
  
  返回boolean
- 算数运算法
  
  +，-，*，/，%，|，^，~
  
  适用于数值计算
- 逻辑运算符
  
  and，or，not，&&，|，！
  
  适用于布尔值运算
- 复杂函数
  
  定义
  
  map(k1,v1,k2,v2...)
  
  struct(v1,v2,v3...)
  
  array(v1,v2,v3)
  
  操作
  
  A[n] 数组A的第n个元素，从0开始
  
  M['key'] 数组M中key对应的值
  
  S.x 结构体S中的x属性值
内置函数
- 数字函数
  
  数值计算相关函数，包括取值，随机，转进制，绝对值...
- 字符串函数
  
  长度，分割split，连接，大小写，去空格...
- collection函数
  
  size(数组/map) 获取长度
- 转型函数
  
  cast(值 as 目标类型)
- 日期函数
  
  与字符串转换，日期的计算相关
- 条件函数
  
  if(boolean,value1,value2)
内置聚合函数UDAF
- count,sum,avg,min,max；
- 求方差，差值等；
- collect_set(col)返回无重复的数据
内置表生成函数UDTF

explode(array) 拆分数组

自定义函数

由于内置函数不满足我们的需要，需要自定义函数。（自定义代码实现对指定的数据进行运算，返回所需的结果，中间可以使用java的类库实现复杂操作）
- UDF(User-Defined-Function) 一进一出
- UDAF(User- Defined Aggregation Funcation) 聚集函数，多进一出
- UDTF(User-Defined Table-Generating Functions) 一进多出(了解)
注意：在IDE工具中导入hive依赖jar包（D:BigData课件及软件第6阶段：Hadoop 离线体系：Hive软件apache-hive-1.2.1-binlib）

以下函数均使用临时函数命令

UDF函数
1. 创建项目，导入hive的jar包，创建java类继承org.apache.hadoop.hive.ql.exec.UDF
2. 实现public String evaluate(Object value...)方法，该方法为重载方法，可以传入任意类型数据
3. 将项目打成jar文件上传至linux系统
4. hive客户端中，清空以前的同名文件，将上传的文件添加到hive函数库中
  
  delete jar /root/xxx.jar
  
  add jar /root/xxx.jar
5. 给自定义函数建名称,指定到对应的自定义java类
  
  create temporary function xxx as 'com.jay.Xxx'
6. 使用函数
  
  select xxx(empno),xxx(emane) from t_emp;
7. 销毁函数
  
  drop temporary function xxx;
自定义函数代码
```
package com.jay;
import org.apache.hadoop.hive.ql.exec.UDF;
//自定义UDF函数
public class Myudf extends UDF{
	//单个参数处理
	public String evaluate(String value){
		return value+"xxx";}
	//多参数处理
	public String evaluate(String value1,int value2 ){
		return value1+"-"+value2;}
}
```
UDAF函数
- 创建项目，导入hive的jar包，创建java类继承org.apache.hadoop.hive.ql.exec.UDAF
- 创建静态内部类，实现org.apache.hadoop.hive.ql.exec.UDAFEvaluator
  
  重写init方法，该方法至执行一次
  
  boolean iterate(Object) 迭代器
  
  Object terminatePartial() 临时结果输出
  
  boolean merge(Object) 执行合并操作
  
  Object terminate() 最终结果输出
  
  调用说明（根据需求调用以上方法）
  
  map过程调用iterate与terminatePartial；
  
  combiner(map合并)调用merge和terminatePartial
  
  reduce调用merge与terminate
- 其他步骤与HDF相同，调用UDAF会执行MR
```
import org.apache.hadoop.hive.ql.exec.UDAF;
import org.apache.hadoop.hive.ql.exec.UDAFEvaluator;
public class Myudaf extends UDAF{
	public static class aaa implements UDAFEvaluator{
		//定义一个中间量，执行所需业务
		private int sum;
		@Override
		public void init() {
			System.out.print("初始化，只执行一次");
		}
		//迭代处理原始数据
		public boolean iterate(String value) {
			if (value != null) 
				sum += value.length();
			return true;
		}
		//临时输出
		public int terminatePartial() {
			return sum;}
		//合并
		public boolean merge(int tmpSum) {
			sum += tmpSum;
			return true;}
		//最终输出
		public String terminate() {
			return "sum:" + sum;}
	}
}
```
hive优化

在优化中主要关注

Map的数量，reduce数量，文件数量，切片大小

hive中修改配置属性语句为：set xxx=值;

理解HSQL的执行

表连接

select u.name, o.orderid from order o join user u on o.uid = u.uid

注：uid作为key进行MR

表分组及分组函数

select rank, isonline, count (*) from city group by rank , isonline

注：将rank -isonline作为key

表分组去重

select dealid, count(distinct uid) num from order group by dealid

注：根据dealid执行map之后的分区，根据分区的dealid+去重的uid执行reduce的分组

表多重去重

select dealid, count(distinct uid), count(distinct date) from order group by dealid

方式1：只能在reduce中去重

方式2：实现在map中去重

Map表连接优化
- 指定大表和小表。减少了全表连接的数量
- 执行过程：小表节点先执行map，结果载入到hashtable中，各大表节点启动map并将小表执行结果载入内存，在各大表节点执行map合并，再将数据写出到reduce处理。
- select * from a join b join c; 控制a<b<c,使得hive将a视为b和c的小表，再将b视为c的小表
避免MR执行
- select与where默认不会导致MR启动
  
  select * from t_emp where id = 8
- 若select中不需要分区和组函数，可以使用hdfs默认的filter进行数据过滤
  
  hive-site.xml中配置如下信息，属性为more时上述情况默认不启动MR
  
  hive.fetch.task.conversion= more不启动/minimal启动
- insert语句必然执行MR操作
map的数量
- map任务数量过多，节点容易oom(内存溢出)
  
  map任务数量过少，任务节点少，处理速度慢
- map数量与切片数量关联，需要根据具体文件大小和内存设置map数
- 通过调整切片大小，可以控制切出的切片数量，进而控制map数量
  
  mapred.min.split.size 最小切片大小默认1B
  
  mapred.max.split.size 最大切片大小默认256MB
  
  上述值用B单位的数字进行设置
reduce数量

数量影响
- reduce过多产生大量小文件，影响hdfs性能，增加NameNode的负担
- reduce过少，单节点压力大容易oom
系统分配reduce方式，基于以下两个参数设置
- hive.exec.reducers.bytes.per.reducer 每个reduce处理的数据量，默认1G
- hive.exec.reducers.max 最大reduce数，默认999
- set mapred.reduce.tasks直接设置reduce个数
系统也会依据桶的数量分配reduce数，使得数据能够存入分桶文件中

只有开启一个reduce的情况
1. 分组函数没有设置分区
  
  select pt,count(1) from t_data where pt = ‘2012-07’ [group by pt];
2. 使用 order by 排序
  
  order by 会导致整表排序，只能由一个reduce处理
  
  sorted by则只是对每个reduce结果排序
行式存储与列式存储

行式数据库：块内存储多行数据，一行中有多个不同的数据类型，查询时需要依次进行解析全表数据

列式数据库：块内存列的数据，数据按列进行压缩，由于列属性相同，压缩与解析的格式相同，数据按列处理（列查询效率高）
```
1,admin,123456
2,zhangsan,123456
3,lisi,123456

//行式压缩
1,admin,123456；2,zhangsan,123456；3,lisi,123456
//列式压缩
1,2   admin,zhangsan 123456,123456
3,lisi,123456


select id ，name from table;  适用于列存储，使用较多
select * from table where id = 2;  适用于行存储，大数据中使用较少
```
其他优化
- 根据查询高频词创建分区表，减少查询时数据扫描的范围
- 减少使用去重distinct，避免产生数据倾斜
- JVM重用可以使得JVM实例在同一个job中时候使用N次，减少内存开销
查看全文

相关阅读:
深入Android 【一】 —— 序及开篇
 Android中ContentProvider和ContentResolver使用入门
 深入Android 【六】 —— 界面构造
 The service cannot be activated because it does not support ASP.NET compatibility. ASP.NET compatibility is enabled for this application. Turn off ASP.NET compatibility mode in the web.config or add the AspNetCompatibilityRequirements attribute to the ser
Dynamic Business代码片段总结
 对文件的BuildAction以content,resource两种方式的读取
 paraview 3.12.0 windows下编译成功小记
 百度网盘PanDownload使用Aria2满速下载
 netdata的安装与使用
 用PS给证件照排版教程

原文地址：https://www.cnblogs.com/javaxiaobu/p/11703004.html

Hive

数据仓库

Hive架构

Hive搭建

Hive-SQL

数据类型

基本类型

类型转换

引用/复合类型

DDL库操作

DDL表创建

外部表与内部表

表删除与清空

数据载入

load载入

insert载入

表数据导入导出

分区

定义分区表

静态分区

动态分区

分桶

复杂映射建表

DQL语句

主要语法

非关系型数据库DQL

内置函数

自定义函数

UDF函数

UDAF函数

hive优化

理解HSQL的执行

Map表连接优化

避免MR执行

map的数量

reduce数量

行式存储与列式存储

其他优化