hive Hive数据导入导出

转载：https://www.cnblogs.com/fenghuoliancheng/p/10672012.html

 

1.5  Hive的数据存储

    首先，Hive没有专门的数据存储格式，也没有为数据建立索引，用户可以非常自由的组织 Hive 中的表，只需要在创建表的时候告诉 Hive 数据中的列分隔符和行分隔符，Hive 就可以解析数据。其次，Hive 中所有的数据都存储在 HDFS 中，Hive 中包含以下数据模型：Table，External Table，Partition，Bucket。

1. Hive 中的 Table 和数据库中的 Table 在概念上是类似的，每一个 Table 在 Hive 中都有一个相应的目录存储数据。例如，一个表 xiaojun，它在 HDFS 中的路径为：/ warehouse /xiaojun，其中，wh 是在 hive-site.xml 中由 ${hive.metastore.warehouse.dir} 指定的数据仓库的目录，所有的 Table 数据（不包括 External Table）都保存在这个目录中。
2. Partition 对应于数据库中的 Partition 列的密集索引，但是 Hive 中 Partition 的组织方式和数据库中的很不相同。在 Hive 中，表中的一个 Partition 对应于表下的一个目录，所有的 Partition 的数据都存储在对应的目录中。例如：xiaojun 表中包含 dt 和 city 两个 Partition，则对应于 dt = 20100801, ctry = US 的 HDFS 子目录为：/ warehouse /xiaojun/dt=20100801/ctry=US；对应于 dt = 20100801, ctry = CA 的 HDFS 子目录为；/ warehouse /xiaojun/dt=20100801/ctry=CA
3. Buckets 对指定列计算 hash，根据 hash 值切分数据，目的是为了并行，每一个 Bucket 对应一个文件。将 user 列分散至 32 个 bucket，首先对 user 列的值计算 hash，对应 hash 值为 0 的 HDFS 目录为：/ warehouse /xiaojun/dt =20100801/ctry=US/part-00000；hash 值为 20 的 HDFS 目录为：/ warehouse /xiaojun/dt =20100801/ctry=US/part-00020
4. External Table 指向已经在 HDFS 中存在的数据，可以创建 Partition。它和 Table 在元数据的组织上是相同的，而实际数据的存储则有较大的差异。

• Table 的创建过程和数据加载过程（这两个过程可以在同一个语句中完成），在加载数据的过程中，实际数据会被移动到数据仓库目录中；之后对数据对访问将会直接在数据仓库目录中完成。删除表时，表中的数据和元数据将会被同时删除。
• External Table 只有一个过程，加载数据和创建表同时完成（CREATE EXTERNAL TABLE ……LOCATION），实际数据是存储在 LOCATION 后面指定的 HDFS 路径中，并不会移动到数据仓库目录中。当删除一个 External Table 时，仅删除元数据。

2.    Hive基本操作

2.1  DDL操作

2.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 SEQUENCE。

2.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)

是错误的。

1. 可以 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。“FROM a LEFT OUTER JOIN b”这句一定要写在同一行——意思是 a 表在 b 表的左边，所以 a 表中的所有记录都被保留了；“a RIGHT OUTER JOIN b”会保留所有 b 表的记录。OUTER JOIN 语义应该是遵循标准 SQL spec的。

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

 

 

2.4.1  内置运算符

  关系运算符

运算符	类型	说明
A = B	原始类型	如果A与B相等,返回TRUE,否则返回FALSE
A == B	无	失败，因为无效的语法。 SQL使用”=”，不使用”==”。
A <> B	原始类型	如果A不等于B返回TRUE,否则返回FALSE。如果A或B值为”NULL”，结果返回”NULL”。
A < B	原始类型	如果A小于B返回TRUE,否则返回FALSE。如果A或B值为”NULL”，结果返回”NULL”。
A <= B	原始类型	如果A小于等于B返回TRUE,否则返回FALSE。如果A或B值为”NULL”，结果返回”NULL”。
A > B	原始类型	如果A大于B返回TRUE,否则返回FALSE。如果A或B值为”NULL”，结果返回”NULL”。
A >= B	原始类型	如果A大于等于B返回TRUE,否则返回FALSE。如果A或B值为”NULL”，结果返回”NULL”。
A IS NULL	所有类型	如果A值为”NULL”，返回TRUE,否则返回FALSE
A IS NOT NULL	所有类型	如果A值不为”NULL”，返回TRUE,否则返回FALSE
A LIKE B	字符串	如果A或B值为”NULL”，结果返回”NULL”。字符串A与B通过sql进行匹配，如果相符返回TRUE，
		不符返回FALSE。
		B字符串中 的”_”代表任一字符，”%”则代表多个任意字符。
		例如： (‘foobar’ like ‘foo’)返回FALSE，（ ‘foobar’ like ‘foo_ _ _’或者 ‘foobar’ like ‘foo%’)
		则返回TURE
A RLIKE B	字符串	如果A或B值为”NULL”，结果返回”NULL”。字符串A与B通过java进行匹配，如果相符返回TRUE，
		不符返回FALSE。
		例如：（ ‘foobar’ rlike ‘foo’）返回FALSE，（’foobar’ rlike ‘^f.*r$’ ）返回TRUE。
A REGEXP B	字符串	与RLIKE相同。

  算术运算符

运算符	类型	说明
A + B	数字类型	A和B相加。结果的与操作数值有共同类型。例如每一个整数是一个浮点数，浮点数包含整数。
		所以，一个浮点数和一个整数相加结果也是一个浮点数。
A – B	数字类型	A和B相减。结果的与操作数值有共同类型。
A * B	数字类型	A和B相乘，结果的与操作数值有共同类型。需要说明的是，如果乘法造成溢出，将选择更高的类型。
A / B	数字类型	A和B相除，结果是一个double（双精度）类型的结果。
A % B	数字类型	A除以B余数与操作数值有共同类型。
A & B	数字类型	运算符查看两个参数的二进制表示法的值，并执行按位”与”操作。两个表达式的一位均为1时，则结果的该位为 1。
		否则，结果的该位为 0。
A|B	数字类型	运算符查看两个参数的二进制表示法的值，并执行按位”或”操作。只要任一表达式的一位为 1，则结果的该位为 1。
		否则，结果的该位为 0。
A ^ B	数字类型	运算符查看两个参数的二进制表示法的值，并执行按位”异或”操作。当且仅当只有一个表达式的某位上为 1 时，
		结果的该位才为 1。
		否则结果的该位为 0。
~A	数字类型	对一个表达式执行按位”非”（取反）。

  逻辑运算符

运算符	类型	说明
A AND B	布尔值	A和B同时正确时,返回TRUE,否则FALSE。如果A或B值为NULL，返回NULL。
A && B	布尔值	与”A AND B”相同。
A OR B	布尔值	A或B正确,或两者同时正确返返回TRUE,否则FALSE。如果A和B值同时为NULL，返回NULL。
A | B	布尔值	与”A OR B”相同
NOT A	布尔值	如果A为NULL或错误的时候返回TURE，否则返回FALSE。
! A	布尔值	与”NOT A”相同

  复制类型函数

函数	类型	说明
map	(key1, value1, key2, value2, …)	通过指定的键/值对，创建一个map。
struct	(val1, val2, val3, …)	通过指定的字段值，创建一个结构。结构字段名称将COL1，COL2，…
array	(val1, val2, …)	通过指定的元素，创建一个数组。

  复制类型函数操作

函数	类型	说明
A[n]	A是一个数组，n为int型	返回数组A的第n个元素，第一个元素的索引为0。如果A数组为['foo','bar']， 则A[0]返回’foo’和A[1]返回”bar”。
M[key]	M是Map<K, V>，关键K型	返回关键值对应的值，例如mapM为 \{‘f’ -> ‘foo’, ‘b’ -> ‘bar’, ‘all’ -> ‘foobar’\}，则M['all'] 返回’foobar’。
S.x	S为struct	返回结构x字符串在结构S中的存储位置。 如 foobar \{int foo, int bar\} foobar.foo的领域中存储的整数。

2.4.2  内置函数

  数学函数

返回类型	函数	说明
BIGINT	round(double a)	四舍五入
DOUBLE	round(double a, int d)	小数部分d位之后数字四舍五入，例如round(21.263,2),返回21.26
BIGINT	floor(double a)	对给定数据进行向下舍入最接近的整数。例如floor(21.2),返回21。
BIGINT	ceil(double a)	将参数向上舍入为最接近的整数。例如ceil(21.2),返回23.
	ceiling(double a)
double	rand(), rand(int seed)	返回大于或等于0且小于1的平均分布随机数（依重新计算而变）
double	exp(double a)	返回e的n次方
double	ln(double a)	返回给定数值的自然对数
double	log10(double a)	返回给定数值的以10为底自然对数
double	log2(double a)	返回给定数值的以2为底自然对数
double	log(double base, double a)	返回给定底数及指数返回自然对数
double	pow(double a, double p)	返回某数的乘幂
	power(double a, double p)
double	sqrt(double a)	返回数值的平方根
string	bin(BIGINT a)	返回二进制格式，
		参考：http://dev.mysql.com/doc/refman/5.0/en/string-functions.html#function_hex
string	hex(BIGINT a)	将整数或字符转换为十六进制格式。
	hex(string a)	参考：http://dev.mysql.com/doc/refman/5.0/en/string-functions.html#function_hex
string	unhex(string a)	十六进制字符转换由数字表示的字符。
string	conv(BIGINT num, int from_base, int to_base)	将指定数值，由原来的度量体系转换为指定的试题体系。例如CONV(‘a’,16,2),返回。
		参考：’1010′ http://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html#function_conv
double	abs(double a)	取绝对值
int double	pmod(int a, int b)	返回a除b的余数的绝对值
	pmod(double a, double b)
double	sin(double a)	返回给定角度的正弦值
double	asin(double a)	返回x的反正弦，即是X。如果X是在-1到1的正弦值，返回NULL。
double	cos(double a)	返回余弦
double	acos(double a)	返回X的反余弦，即余弦是X，，如果-1<= A <= 1，否则返回null.
int double	positive(int a)	返回A的值，例如positive(2)，返回2。
	positive(double a)
int double	negative(int a)	返回A的相反数，例如negative(2),返回-2。
	negative(double a)

  收集函数

回类型	函数	说明
int	size(Map<K.V>)	返回的map类型的元素的数量
int	size(Array<T>)	返回数组类型的元素数量

  类型转换函数

返回类型	函数	说明
指定 “type”	cast(expr as <type>)	类型转换。例如将字符”1″转换为整数:cast(’1′ as bigint)，如果转换失败返回NULL。

  日期函数

返回类型	函数	说明
string	from_unixtime(bigint unixtime[, string format])	UNIX_TIMESTAMP参数表示返回一个值’YYYY- MM – DD HH：MM：SS’
		或YYYYMMDDHHMMSS.uuuuuu格式，这取决于是否是在一个字符串或数字语境中
		使用的功能。
		该值表示在当前的时区。
bigint	unix_timestamp()	如果不带参数的调用，返回一个Unix时间戳（从’1970- 01 – 0100:00:00′到现在的
		UTC秒数）
		为无符号整数。
bigint	unix_timestamp(string date)	指定日期参数调用UNIX_TIMESTAMP（），它返回参数值’1970- 01 – 0100:00:00′到
		指定日期的秒数。
bigint	unix_timestamp(string date, string pattern)	指定时间输入格式，返回到1970年秒数：
		unix_timestamp(’2009-03-20′, ‘yyyy-MM-dd’) = 1237532400
		参考：http://java.sun.com/j2se/1.4.2/docs/api/java/text/SimpleDateFormat.html
string	to_date(string timestamp)	返回时间中的年月日： to_date(“1970-01-01 00:00:00″) = “1970-01-01″
string	to_dates(string date)	给定一个日期date，返回一个天数（0年以来的天数）
int	year(string date)	返回指定时间的年份，范围在1000到9999，或为”零”日期的0。
int	month(string date)	返回指定时间的月份，范围为1至12月，或0一个月的一部分，如’0000-00-00′
		或’2008-00-00′的日期。
int	day(string date) dayofmonth(date)	返回指定时间的日期
int	hour(string date)	返回指定时间的小时，范围为0到23。
int	minute(string date)	返回指定时间的分钟，范围为0到59。
int	second(string date)	返回指定时间的秒，范围为0到59。
int	weekofyear(string date)	返回指定日期所在一年中的星期号，范围为0到53。
int	datediff(string enddate, string startdate)	两个时间参数的日期之差。
int	date_add(string startdate, int days)	给定时间，在此基础上加上指定的时间段。
int	date_sub(string startdate, int days)	给定时间，在此基础上减去指定的时间段。

  条件函数

返回类型	函数	说明
T	if(boolean testCondition, T valueTrue, T valueFalseOrNull)	判断是否满足条件，如果满足返回一个值，如果不满足则返回另一个值。
T	COALESCE(T v1, T v2, …)	返回一组数据中，第一个不为NULL的值，如果均为NULL,返回NULL。
T	CASE a WHEN b THEN c [WHEN d THEN e]* [ELSE f] END	当a=b时,返回c；当a=d时，返回e，否则返回f。
T	CASE WHEN a THEN b [WHEN c THEN d]* [ELSE e] END	当值为a时返回b,当值为c时返回d。否则返回e。

  字符函数

返回类型	函数	说明
int	length(string A)	返回字符串的长度
string	reverse(string A)	返回倒序字符串
string	concat(string A, string B…)	连接多个字符串，合并为一个字符串，可以接受任意数量的输入字符串
string	concat_ws(string SEP, string A, string B…)	链接多个字符串，字符串之间以指定的分隔符分开。
string	substr(string A, int start) substring(string A, int start)	从文本字符串中指定的起始位置后的字符。
string	substr(string A, int start, int len) substring(string A, int start, int len)	从文本字符串中指定的位置指定长度的字符。
string	upper(string A) ucase(string A)	将文本字符串转换成字母全部大写形式
string	lower(string A) lcase(string A)	将文本字符串转换成字母全部小写形式
string	trim(string A)	删除字符串两端的空格，字符之间的空格保留
string	ltrim(string A)	删除字符串左边的空格，其他的空格保留
string	rtrim(string A)	删除字符串右边的空格，其他的空格保留
string	regexp_replace(string A, string B, string C)	字符串A中的B字符被C字符替代
string	regexp_extract(string subject, string pattern, int index)	通过下标返回正则表达式指定的部分。regexp_extract(‘foothebar’, ‘foo(.*?)(bar)’, 2) returns ‘bar.’
string	parse_url(string urlString, string partToExtract [, string keyToExtract])	返回URL指定的部分。parse_url(‘http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1′, ‘HOST’) 返回：’facebook.com’
string	get_json_object(string json_string, string path)	select a.timestamp, get_json_object(a.appevents, ‘$.eventid’), get_json_object(a.appenvets, ‘$.eventname’) from log a;
string	space(int n)	返回指定数量的空格
string	repeat(string str, int n)	重复N次字符串
int	ascii(string str)	返回字符串中首字符的数字值
string	lpad(string str, int len, string pad)	返回指定长度的字符串，给定字符串长度小于指定长度时，由指定字符从左侧填补。
string	rpad(string str, int len, string pad)	返回指定长度的字符串，给定字符串长度小于指定长度时，由指定字符从右侧填补。
array	split(string str, string pat)	将字符串转换为数组。
int	find_in_set(string str, string strList)	返回字符串str第一次在strlist出现的位置。如果任一参数为NULL,返回NULL；如果第一个参数包含逗号，返回0。
array<array<string>>	sentences(string str, string lang, string locale)	将字符串中内容按语句分组，每个单词间以逗号分隔，最后返回数组。 例如sentences(‘Hello there! How are you?’) 返回：( (“Hello”, “there”), (“How”, “are”, “you”) )
array<struct<string,double>>	ngrams(array<array<string>>, int N, int K, int pf)	SELECT ngrams(sentences(lower(tweet)), 2, 100 [, 1000]) FROM twitter;
array<struct<string,double>>	context_ngrams(array<array<string>>, array<string>, int K, int pf)	SELECT context_ngrams(sentences(lower(tweet)), array(null,null), 100, [, 1000]) FROM twitter;

  内置聚合函数

返回类型	函数	说明
bigint	count(*) , count(expr), count(DISTINCT expr[, expr_., expr_.])	返回记录条数。
double	sum(col), sum(DISTINCT col)	求和
double	avg(col), avg(DISTINCT col)	求平均值
double	min(col)	返回指定列中最小值
double	max(col)	返回指定列中最大值
double	var_pop(col)	返回指定列的方差
double	var_samp(col)	返回指定列的样本方差
double	stddev_pop(col)	返回指定列的偏差
double	stddev_samp(col)	返回指定列的样本偏差
double	covar_pop(col1, col2)	两列数值协方差
double	covar_samp(col1, col2)	两列数值样本协方差
double	corr(col1, col2)	返回两列数值的相关系数
double	percentile(col, p)	返回数值区域的百分比数值点。0<=P<=1,否则返回NULL,不支持浮点型数值。
array<double>	percentile(col, array(p~1,,\ [, p,,2,,]…))	返回数值区域的一组百分比值分别对应的数值点。0<=P<=1,否则返回NULL,不支持浮点型数值。
double	percentile_approx(col, p[, B])	Returns an approximate p^th^ percentile of a numeric column (including floating point types) in the group.
		The B parameter controls approximation accuracy at the cost of memory. Higher values yield better approximations, and the default is 10,000. When the number of distinct values in col is smaller than B,
		this gives an exact percentile value.
array<double>	percentile_approx(col, array(p~1,, [, p,,2_]…) [, B])	Same as above, but accepts and returns an array of percentile values instead of a single one.
array<struct\{‘x’,'y’\}>	histogram_numeric(col, b)	Computes a histogram of a numeric column in the group using b non-uniformly spaced bins.
		The output is an array of size b of double-valued (x,y) coordinates that represent the bin centers and heights
array	collect_set(col)	返回无重复记录

  内置表函数

返回类型	函数	说明
数组	explode(array<TYPE> a)	数组一条记录中有多个参数，将参数拆分，每个参数生成一列。
	json_tuple	get_json_object语句：
		select a.timestamp, get_json_object(a.appevents, ‘$.eventid’), get_json_object(a.appenvets, ‘$.eventname’)
		from log a;
		json_tuple语句:
		select a.timestamp, b.* from log a lateral view json_tuple(a.appevent, ‘eventid’, ‘eventname’) b as f1, f2

6.8 Join中处理null值的语义区别

SQL标准中，任何对null的操作（数值比较，字符串操作等）结果都为null。Hive对null值处理的逻辑和标准基本一致，除了Join时的特殊逻辑。

这里的特殊逻辑指的是，Hive的Join中，作为Join key的字段比较，null=null是有意义的，且返回值为true。检查以下查询：

select u.uid, count(u.uid)

from t_weblog l join t_user u on (l.uid = u.uid) group by u.uid;

查询中，t_weblog表中uid为空的记录将和t_user表中uid为空的记录做连接，即l.uid = u.uid=null成立。

如果需要与标准一致的语义，我们需要改写查询手动过滤null值的情况：

select u.uid, count(u.uid)

from t_weblog l join t_user u

on (l.uid = u.uid and l.uid is not null and u.uid is not null)

group by u.uid;

实践中，这一语义区别也是经常导致数据倾斜的原因之一。

6.9分号字符

分号是SQL语句结束标记，在HiveQL中也是，但是在HiveQL中，对分号的识别没有那么智慧，例如：

select concat(cookie_id,concat(';',’zoo’)) from c02_clickstat_fatdt1 limit 2;

FAILED: Parse Error: line 0:-1 cannot recognize input '<EOF>' in function specification

可以推断，Hive解析语句的时候，只要遇到分号就认为语句结束，而无论是否用引号包含起来。

解决的办法是，使用分号的八进制的ASCII码进行转义，那么上述语句应写成：

select concat(cookie_id,concat('\073','zoo')) from c02_clickstat_fatdt1 limit 2;

为什么是八进制ASCII码？

我尝试用十六进制的ASCII码，但Hive会将其视为字符串处理并未转义，好像仅支持八进制，原因不详。这个规则也适用于其他非SELECT语句，如CREATE TABLE中需要定义分隔符，那么对不可见字符做分隔符就需要用八进制的ASCII码来转义。

 

 

7. Hive优化策略

7.1  HADOOP计算框架特性

• 数据量大不是问题，数据倾斜是个问题。
• jobs数比较多的作业运行效率相对比较低，比如即使有几百行的表，如果多次关联多次汇总，产生十几个jobs，耗时很长。原因是map reduce作业初始化的时间是比较长的。
• sum,count,max,min等UDAF，不怕数据倾斜问题,hadoop在map端的汇总合并优化，使数据倾斜不成问题。
• count(distinct ),在数据量大的情况下，效率较低，如果是多count(distinct )效率更低，因为count(distinct)是按group by 字段分组，按distinct字段排序，一般这种分布方式是很倾斜的，比如男uv,女uv，淘宝一天30亿的pv，如果按性别分组，分配2个reduce,每个reduce处理15亿数据。

7.2  优化的常用手段

• 好的模型设计事半功倍。
• 解决数据倾斜问题。
• 减少job数。
• 设置合理的map reduce的task数，能有效提升性能。(比如，10w+级别的计算，用160个reduce，那是相当的浪费，1个足够)。
• 了解数据分布，自己动手解决数据倾斜问题是个不错的选择。set hive.groupby.skewindata=true;这是通用的算法优化，但算法优化有时不能适应特定业务背景，开发人员了解业务，了解数据，可以通过业务逻辑精确有效的解决数据倾斜问题。
• 数据量较大的情况下，慎用count(distinct)，count(distinct)容易产生倾斜问题。
• 对小文件进行合并，是行至有效的提高调度效率的方法，假如所有的作业设置合理的文件数，对云梯的整体调度效率也会产生积极的正向影响。
• 优化时把握整体，单个作业最优不如整体最优。

7.3 全排序

Hive的排序关键字是SORT BY，它有意区别于传统数据库的ORDER BY也是为了强调两者的区别–SORT BY只能在单机范围内排序。

7.3.1 例1

set mapred.reduce.tasks=2;

原值

select cookie_id,page_id,id from c02_clickstat_fatdt1

where cookie_id IN('1.193.131.218.1288611279693.0','1.193.148.164.1288609861509.2')

1.193.148.164.1288609861509.2   113181412886099008861288609901078194082403      684000005

1.193.148.164.1288609861509.2   127001128860563972141288609859828580660473      684000015

1.193.148.164.1288609861509.2   113181412886099165721288609915890452725326      684000018

1.193.131.218.1288611279693.0   01c183da6e4bc50712881288611540109914561053      684000114

1.193.131.218.1288611279693.0   01c183da6e4bc22412881288611414343558274174      684000118

1.193.131.218.1288611279693.0   01c183da6e4bc50712881288611511781996667988      684000121

1.193.131.218.1288611279693.0   01c183da6e4bc22412881288611523640691739999      684000126

1.193.131.218.1288611279693.0   01c183da6e4bc50712881288611540109914561053      684000128

hive> select cookie_id,page_id,id from c02_clickstat_fatdt1 where

cookie_id IN('1.193.131.218.1288611279693.0','1.193.148.164.1288609861509.2')

SORT BY COOKIE_ID,PAGE_ID;

SORT排序后的值

1.193.131.218.1288611279693.0           684000118       01c183da6e4bc22412881288611414343558274174      684000118

1.193.131.218.1288611279693.0           684000114       01c183da6e4bc50712881288611540109914561053      684000114

1.193.131.218.1288611279693.0           684000128       01c183da6e4bc50712881288611540109914561053      684000128

1.193.148.164.1288609861509.2           684000005       113181412886099008861288609901078194082403      684000005

1.193.148.164.1288609861509.2           684000018       113181412886099165721288609915890452725326      684000018

1.193.131.218.1288611279693.0           684000126       01c183da6e4bc22412881288611523640691739999      684000126

1.193.131.218.1288611279693.0           684000121       01c183da6e4bc50712881288611511781996667988      684000121

1.193.148.164.1288609861509.2           684000015       127001128860563972141288609859828580660473      684000015

select cookie_id,page_id,id from c02_clickstat_fatdt1

where cookie_id IN('1.193.131.218.1288611279693.0','1.193.148.164.1288609861509.2')

ORDER BY PAGE_ID,COOKIE_ID;

1.193.131.218.1288611279693.0           684000118       01c183da6e4bc22412881288611414343558274174      684000118

1.193.131.218.1288611279693.0           684000126       01c183da6e4bc22412881288611523640691739999      684000126

1.193.131.218.1288611279693.0           684000121       01c183da6e4bc50712881288611511781996667988      684000121

1.193.131.218.1288611279693.0           684000114       01c183da6e4bc50712881288611540109914561053      684000114

1.193.131.218.1288611279693.0           684000128       01c183da6e4bc50712881288611540109914561053      684000128

1.193.148.164.1288609861509.2           684000005       113181412886099008861288609901078194082403      684000005

1.193.148.164.1288609861509.2           684000018       113181412886099165721288609915890452725326      684000018

1.193.148.164.1288609861509.2           684000015       127001128860563972141288609859828580660473      684000015

可以看到SORT和ORDER排序出来的值不一样。一开始我指定了2个reduce进行数据分发(各自进行排序)。结果不一样的主要原因是上述查询没有reduce key，hive会生成随机数作为reduce key。这样的话输入记录也随机地被分发到不同reducer机器上去了。为了保证reducer之间没有重复的cookie_id记录，可以使用DISTRIBUTE BY关键字指定分发key为cookie_id。

select cookie_id,country,id,page_id,id from c02_clickstat_fatdt1 where cookie_id IN('1.193.131.218.1288611279693.0','1.193.148.164.1288609861509.2')  distribute by cookie_id SORT BY COOKIE_ID,page_id;

1.193.131.218.1288611279693.0           684000118       01c183da6e4bc22412881288611414343558274174      684000118

1.193.131.218.1288611279693.0           684000126       01c183da6e4bc22412881288611523640691739999      684000126

1.193.131.218.1288611279693.0           684000121       01c183da6e4bc50712881288611511781996667988      684000121

1.193.131.218.1288611279693.0           684000114       01c183da6e4bc50712881288611540109914561053      684000114

1.193.131.218.1288611279693.0           684000128       01c183da6e4bc50712881288611540109914561053      684000128

1.193.148.164.1288609861509.2           684000005       113181412886099008861288609901078194082403      684000005

1.193.148.164.1288609861509.2           684000018       113181412886099165721288609915890452725326      684000018

1.193.148.164.1288609861509.2           684000015       127001128860563972141288609859828580660473      684000015

7.3.2 例2

CREATE TABLE if not exists t_order(

id int, -- 订单编号

sale_id int, -- 销售ID

customer_id int, -- 客户ID

product _id int, -- 产品ID

amount int -- 数量

) PARTITIONED BY (ds STRING);

在表中查询所有销售记录，并按照销售ID和数量排序：

set mapred.reduce.tasks=2;

Select sale_id, amount from t_order

Sort by sale_id, amount;

这一查询可能得到非期望的排序。指定的2个reducer分发到的数据可能是（各自排序）：

Reducer1：

Sale_id | amount

0 | 100

1 | 30

1 | 50

2 | 20

Reducer2：

Sale_id | amount

0 | 110

0 | 120

3 | 50

4 | 20

使用DISTRIBUTE BY关键字指定分发key为sale_id。改造后的HQL如下：

set mapred.reduce.tasks=2;

Select sale_id, amount from t_order

Distribute by sale_id

Sort by sale_id, amount;

这样能够保证查询的销售记录集合中，销售ID对应的数量是正确排序的，但是销售ID不能正确排序，原因是hive使用hadoop默认的HashPartitioner分发数据。

这就涉及到一个全排序的问题。解决的办法无外乎两种：

1.) 不分发数据，使用单个reducer：

set mapred.reduce.tasks=1;

这一方法的缺陷在于reduce端成为了性能瓶颈，而且在数据量大的情况下一般都无法得到结果。但是实践中这仍然是最常用的方法，原因是通常排序的查询是为了得到排名靠前的若干结果，因此可以用limit子句大大减少数据量。使用limit n后，传输到reduce端（单机）的数据记录数就减少到n* （map个数）。

2.) 修改Partitioner，这种方法可以做到全排序。这里可以使用Hadoop自带的TotalOrderPartitioner（来自于Yahoo!的TeraSort项目），这是一个为了支持跨reducer分发有序数据开发的Partitioner，它需要一个SequenceFile格式的文件指定分发的数据区间。如果我们已经生成了这一文件（存储在/tmp/range_key_list，分成100个reducer），可以将上述查询改写为

set mapred.reduce.tasks=100;

set hive.mapred.partitioner=org.apache.hadoop.mapred.lib.TotalOrderPartitioner;

set total.order.partitioner.path=/tmp/ range_key_list;

Select sale_id, amount from t_order

Cluster by sale_id

Sort by amount;

有很多种方法生成这一区间文件（例如hadoop自带的o.a.h.mapreduce.lib.partition.InputSampler工具）。这里介绍用Hive生成的方法，例如有一个按id有序的t_sale表：

CREATE TABLE if not exists t_sale (

id int,

name string,

loc string

);

则生成按sale_id分发的区间文件的方法是：

create external table range_keys(sale_id int)

row format serde

'org.apache.hadoop.hive.serde2.binarysortable.BinarySortableSerDe'

stored as

inputformat

'org.apache.hadoop.mapred.TextInputFormat'

outputformat

'org.apache.hadoop.hive.ql.io.HiveNullValueSequenceFileOutputFormat'

location '/tmp/range_key_list';

insert overwrite table range_keys

select distinct sale_id

from source t_sale sampletable(BUCKET 100 OUT OF 100 ON rand()) 

sort by sale_id;

生成的文件（/tmp/range_key_list目录下）可以让TotalOrderPartitioner按sale_id有序地分发reduce处理的数据。区间文件需要考虑的主要问题是数据分发的均衡性，这有赖于对数据深入的理解。

7.4 怎样做笛卡尔积

当Hive设定为严格模式（hive.mapred.mode=strict）时，不允许在HQL语句中出现笛卡尔积，这实际说明了Hive对笛卡尔积支持较弱。因为找不到Join key，Hive只能使用1个reducer来完成笛卡尔积。

当然也可以用上面说的limit的办法来减少某个表参与join的数据量，但对于需要笛卡尔积语义的需求来说，经常是一个大表和一个小表的Join操作，结果仍然很大（以至于无法用单机处理），这时MapJoin才是最好的解决办法。

MapJoin，顾名思义，会在Map端完成Join操作。这需要将Join操作的一个或多个表完全读入内存。

MapJoin的用法是在查询/子查询的SELECT关键字后面添加/*+ MAPJOIN(tablelist) */提示优化器转化为MapJoin（目前Hive的优化器不能自动优化MapJoin）。其中tablelist可以是一个表，或以逗号连接的表的列表。tablelist中的表将会读入内存，应该将小表写在这里。

PS：有用户说MapJoin在子查询中可能出现未知BUG。在大表和小表做笛卡尔积时，规避笛卡尔积的方法是，给Join添加一个Join key，原理很简单：将小表扩充一列join key，并将小表的条目复制数倍，join key各不相同；将大表扩充一列join key为随机数。

7.5 怎样写exist/in子句

Hive不支持where子句中的子查询，SQL常用的exist in子句需要改写。这一改写相对简单。考虑以下SQL查询语句：

SELECT a.key, a.value

FROM a

WHERE a.key in

(SELECT b.key

FROM B);

可以改写为

SELECT a.key, a.value

FROM a LEFT OUTER JOIN b ON (a.key = b.key)

WHERE b.key <> NULL;

一个更高效的实现是利用left semi join改写为：

SELECT a.key, a.val

FROM a LEFT SEMI JOIN b on (a.key = b.key);

left semi join是0.5.0以上版本的特性。

7.6 怎样决定reducer个数

Hadoop MapReduce程序中，reducer个数的设定极大影响执行效率，这使得Hive怎样决定reducer个数成为一个关键问题。遗憾的是Hive的估计机制很弱，不指定reducer个数的情况下，Hive会猜测确定一个reducer个数，基于以下两个设定：

1. hive.exec.reducers.bytes.per.reducer（默认为1000^3）

2. hive.exec.reducers.max（默认为999）

计算reducer数的公式很简单：

N=min(参数2，总输入数据量/参数1)

通常情况下，有必要手动指定reducer个数。考虑到map阶段的输出数据量通常会比输入有大幅减少，因此即使不设定reducer个数，重设参数2还是必要的。依据Hadoop的经验，可以将参数2设定为0.95*(集群中TaskTracker个数)。

7.7 合并MapReduce操作

Multi-group by

Multi-group by是Hive的一个非常好的特性，它使得Hive中利用中间结果变得非常方便。例如，

FROM (SELECT a.status, b.school, b.gender

FROM status_updates a JOIN profiles b

ON (a.userid = b.userid and

a.ds='2009-03-20' )

) subq1

INSERT OVERWRITE TABLE gender_summary

PARTITION(ds='2009-03-20')

SELECT subq1.gender, COUNT(1) GROUP BY subq1.gender

INSERT OVERWRITE TABLE school_summary

PARTITION(ds='2009-03-20')

SELECT subq1.school, COUNT(1) GROUP BY subq1.school

上述查询语句使用了Multi-group by特性连续group by了2次数据，使用不同的group by key。这一特性可以减少一次MapReduce操作。

Multi-distinct

Multi-distinct是淘宝开发的另一个multi-xxx特性，使用Multi-distinct可以在同一查询/子查询中使用多个distinct，这同样减少了多次MapReduce操作

7.7 Bucket 与 Sampling

Bucket是指将数据以指定列的值为key进行hash，hash到指定数目的桶中。这样就可以支持高效采样了。

如下例就是以userid这一列为bucket的依据，共设置32个buckets

CREATE TABLE page_view(viewTime INT, userid BIGINT,

                    page_url STRING, referrer_url STRING,

                    ip STRING COMMENT 'IP Address of the User')

    COMMENT 'This is the page view table'

    PARTITIONED BY(dt STRING, country STRING)

    CLUSTERED BY(userid) SORTED BY(viewTime) INTO 32 BUCKETS

    ROW FORMAT DELIMITED

            FIELDS TERMINATED BY '1'

            COLLECTION ITEMS TERMINATED BY '2'

            MAP KEYS TERMINATED BY '3'

    STORED AS SEQUENCEFILE;

Sampling可以在全体数据上进行采样，这样效率自然就低，它还是要去访问所有数据。而如果一个表已经对某一列制作了bucket，就可以采样所有桶中指定序号的某个桶，这就减少了访问量。

如下例所示就是采样了page_view中32个桶中的第三个桶。

SELECT * FROM page_view TABLESAMPLE(BUCKET 3 OUT OF 32);

7.8  Partition

Partition就是分区。分区通过在创建表时启用partition by实现，用来partition的维度并不是实际数据的某一列，具体分区的标志是由插入内容时给定的。当要查询某一分区的内容时可以采用where语句，形似where tablename.partition_key > a来实现。

创建含分区的表

    CREATE TABLE page_view(viewTime INT, userid BIGINT,

                    page_url STRING, referrer_url STRING,

                    ip STRING COMMENT 'IP Address of the User')

    PARTITIONED BY(date STRING, country STRING)

    ROW FORMAT DELIMITED

            FIELDS TERMINATED BY '1'

    STORED AS TEXTFILE;

载入内容，并指定分区标志

LOAD DATA LOCAL INPATH `/tmp/pv_2008-06-08_us.txt` INTO TABLE page_view PARTITION(date='2008-06-08', country='US');

查询指定标志的分区内容

SELECT page_views.*

    FROM page_views

    WHERE page_views.date >= '2008-03-01' AND page_views.date <= '2008-03-31' AND page_views.referrer_url like '%xyz.com';

7.9 JOIN

7.9.1 JOIN原则

在使用写有 Join 操作的查询语句时有一条原则：应该将条目少的表/子查询放在 Join 操作符的左边。原因是在 Join 操作的 Reduce 阶段，位于 Join 操作符左边的表的内容会被加载进内存，将条目少的表放在左边，可以有效减少发生 OOM 错误的几率。对于一条语句中有多个 Join 的情况，如果 Join 的条件相同，比如查询：

INSERT OVERWRITE TABLE pv_users  SELECT pv.pageid, u.age FROM page_view p  JOIN user u ON (pv.userid = u.userid)  JOIN newuser x ON (u.userid = x.userid);

• 如果 Join 的 key 相同，不管有多少个表，都会则会合并为一个 Map-Reduce
• 一个 Map-Reduce 任务，而不是 ‘n’ 个
• 在做 OUTER JOIN 的时候也是一样

如果 Join 的条件不相同，比如：

INSERT OVERWRITE TABLE pv_users    SELECT pv.pageid, u.age FROM page_view p    JOIN user u ON (pv.userid = u.userid)    JOIN newuser x on (u.age = x.age);

Map-Reduce 的任务数目和 Join 操作的数目是对应的，上述查询和以下查询是等价的：

INSERT OVERWRITE TABLE tmptable    SELECT * FROM page_view p JOIN user u    ON (pv.userid = u.userid);  INSERT OVERWRITE TABLE pv_users    SELECT x.pageid, x.age FROM tmptable x    JOIN newuser y ON (x.age = y.age);

7.10 数据倾斜

7.10.1 空值数据倾斜

场景：如日志中，常会有信息丢失的问题，比如全网日志中的user_id，如果取其中的user_id和bmw_users关联，会碰到数据倾斜的问题。

解决方法1： user_id为空的不参与关联

Select * From log a

Join bmw_users b

On a.user_id is not null

And a.user_id = b.user_id

Union all

Select * from log a

where a.user_id is null;

解决方法2 ：赋与空值分新的key值

Select *  

from log a 

left outer join bmw_users b 

on case when a.user_id is null then concat(‘dp_hive’,rand() ) else a.user_id end = b.user_id; 

结论：方法2比方法效率更好，不但io少了，而且作业数也少了。方法1 log读取两次，jobs是2。方法2 job数是1 。这个优化适合无效id(比如-99,’’,null等)产生的倾斜问题。把空值的key变成一个字符串加上随机数，就能把倾斜的数据分到不同的reduce上 ,解决数据倾斜问题。附上hadoop通用关联的实现方法（关联通过二次排序实现的，关联的列为parition key,关联的列c1和表的tag组成排序的group key,根据parition key分配reduce。同一reduce内根据group key排序）

7.10.2 不同数据类型关联产生数据倾斜

场景：一张表s8的日志，每个商品一条记录，要和商品表关联。但关联却碰到倾斜的问题。s8的日志中有字符串商品id,也有数字的商品id,类型是string的，但商品中的数字id是bigint的。猜测问题的原因是把s8的商品id转成数字id做hash来分配reduce，所以字符串id的s8日志，都到一个reduce上了，解决的方法验证了这个猜测。

解决方法：把数字类型转换成字符串类型

Select * from s8_log a

Left outer join r_auction_auctions b

On a.auction_id = cast(b.auction_id as string);

7.10.3 大表Join的数据偏斜

MapReduce编程模型下开发代码需要考虑数据偏斜的问题，Hive代码也是一样。数据偏斜的原因包括以下两点：

1. Map输出key数量极少，导致reduce端退化为单机作业。

2. Map输出key分布不均，少量key对应大量value，导致reduce端单机瓶颈。

Hive中我们使用MapJoin解决数据偏斜的问题，即将其中的某个表（全量）分发到所有Map端进行Join，从而避免了reduce。这要求分发的表可以被全量载入内存。

极限情况下，Join两边的表都是大表，就无法使用MapJoin。

这种问题最为棘手，目前已知的解决思路有两种：

1. 如果是上述情况1，考虑先对Join中的一个表去重，以此结果过滤无用信息。这样一般会将其中一个大表转化为小表，再使用MapJoin 。

一个实例是广告投放效果分析，例如将广告投放者信息表i中的信息填充到广告曝光日志表w中，使用投放者id关联。因为实际广告投放者数量很少（但是投放者信息表i很大），因此可以考虑先在w表中去重查询所有实际广告投放者id列表，以此Join过滤表i，这一结果必然是一个小表，就可以使用MapJoin。

2. 如果是上述情况2，考虑切分Join中的一个表为多片，以便将切片全部载入内存，然后采用多次MapJoin得到结果。

一个实例是商品浏览日志分析，例如将商品信息表i中的信息填充到商品浏览日志表w中，使用商品id关联。但是某些热卖商品浏览量很大，造成数据偏斜。例如，以下语句实现了一个inner join逻辑，将商品信息表拆分成2个表：

select * from

(

select w.id, w.time, w.amount, i1.name, i1.loc, i1.cat

from w left outer join i sampletable(1 out of 2 on id) i1

)

union all

(

select w.id, w.time, w.amount, i2.name, i2.loc, i2.cat

from w left outer join i sampletable(1 out of 2 on id) i2

)

);

以下语句实现了left outer join逻辑：

select t1.id, t1.time, t1.amount,

    coalease(t1.name, t2.name),

    coalease(t1.loc, t2.loc),

    coalease(t1.cat, t2.cat)

from ( 

    select w.id, w.time, w.amount, i1.name, i1.loc, i1.cat

    from w left outer join i sampletable(1 out of 2 on id) i1

) t1 left outer join i sampletable(2 out of 2 on id) t2;

上述语句使用Hive的sample table特性对表做切分。

7.11 合并小文件

文件数目过多，会给 HDFS 带来压力，并且会影响处理效率，可以通过合并 Map 和 Reduce 的结果文件来消除这样的影响：

hive.merge.mapfiles = true 是否和并 Map 输出文件，默认为 True

hive.merge.mapredfiles = false 是否合并 Reduce 输出文件，默认为 False

hive.merge.size.per.task = 256*1000*1000 合并文件的大小

7.12 Group By

7.12.1 Map 端部分聚合：

     并不是所有的聚合操作都需要在 Reduce 端完成，很多聚合操作都可以先在 Map 端进行部分聚合，最后在 Reduce 端得出最终结果。

      基于 Hash

      参数包括：

• hive.map.aggr = true 是否在 Map 端进行聚合，默认为 True
• hive.groupby.mapaggr.checkinterval = 100000 在 Map 端进行聚合操作的条目数目

7.12.2 有数据倾斜的时候进行负载均衡

      hive.groupby.skewindata = false

当选项设定为 true，生成的查询计划会有两个 MR Job。第一个 MR Job 中，Map 的输出结果集合会随机分布到 Reduce 中，每个 Reduce 做部分聚合操作，并输出结果，这样处理的结果是相同的 Group By Key 有可能被分发到不同的 Reduce 中，从而达到负载均衡的目的；第二个 MR Job 再根据预处理的数据结果按照 Group By Key 分布到 Reduce 中（这个过程可以保证相同的 Group By Key 被分布到同一个 Reduce 中），最后完成最终的聚合操作。  

8. Hive实战(实战中所需表由数据仓库建模时提供)

8.1 互联网公司Order表相关常见Hql分析

8.1.1 管理报表-订单基本统计信息(日粒度)

查看每个城市每天完成订单数，取消订单数，下单订单数，下单用户数。

select city_id,sum(case when order_status=5 then 1 else 0 end) as cnt_ord_succ_d,

 sum(case when order_status=3 then 1 else 0 end) as cnt_ord_cacel_d,

 sum(1) as cnt_ord_d,

 count(distinct CUST_ID) as cnt_ord_user

 FROM dw.dw_order WHERE dt='${day_01}'

 group by city_id;

8.1.2 运营团队-订单数据信息(活动分析)                   

8.1.3 商品复购率Hql分析

需求列出的商品的7日,15日,30复购率，目的了解这几款商品的周期.

计算口径:当日购买部分商品的用户数/7日重复购买此商品的用户数。

每天查看每个城市每个商品当日购买用户数，7日15日30日复购率。

SELECT t3.atdate AS cdate,t3.city_id,t3.goods_id,

COUNT(DISTINCT CASE WHEN days=0 THEN t3.cust_id END) AS cnt_buy_cust_d,

COUNT(DISTINCT CASE WHEN days>0 AND days<=7 THEN t3.cust_id END) AS cnt_buy_cust_7_d,

COUNT(DISTINCT CASE WHEN days>0 AND days<=15 THEN t3.cust_id END) AS cnt_buy_cust_15_d,

COUNT(DISTINCT CASE WHEN days>0 AND days<=30 THEN t3.cust_id END) AS cnt_buy_cust_30_d

FROM (

SELECT t1.atdate,t1.city_id,t1.cust_id,t1.goods_id,

DATEDIFF(t2.atdate, t1.atdate) days

FROM (

SELECT o.order_date AS atdate,o.city_id,

o.cust_id,og.goods_id

FROM dw.dw_order o INNER JOIN dw.dw_order_goods og

ON o.order_id=og.order_id

AND o.ORDER_STATUS = 5

AND og.source_id=1

AND o.dt = '20151010'

) t1 INNER JOIN (

SELECT o.order_date AS atdate,o.city_id,

o.cust_id,og.goods_id,

og.goods_name

FROM dw.dw_order o INNER JOIN dw.dw_order_goods og

ON o.order_id=og.order_id

AND o.ORDER_STATUS = 5

AND og.source_id=1

) t2 ON t1.cust_id=t2.cust_id AND t1.goods_id=t2.goods_id

) t3 GROUP BY t3.atdate,t3.city_id,t3.goods_id;

8.1.4 月平均日客户数Hql分析

   目前有一个合作资源，北京某度假酒店，价值几百到8000不等的酒店套房，一共100套，可以给到购买200元以上订单用户，用于抽奖奖品，比如设置的获奖条件：凡在9月,10月,11月的用户，下单200元以上的订单，即可获得北京某度假酒店。目的带动销量，刺激用户参与活动，同时给合作方导流。

  合作方需要知道我们订单金额在200以上的每天平均的用户量是多少.

#客户id是int类型 需注意用count

SELECT

SUM(CASE WHEN t.COMPLETION_DATE>='20151001' AND t.COMPLETION_DATE<='20151031' THEN 1 ELSE 0 END) AS cnt_ord_10_m

,COUNT(DISTINCT CASE WHEN t.COMPLETION_DATE>='20151001' AND t.COMPLETION_DATE<='20151031' THEN CUST_ID END) AS cnt_cust_10_m

FROM dw.dw_order t

WHERE t.COMPLETION_DATE>='20151001'

AND t.COMPLETION_DATE<='20151031'

AND CITY_ID=2

AND ORDER_TYPE <>6

AND PAYABLE_AMOUNT>100

AND t.ORDER_STATUS=5;

8.2 互联网公司User相关常见Hql分析

8.2.1用户总体数据信息Hql分析(历史累计)

求每个用户累计订单数，累计应付金额

select nvl(t1.cust_id,t2.cust_id),

nvl(t2.order_cnt,0)+nvl(t1.order_cnt,0) as order_cnt,

nvl(t2.amount_sum,0)+nvl(t1.amount_sum,0) as amount_sum

from dw.dw_customer t1

full outer join (

select cust_id,count(1) as order_cnt,sum(payable_amount) as amount_sum from

dw.dw_order where dt='20151011' and order_status=5

group by cust_id

) t2 on t1.cust_id=t2.cust_id

and t1.dt=20151210 limit 100;

8.2.2新用户统计信息Hql分析(日粒度)

select count(1) from dw.dw_customer

where dt='20151210' and 

from_unixtime(unix_timestamp(register_time,'yyyy/MM/dd HH:mm'),'yyyyMMdd')='20140610';

8.2.3求5,6月各个渠道带来的新用户，以此来考核运营部门的kpi

select source_no,count(1) from dw.dw_customer

where dt=20151211 and

from_unixtime(unix_timestamp(register_time,'yyyy/MM/dd HH:mm'),'yyyyMMdd')>='20141201'

and from_unixtime(unix_timestamp(register_time,'yyyy/MM/dd HH:mm'),'yyyyMMdd')<='20150131'

and source_no is not null

group by source_no;

 8.2.4统计各个渠道带来的用户，top10完成订单数

#主要掌握求top 10 hql

select source_no,mobile,order_cnt,rn from (

select source_no,order_cnt,mobile,

row_number() over(partition by source_no order by order_cnt desc) as rn

from dw.dw_customer

where dt=20151211 and source_no is not null and order_cnt is not null

) t2 where rn <10;

8.2.4 分时段提取僵尸用户数据Hql分析

     僵尸用户口径定义：注册后未下单及未成功下过订单的用户

select count(1) from dw.dw_customer where last_order_time is null;

8.3 大胃王项目数据统计

8.3.1 2015年消费账单，打败了多少人

8.3.2 2015年购买商品的top 10

9. ETL任务调度设计

9.1通过Liunx Crontab实现任务调度

9.1.1 Shell脚步实现ETL作业之间依赖关系

9.1.2 Hive ETL作业开发模板

9.1.3 Crontab配置模板

---

对于每一个表（table）或者分区， Hive可以进一步组织成桶，也就是说桶是更为细粒度的数据范围划分。Hive也是 针对某一列进行桶的组织。Hive采用对列值哈希，然后除以桶的个数求余的方式决定该条记录存放在哪个桶当中。

把表（或者分区）组织成桶（Bucket）有两个理由：

（1）获得更高的查询处理效率。桶为表加上了额外的结构，Hive 在处理有些查询时能利用这个结构。具体而言，连接两个在（包含连接列的）相同列上划分了桶的表，可以使用 Map 端连接 （Map-side join）高效的实现。比如JOIN操作。对于JOIN操作两个表有一个相同的列，如果对这两个表都进行了桶操作。那么将保存相同列值的桶进行JOIN操作就可以，可以大大较少JOIN的数据量。

（2）使取样（sampling）更高效。在处理大规模数据集时，在开发和修改查询的阶段，如果能在数据集的一小部分数据上试运行查询，会带来很多方便。

ADD是代表新增一字段，字段位置在所有列后面(partition列前)，REPLACE则是表示替换表中所有字段。

1、order by 会对输入做全局排序，因此只有一个reducer，会导致当输入规模较大时，需要较长的计算时间。

2、sort by不是全局排序，其在数据进入reducer前完成排序。因此，如果用sort by进行排序，并且设置mapred.reduce.tasks>1，

   则sort by只保证每个reducer的输出有序，不保证全局有序。

3、distribute by根据distribute by指定的内容将数据分到同一个reducer。

4、Cluster by 除了具有Distribute by的功能外，还会对该字段进行排序。因此，常常认为cluster by = distribute by + sort by

Hive数据导入导出

Hive三种不同的数据导出的方式

（1）  导出到本地文件系统

insert overwrite local directory '/home/anjianbing/soft/export_data/app_order_city_d'

row format delimited

fields terminated by '\t'

select * from app.app_order_city_d limit 10;

通过insert overwrite local directory将hive中的表app_order_city_d的内容到本地文件系统的/home/anjianbing/soft/export_data下的app_order_city_d目录下，这条HQL的执行需要启用Mapreduce完成，

运行完这条语句之后，将会在本地文件系统的/home/anjianbing/soft/export_data/app_order_city_d目录下生成文件，这个文件是Reduce产生的结果（这里生成的文件名是000000_0）

（2）  导出到hive的另一个表中

insert into table hive_student_test 
select id,name,sex,salary from student; 

(3) $ hive -e "select * from employees" >> export/out.txt

Hive Load方式加载数据

load data local inpath '/home/joe/Desktop/employees.tsv' overwrite into table employees;

Sqoop与关系型数据库导入导出命令

1.列出所有数据库

$SQOOP_HOME/bin/sqoop list-databases --connect jdbc:mysql://192.168.209.1:3306/ --username root --password 123456

2.mysql导出表到hive并创建表(默认default库，如需设置路径：--warehouse-dir /user/hive/warehouse/t_etl_log)

$SQOOP_HOME/bin/sqoop import --connect jdbc:mysql://192.168.209.1:3306/world --username root --password 123456 --table city --hive-import -m 1

3.hdfs导出到mysql

$SQOOP_HOME/bin/sqoop export --connect jdbc:mysql://192.168.209.1:3306/world --username root --password 123456 --table city --fields-terminated-by '\001' --export-dir /user/hive/warehouse/city

MySQL
一、 把 employees.tsv 文件数据导入数据表：
$ mysql --local-infile –u hadoopuser –p
mysql> load data local infile '/home/joe/Desktop/employees.tsv' into table employees fields
terminated by '\t' lines terminated by '\n';
二、 利用 MySQL 导出数据：
mysql> select * from employees into outfile '/tmp/mysql_out.csv' fields terminated by ',' lines
terminated by '\n';

Hive三种不同的数据导出的方式

（1）  导出到本地文件系统

insert overwrite local directory '/home/anjianbing/soft/export_data/app_order_city_d'

row format delimited

fields terminated by '\t'

select * from app.app_order_city_d limit 10;

通过insert overwrite local directory将hive中的表app_order_city_d的内容到本地文件系统的/home/anjianbing/soft/export_data下的app_order_city_d目录下，这条HQL的执行需要启用Mapreduce完成，

运行完这条语句之后，将会在本地文件系统的/home/anjianbing/soft/export_data/app_order_city_d目录下生成文件，这个文件是Reduce产生的结果（这里生成的文件名是000000_0）

（2）  导出到hive的另一个表中

insert into table hive_student_test 
select id,name,sex,salary from student; 

(3) $ hive -e "select * from employees" >> export/out.txt

Hive Load方式加载数据

load data local inpath '/home/joe/Desktop/employees.tsv' overwrite into table employees;

Sqoop与关系型数据库导入导出命令

1.列出所有数据库

$SQOOP_HOME/bin/sqoop list-databases --connect jdbc:mysql://192.168.209.1:3306/ --username root --password 123456

2.mysql导出表到hive并创建表(默认default库，如需设置路径：--warehouse-dir /user/hive/warehouse/t_etl_log)

$SQOOP_HOME/bin/sqoop import --connect jdbc:mysql://192.168.209.1:3306/world --username root --password 123456 --table city --hive-import -m 1

3.hdfs导出到mysql

$SQOOP_HOME/bin/sqoop export --connect jdbc:mysql://192.168.209.1:3306/world --username root --password 123456 --table city --fields-terminated-by '\001' --export-dir /user/hive/warehouse/city

MySQL
一、 把 employees.tsv 文件数据导入数据表：
$ mysql --local-infile –u hadoopuser –p
mysql> load data local infile '/home/joe/Desktop/employees.tsv' into table employees fields
terminated by '\t' lines terminated by '\n';
二、 利用 MySQL 导出数据：
mysql> select * from employees into outfile '/tmp/mysql_out.csv' fields terminated by ',' lines
terminated by '\n';