[TOC]
# Hive操作
## 1 DDL操作
### 1.1 創建表
> 建表語法
~~~
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]
~~~
> 說明：
1. CREATE TABLE 創建一個指定名字的表。如果相同名字的表已經存在，則拋出異常；用戶可以用 IF NOT EXISTS 選項來忽略這個異常。
2. EXTERNAL關鍵字可以讓用戶創建一個外部表，在建表的同時指定一個指向實際數據的路徑（LOCATION），Hive 創建內部表時，會將數據移動到數據倉庫指向的路徑；若創建外部表，僅記錄數據所在的路徑，不對數據的位置做任何改變。在刪除表的時候，內部表的元數據和數據會被一起刪除，而外部表只刪除元數據，不刪除數據。
3. LIKE 允許用戶復制現有的表結構，但是不復制數據。
4. ROW FORMAT
~~~
DELIMITED [FIELDS TERMINATED BY char] [COLLECTION ITEMS TERMINATED BY char]
[MAP KEYS TERMINATED BY char] [LINES TERMINATED BY char]
| SERDE serde_name [WITH SERDEPROPERTIES (property_name=property_value, property_name=property_value, ...)]
~~~
> 用戶在建表的時候可以自定義 SerDe 或者使用自帶的 SerDe。如果沒有指定 ROW FORMAT 或者 ROW FORMAT DELIMITED，將會使用自帶的 SerDe。在建表的時候，用戶還需要為表指定列，用戶在指定表的列的同時也會指定自定義的 SerDe，Hive通過 SerDe 確定表的具體的列的數據。
5、 STORED AS
> SEQUENCEFILE|TEXTFILE|RCFILE
> 如果文件數據是純文本，可以使用 STORED AS TEXTFILE。如果數據需要壓縮，使用 STORED AS SEQUENCEFILE。
6、CLUSTERED BY
> 對于每一個表（table）或者分區， Hive可以進一步組織成桶，也就是說桶是更為細粒度的數據范圍劃分。Hive也是 針對某一列進行桶的組織。Hive采用對列值哈希，然后除以桶的個數求余的方式決定該條記錄存放在哪個桶當中。
> 把表（或者分區）組織成桶（Bucket）有兩個理由：
1. 獲得更高的查詢處理效率。桶為表加上了額外的結構，Hive 在處理有些查詢時能利用這個結構。具體而言，連接兩個在（包含連接列的）相同列上劃分了桶的表，可以使用 Map 端連接 （Map-side join）高效的實現。比如JOIN操作。對于JOIN操作兩個表有一個相同的列，如果對這兩個表都進行了桶操作。那么將保存相同列值的桶進行JOIN操作就可以，可以大大較少JOIN的數據量。
2. 使取樣（sampling）更高效。在處理大規模數據集時，在開發和修改查詢的階段，如果能在數據集的一小部分數據上試運行查詢，會帶來很多方便。
> 具體實例
1、 創建內部表mytable。
2、 創建外部表pageview。
3、 創建分區表invites。
> create table student_p(Sno int,Sname string,Sex string,Sage int,Sdept string)
> partitioned by(part string)
> row format delimited fields
> terminated by ','stored as textfile;
4、 創建帶桶的表student。
5、 桶表抽樣查詢
~~~
Select * from student tablesample(bucket 1 out of 2 on id)
~~~
> tablesample是抽樣語句，語法：TABLESAMPLE(BUCKET x OUT OF y)
> y必須是table總bucket數的倍數或者因子。hive根據y的大小，決定抽樣的比例.
> 如，table總共分了64份，當y=32時，抽取(64/32=)2個bucket的數據，當y=128時，抽取(64/128=)1/2個bucket的數據。x表示從哪個bucket開始抽取。例如，table總bucket數為32，tablesample(bucket 3 out of 16)，表示總共抽取（32/16=）2個bucket的數據，分別為第3個bucket和第（3+16=）19個bucket的數據。
### 1.2 修改表
> 增加/刪除分區
1) 語法結構
~~~
ALTER TABLE table_name ADD [IF NOT EXISTS] partition_spec [ LOCATION 'location1' ] partition_spec [ LOCATION 'location2' ] ...
partition_spec:
: PARTITION (partition_col = partition_col_value, partition_col = partiton_col_value, ...)
ALTER TABLE table_name DROP partition_spec, partition_spec,...
~~~
> 具體實例
~~~
alter table student_p add partition(part='a') partition(part='b');
~~~
2) 重命名表
> 語法結構
~~~
ALTER TABLE table_name RENAME TO new_table_name
~~~
> 具體實例
3) 增加/更新列
語法結構
~~~
ALTER TABLE table_name ADD|REPLACE COLUMNS (col_name data_type [COMMENT col_comment], ...)
~~~
> 注：ADD是代表新增一字段，字段位置在所有列后面(partition列前)，REPLACE則是表示替換表中所有字段。
~~~
ALTER TABLE table_name
CHANGE [COLUMN] col_old_name col_new_name column_type [COMMENT col_comment] [FIRST|AFTER column_name]
~~~
> 具體實例
### 1.3 顯示命令
~~~
show tables
show databases
show partitions
show functions
desc extended t_name;
desc formatted table_name;
~~~
## 2 DML操作
### 2.1 Load
> 語法結構
~~~
LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO
TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)]
~~~
> 說明：
1、 Load 操作只是單純的復制/移動操作，將數據文件移動到 Hive 表對應的位置。
2、 filepath：
~~~
相對路徑，例如：project/data1
絕對路徑，例如：/user/hive/project/data1
包含模式的完整 URI，列如：
hdfs://namenode:9000/user/hive/project/data1
~~~
3、 LOCAL關鍵字
~~~
如果指定了 LOCAL， load 命令會去查找本地文件系統中的 filepath。
如果沒有指定 LOCAL 關鍵字，則根據inpath中的uri查找文件
~~~
4、 OVERWRITE 關鍵字
1) 如果使用了 OVERWRITE 關鍵字，則目標表（或者分區）中的內容會被刪除，然后再將 filepath 指向的文件/目錄中的內容添加到表/分區中。
2) 如果目標表（分區）已經有一個文件，并且文件名和 filepath 中的文件名沖突，那么現有的文件會被新文件所替代。
> 具體實例
1、 加載相對路徑數據。
2、 加載絕對路徑數據。
3、 加載包含模式數據。
4、 OVERWRITE關鍵字使用。
### 2.2 Insert
#### 將查詢結果插入Hive表
> 語法結構
> 利用查詢語句，將查詢結果插入新的表
~~~
INSERT OVERWRITE [INTO] TABLE tablename1 [PARTITION (partcol1=val1, partcol2=val2 ...)] select_statement1 FROM from_statement
~~~
> 插入一條數據
~~~
INSERT INTO TABLE VALUES(XX,YY,ZZ);
~~~
> Multi Inserts多重插入:
~~~
FROM from_statement
INSERT OVERWRITE TABLE tablename1 [PARTITION (partcol1=val1, partcol2=val2 ...)] select statement1
[INSERT OVERWRITE TABLE tablename2 [PARTITION ...]
Select statement2] ...
~~~
> Dynamic partition inserts動態分區插入:
~~~
INSERT OVERWRITE TABLE tablename PARTITION (partcol1[=val1], partcol2[=val2] ...) select_statement FROM from_statement
~~~
> 具體實例
1、基本模式插入。
2、多插入模式。
3、自動分區模式。
> 使用了非嚴格模式
~~~
set hive.exec.dynamic.partition.mode=nonstrict
~~~
#### 導出表數據
> 語法結構
~~~
INSERT OVERWRITE [LOCAL] DIRECTORY directory1 SELECT ... FROM ...
multiple inserts:
FROM from_statement
INSERT OVERWRITE [LOCAL] DIRECTORY directory1 select_statement1
[INSERT OVERWRITE [LOCAL] DIRECTORY directory2 select_statement2] ...
~~~
> 具體實例
1、導出文件到本地。
> 說明：
> 數據寫入到文件系統時進行文本序列化，且每列用^A來區分，\n為換行符。用more命令查看時不容易看出分割符，可以使用: sed -e 's/\x01/|/g' filename來查看。
2、導出數據到HDFS。
### 2.3 SELECT
#### 基本的Select操作
> 語法結構
~~~
SELECT [ALL | DISTINCT] select_expr, select_expr, ...
FROM table_reference
[WHERE where_condition]
[GROUP BY col_list [HAVING condition]]
[CLUSTER BY col_list
| [DISTRIBUTE BY col_list] [SORT BY| ORDER BY col_list]
]
[LIMIT number]
~~~
> 注：
1. order by 會對輸入做全局排序，因此只有一個reducer，會導致當輸入規模較大時，需要較長的計算時間。
2. sort by不是全局排序，其在數據進入reducer前完成排序。因此，如果用sort by進行排序，并且設置mapred.reduce.tasks>1，則sort by只保證每個reducer的輸出有序，不保證全局有序。
3. distribute by(字段)根據指定的字段將數據分到不同的reducer，且分發算法是hash散列。
4. Cluster by(字段) 除了具有Distribute by的功能外，還會對該字段進行排序。
> 因此，如果分桶和sort字段是同一個時，此時，cluster by = distribute by + sort by
> 分桶表的作用：最大的作用是用來提高join操作的效率；
> （思考這個問題：
> select a.id,a.name,b.addr from a join b on a.id = b.id;
> 如果a表和b表已經是分桶表，而且分桶的字段是id字段
> 做這個join操作時，還需要全表做笛卡爾積嗎？）
> 注意：在hive中提供了一種“嚴格模式”的設置來阻止用戶執行可能會帶來未知不好影響的查詢。
> 設置屬性hive.mapred.mode 為strict能夠阻止以下三種類型的查詢：
1) 除非在where語段中包含了分區過濾，否則不能查詢分區了的表。這是因為分區表通常保存的數據量都比較大，沒有限定分區查詢會掃描所有分區，耗費很多資源。
~~~
不允許：select *from logs;
允許：select * from logs where day=20151212;
~~~
2) 包含order by，但沒有limit子句的查詢。因為order by 會將所有的結果發送給單個reducer來執行排序，這樣的排序很耗時。
3) 笛卡爾乘積；簡單理解就是JOIN沒帶ON，而是帶where的
> 具體實例
1、獲取年齡大的3個學生。
2、查詢學生信息按年齡，降序排序。
3、按學生名稱匯總學生年齡。
## 3 Hive Join
> 語法結構
~~~
join_table:
table_reference JOIN table_factor [join_condition]
| table_reference {LEFT|RIGHT|FULL} [OUTER] JOIN table_reference join_condition
| table_reference LEFT SEMI JOIN table_reference join_condition
~~~
> Hive 支持等值連接（equality joins）、外連接（outer joins）和（left/right joins）。Hive 不支持非等值的連接，因為非等值連接非常難轉化到 map/reduce 任務。
> 另外，Hive 支持多于 2 個表的連接。
> 寫 join 查詢時，需要注意幾個關鍵點：
1. 只支持等值join
> 例如：
~~~
SELECT a.* FROM a JOIN b ON (a.id = b.id)
SELECT a.* FROM a JOIN b
ON (a.id = b.id AND a.department = b.department)
~~~
~~~
是正確的，然而:
SELECT a.* FROM a JOIN b ON (a.id>b.id)
是錯誤的。
~~~
2. 可以 join 多于 2 個表。
> 例如
~~~
SELECT a.val, b.val, c.val FROM a JOIN b
ON (a.key = b.key1) JOIN c ON (c.key = b.key2)
~~~
> 如果join中多個表的 join key 是同一個，則 join 會被轉化為單個 map/reduce 任務，例如：
~~~
SELECT a.val, b.val, c.val FROM a JOIN b
ON (a.key = b.key1) JOIN c
ON (c.key = b.key1)
~~~
> 被轉化為單個 map/reduce 任務，因為 join 中只使用了 b.key1 作為 join key。
~~~
SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1)
JOIN c ON (c.key = b.key2)
~~~
> 而這一 join 被轉化為 2 個 map/reduce 任務。因為 b.key1 用于第一次 join 條件，而 b.key2 用于第二次 join。
3. join 時，每次 map/reduce 任務的邏輯：
> reducer 會緩存 join 序列中除了最后一個表的所有表的記錄，再通過最后一個表將結果序列化到文件系統。這一實現有助于在 reduce 端減少內存的使用量。實踐中，應該把最大的那個表寫在最后（否則會因為緩存浪費大量內存）。例如：
~~~
SELECT a.val, b.val, c.val FROM a
JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)
~~~
> 所有表都使用同一個 join key（使用 1 次 map/reduce 任務計算）。Reduce 端會緩存 a 表和 b 表的記錄，然后每次取得一個 c 表的記錄就計算一次 join 結果，類似的還有：
~~~
SELECT a.val, b.val, c.val FROM a
JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key2)
~~~
> 這里用了 2 次 map/reduce 任務。第一次緩存 a 表，用 b 表序列化；第二次緩存第一次 map/reduce 任務的結果，然后用 c 表序列化。
4. LEFT，RIGHT 和 FULL OUTER 關鍵字用于處理 join 中空記錄的情況
> 例如：
~~~
SELECT a.val, b.val FROM
a LEFT OUTER JOIN b ON (a.key=b.key)
~~~
> 對應所有 a 表中的記錄都有一條記錄輸出。輸出的結果應該是 a.val, b.val，當 a.key=b.key 時，而當
> b.key 中找不到等值的 a.key 記錄時也會輸出:
> a.val, NULL
> 所以 a 表中的所有記錄都被保留了；
> “a RIGHT OUTER JOIN b”會保留所有 b 表的記錄。
Join 發生在 WHERE 子句之前。如果你想限制 join 的輸出，應該在 WHERE 子句中寫過濾條件——或是在 join 子句中寫。這里面一個容易混淆的問題是表分區的情況：
~~~
SELECT a.val, b.val FROM a
LEFT OUTER JOIN b ON (a.key=b.key)
WHERE a.ds='2009-07-07' AND b.ds='2009-07-07'
~~~
> 會 join a 表到 b 表（OUTER JOIN），列出 a.val 和 b.val 的記錄。WHERE 從句中可以使用其他列作為過濾條件。但是，如前所述，如果 b 表中找不到對應 a 表的記錄，b 表的所有列都會列出 NULL，包括 ds 列。也就是說，join 會過濾 b 表中不能找到匹配 a 表 join key 的所有記錄。這樣的話，LEFT OUTER 就使得查詢結果與 WHERE 子句無關了。解決的辦法是在 OUTER JOIN 時使用以下語法：
~~~
SELECT a.val, b.val FROM a LEFT OUTER JOIN b
ON (a.key=b.key AND
b.ds='2009-07-07' AND
a.ds='2009-07-07')
~~~
> 這一查詢的結果是預先在 join 階段過濾過的，所以不會存在上述問題。這一邏輯也可以應用于 RIGHT 和 FULL 類型的 join 中。
> Join 是不能交換位置的。無論是 LEFT 還是 RIGHT join，都是左連接的。
~~~
SELECT a.val1, a.val2, b.val, c.val
FROM a
JOIN b ON (a.key = b.key)
LEFT OUTER JOIN c ON (a.key = c.key)
~~~
> 先 join a 表到 b 表，丟棄掉所有 join key 中不匹配的記錄，然后用這一中間結果和 c 表做 join。這一表述有一個不太明顯的問題，就是當一個 key 在 a 表和 c 表都存在，但是 b 表中不存在的時候：整個記錄在第一次 join，即 a JOIN b 的時候都被丟掉了（包括a.val1，a.val2和a.key），然后我們再和 c 表 join 的時候，如果 c.key 與 a.key 或 b.key 相等，就會得到這樣的結果：NULL, NULL, NULL, c.val
> 具體實例
1、 獲取已經分配班級的學生姓名。
2、 獲取尚未分配班級的學生姓名。
3、 LEFT SEMI JOIN是IN/EXISTS的高效實現。
## 4 Hive Shell參數
### 4.1 Hive命令行
> 語法結構
~~~
hive [-hiveconf x=y]* [<-i filename>]* [<-f filename>|<-e query-string>] [-S]
~~~
> 說明：
1. -i 從文件初始化HQL。
2. -e從命令行執行指定的HQL
3. -f 執行HQL腳本
4. -v 輸出執行的HQL語句到控制臺
5. -p <port> connect to Hive Server on port number
6. -hiveconf x=y Use this to set hive/hadoop configuration variables.
> 具體實例
1、運行一個查詢。
2、運行一個文件。
3、運行參數文件。
### 4.2 Hive參數配置方式
> Hive參數大全：
> https://cwiki.apache.org/confluence/display/Hive/Configuration+Properties
> 開發Hive應用時，不可避免地需要設定Hive的參數。設定Hive的參數可以調優HQL代碼的執行效率，或幫助定位問題。然而實踐中經常遇到的一個問題是，為什么設定的參數沒有起作用？這通常是錯誤的設定方式導致的。
> 對于一般參數，有以下三種設定方式：
1. 配置文件
2. 命令行參數
3. 參數聲明
> 配置文件：Hive的配置文件包括
1. 用戶自定義配置文件：$HIVE_CONF_DIR/hive-site.xml
2. 默認配置文件：$HIVE_CONF_DIR/hive-default.xml
> 用戶自定義配置會覆蓋默認配置。
> 另外，Hive也會讀入Hadoop的配置，因為Hive是作為Hadoop的客戶端啟動的，Hive的配置會覆蓋Hadoop的配置。
> 配置文件的設定對本機啟動的所有Hive進程都有效。
> 命令行參數：啟動Hive（客戶端或Server方式）時，可以在命令行添加-hiveconf param=value來設定參數，例如：
~~~
bin/hive -hiveconf hive.root.logger=INFO,console
~~~
> 這一設定對本次啟動的Session（對于Server方式啟動，則是所有請求的Sessions）有效。
> 參數聲明：可以在HQL中使用SET關鍵字設定參數，例如：
~~~
set mapred.reduce.tasks=100;
~~~
> 這一設定的作用域也是session級的。
~~~
每個reducer task任務處理的數據量。默認為1G
set hive.exec.reducers.bytes.per.reducer=<number>
設置reducers task的最大個數
set hive.exec.reducers.max=<number>
設置reduce task的任務數
set mapred.reduce.tasks=<number>
~~~
> 總結：
> 上述三種設定方式的優先級依次遞增。即參數聲明覆蓋命令行參數，命令行參數覆蓋配置文件設定。注意某些系統級的參數，例如log4j相關的設定，必須用前兩種方式設定，因為那些參數的讀取在Session建立以前已經完成了。
## 5 Hive函數
### 5.1 內置運算符
> 內容較多，見《Hive官方文檔》
### 5.2 內置函數
> 內容較多，見《Hive官方文檔》
> https://cwiki.apache.org/confluence/display/Hive/LanguageManual+UDF
> 測試各種內置函數的快捷方法：
1、創建一個dual表
~~~
create table dual(id string);
~~~
2、load一個文件（一行，一個空格）到dual表
3、select substr('angelababy',2,3) from dual;
### 5.3 Hive自定義函數和Transform
> 當Hive提供的內置函數無法滿足你的業務處理需要時，此時就可以考慮使用用戶自定義函數（UDF：user-defined function）。
#### 5.3.1 自定義函數類別
> UDF 作用于單個數據行，產生一個數據行作為輸出。（數學函數，字符串函數）
> UDAF（用戶定義聚集函數）：接收多個輸入數據行，并產生一個輸出數據行。（count，max）
#### 5.3.2 UDF開發實例
1）簡單UDF示例
1. 先開發一個java類，繼承UDF，并重載evaluate方法
~~~
package cn.itcast.bigdata.udf
import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;
public final class Lower extends UDF{
public Text evaluate(final Text s){
if(s==null){return null;}
return new Text(s.toString().toLowerCase());
}
}
~~~
2) 打成jar包上傳到服務器
3) 將jar包添加到hive的classpath
~~~
hive>add JAR /home/hadoop/udf.jar;
~~~
4) 創建臨時函數與開發好的java class關聯
~~~
Hive>create temporary function tolowercase as 'cn.itcast.bigdata.udf.ToProvince';
~~~
5) 即可在hql中使用自定義的函數tolowercase ip
~~~
Select tolowercase(name),age from t_test;
~~~
2) Json數據解析UDF開發
> 作業：
> 有原始json數據如下：
~~~
{"movie":"1193","rate":"5","timeStamp":"978300760","uid":"1"}
{"movie":"661","rate":"3","timeStamp":"978302109","uid":"1"}
{"movie":"914","rate":"3","timeStamp":"978301968","uid":"1"}
{"movie":"3408","rate":"4","timeStamp":"978300275","uid":"1"}
{"movie":"2355","rate":"5","timeStamp":"978824291","uid":"1"}
{"movie":"1197","rate":"3","timeStamp":"978302268","uid":"1"}
{"movie":"1287","rate":"5","timeStamp":"978302039","uid":"1"}
~~~
> 需要將數據導入到hive數據倉庫中
> 我不管你中間用幾個表，最終我要得到一個結果表：
| movie | rate | timestamp | uid |
| --- | --- | --- | --- |
| 1197 | 3 | 978302268 | 1 |
> 注：全在hive中完成，可以用自定義函數
~~~
package cn.itcast.bigdata.hive.udf;
//{"movie":"1721","rate":"3","timeStamp":"965440048","uid":"5114"}
public class MovieRateBean {
private String movie;
private String rate;
private String timeStamp;
private String uid;
public String getMovie() {
return movie;
}
public void setMovie(String movie) {
this.movie = movie;
}
public String getRate() {
return rate;
}
public void setRate(String rate) {
this.rate = rate;
}
public String getTimeStamp() {
return timeStamp;
}
public void setTimeStamp(String timeStamp) {
this.timeStamp = timeStamp;
}
public String getUid() {
return uid;
}
public void setUid(String uid) {
this.uid = uid;
}
@Override
public String toString() {
return movie + "\t" + rate + "\t" + timeStamp + "\t" + uid;
}
}
package cn.itcast.bigdata.hive.udf;
import java.io.IOException;
import org.apache.hadoop.hive.ql.exec.UDF;
import parquet.org.codehaus.jackson.JsonParseException;
import parquet.org.codehaus.jackson.map.JsonMappingException;
import parquet.org.codehaus.jackson.map.ObjectMapper;
public class JsonParser extends UDF {
public String evaluate(String jsonLine) {
ObjectMapper objectMapper = new ObjectMapper();
try {
MovieRateBean bean = objectMapper.readValue(jsonLine, MovieRateBean.class);
return bean.toString();
} catch (Exception e) {
}
return "";
}
}
~~~
#### 5.3.3 Transform實現
> Hive的 TRANSFORM 關鍵字提供了在SQL中調用自寫腳本的功能
> 適合實現Hive中沒有的功能又不想寫UDF的情況
> 使用示例1：下面這句sql就是借用了weekday_mapper.py對數據進行了處理.
~~~
CREATE TABLE u_data_new (
movieid INT,
rating INT,
weekday INT,
userid INT)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t';
add FILE weekday_mapper.py;
INSERT OVERWRITE TABLE u_data_new
SELECT
TRANSFORM (movieid , rate, timestring,uid)
USING 'python weekday_mapper.py'
AS (movieid, rating, weekday,userid)
FROM t_rating;
~~~
> 其中weekday_mapper.py內容如下
~~~
#!/bin/python
import sys
import datetime
for line in sys.stdin:
line = line.strip()
movieid, rating, unixtime,userid = line.split('\t')
weekday = datetime.datetime.fromtimestamp(float(unixtime)).isoweekday()
print '\t'.join([movieid, rating, str(weekday),userid])
~~~
### 5.4 HIVE特殊分隔符處理
> Hive對文件中的分隔符默認情況下只支持單字節分隔符，,默認單字符是\001。當然你也可以在創建表格時指定數據的分割符號。但是如果數據文件中的分隔符是多字符的，如下圖：
~~~
01||zhangsan
02||lisi
03||wangwu
~~~
補充：hive讀取數據的機制
1) 首先用inputformat的一個具體的實現類讀取文件數據，返回一條條的記錄（可以是行，或者是你邏輯中的“行”）
2) 然后利用SerDe<默認：
> org.apache.hadoop.hive.serde2.LazySimpleSerDe>的一個具體的實現類，對上面返回的一條條記錄進行字段切割
#### 5.4.1使用RegexSerDe通過正則表達式來抽取字段
1) 建表
~~~
create table t_bi_reg(id string,name string)
row format serde 'org.apache.hadoop.hive.serde2.RegexSerDe'
with serdeproperties(
'input.regex'='(.*)\\|\\|(.*)',
'output.format.string'='%1$s%2$s'
)
stored as textfile;
~~~
2) 加載數據
~~~
01||zhangsan
02||lisi
03||wangwu
load data local inpath '/root/lianggang.txt' into table t_bi_reg;
~~~
3) 查詢
~~~
hive> select * from t_bi_reg;
OK
01 zhangsan
02 lisi
03 wangwu
~~~
#### 5.4.2通過自定義inputformat解決特殊分隔符問題
> 其原理是在inputformat讀取行的時候將數據中的“多字節分隔符”替換為hive默認的分隔符（ctrl+A 亦即 \001）或用于替代的單字符分隔符。以便hive在serde操作的時候按照默認的單字節分隔符進行字段抽取
~~~
package cn.itcast.bigdata.hive.inputformat;
import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.FileSplit;
import org.apache.hadoop.mapred.InputSplit;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.LineRecordReader;
import org.apache.hadoop.mapred.RecordReader;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.TextInputFormat;
public class BiDelimiterInputFormat extends TextInputFormat {
@Override
public RecordReader<LongWritable, Text> getRecordReader(
InputSplit genericSplit, JobConf job, Reporter reporter)
throws IOException {
reporter.setStatus(genericSplit.toString());
MyDemoRecordReader reader = new MyDemoRecordReader(new LineRecordReader(job, (FileSplit) genericSplit));
// BiRecordReader reader = new BiRecordReader(job, (FileSplit)genericSplit);
return reader;
}
public static class MyDemoRecordReader implements RecordReader<LongWritable, Text> {
LineRecordReader reader;
Text text;
public MyDemoRecordReader(LineRecordReader reader) {
this.reader = reader;
text = reader.createValue();
}
@Override
public void close() throws IOException {
reader.close();
}
@Override
public LongWritable createKey() {
return reader.createKey();
}
@Override
public Text createValue() {
return new Text();
}
@Override
public long getPos() throws IOException {
return reader.getPos();
}
@Override
public float getProgress() throws IOException {
return reader.getProgress();
}
@Override
public boolean next(LongWritable key, Text value) throws IOException {
boolean next = reader.next(key, text);
if(next){
String replaceText = text.toString().replaceAll("\\|\\|", "\\|");
value.set(replaceText);
}
return next;
}
}
}
~~~
1) 打包成jar，放到$HIVE_HOME/lib下
2) 建表指明自定義的inputformat
~~~
create table t_lianggang(id string,name string)
row format delimited
fields terminated by '|'
stored as inputformat 'cn.itcast.bigdata.hive.inputformat.BiDelimiterInputFormat'
outputformat 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat';
~~~
3) 加載數據
~~~
01||zhangsan
02||lisi
03||wangwu
load data local inpath '/root/lianggang.txt' into table t_lianggang;
~~~
4) 查詢
~~~
hive> select * from t_lianggang;
OK
01 zhangsan
02 lisi
03 wangwu
~~~
## 6.hive嚴格模式
> hive提供了一個嚴格模式，可以防止用戶執行那些可能產生意想不到的不好的效果的查詢。即某些查詢在嚴格模式下無法執行。通過設置hive.mapred.mode的值為strict，可以禁止3中類型的查詢。
1) 查詢一個分區表時
> 如果在一個分區表執行hive，除非where語句中包含分區字段過濾條件來顯示數據范圍，否則不允許執行。換句話說，就是用戶不允許掃描所有的分區。進行這個限制的原因是，通常分區表都擁有非常大的數據集，而且數據增加迅速。 如果沒有進行分區限制的查詢可能會消耗令人不可接受的巨大資源來處理這個表：例如
~~~
hive> select * from t_patition;
FAILED: SemanticException [Error 10041]: No partition predicate found for Alias "t_patition" Table "t_patition"
~~~
> 注意查詢的時候加上分區：
~~~
hive> select * from t_patition where country=’China’;
~~~
2) 帶有order by的查詢
> 對于使用了orderby的查詢，要求必須有limit語句。因為orderby為了執行排序過程會講所有的結果分發到同一個reducer中進行處理，強烈要求用戶增加這個limit語句可以防止reducer額外執行很長一段時間：
~~~
hive> select * from student order by id;
FAILED: SemanticException 1:31 In strict mode, if ORDER BY is specified, LIMIT must also be specified. Error encountered near token 'id'
~~~
> 注意查詢的時候加上limit：
~~~
select * from student order by id limit 10;
~~~
3) 限制笛卡爾積的查詢
> 對關系型數據庫非常了解的用戶可能期望在執行join查詢的時候不使用on語句而是使用where語句，這樣關系數據庫的執行優化器就可以高效的將where語句轉換成那個on語句。不幸的是，hive不會執行這種優化，因此，如果表足夠大，那么這個查詢就會出現不可控的情況：
~~~
hive> SELECT * FROM fracture_act JOIN fracture_ads
> WHERE fracture_act.planner_id = fracture_ads.planner_id;
FAILED: Error in semantic analysis: In strict mode, cartesian product
is not allowed. If you really want to perform the operation,
+set hive.mapred.mode=nonstrict+
注意查詢的時候使用join和on語句的查詢：
hive> SELECT * FROM fracture_act JOIN fracture_ads
> ON (fracture_act.planner_id = fracture_ads.planner_id);
~~~
- hadoop
- linux基礎
- Linux入門
- Linux進階
- shell
- Zookeeper
- Zookeeper簡介及部署
- Zookeeper使用及API
- Redis
- Redis簡介安裝部署
- Redis使用及API
- Java高級增強
- Java多線程增強
- Maven簡介及搭建
- Hive
- Hive簡介及安裝
- Hive操作
- HIve常用函數
- Hive數據類型
- Flume
- Flume簡介及安裝
- flume 攔截器(interceptor)
- azkaban
- azKaban簡介及安裝
- Sqoop
- Sqoop簡介及安裝
- HDFS
- HDFS原理
- HDFS操作API
- MAPREDUCE原理
- MAPREDUCE圖片資源
- MAPREDUCE加強
- HBASE
- HBASE簡介及安裝
- HBASE操作及API
- HBASE內部原理
- Storm
- Storm簡介及安裝
- Storm原理
- kafka
- kafka簡介及安裝
- kafka常用操作及API
- kafka原理
- kafka配置詳解
- Scala
- Scala簡介及安裝
- Scala基礎語法
- Scala實戰