Hadoop Pig

Pig包括两部分：

用于描述数据流的语言，称为Pig Latin。
用于执行Pig Latin程序的执行环境，当前有两个环境：单JVM中的本地执行环境和Hadoop集群上的分布式执行环境。

Pig内部，每个操作或变换是对输入进行数据处理，然后产生输出结果，这些变换操作被转换成一系列MapReduce作业，Pig让程序员不需要知道这些转换具体是如何进行的，这样工程师可以将精力集中在数据上，而非执行的细节上。

Pig可以看做hadoop的客户端软件，可以连接到hadoop集群进行数据分析的工作

Pig方便不熟悉java的用户，使用一种较为简便的类似SQL的面向数据流的语言piglatin进行数据处理

Pig Latin可以进行排序，过滤，求和，分组，关联等操作，还可以自定义函数，是一种面向数据分析的轻量级脚本语言

Pig可以看做pig latin到map-reduce的映射器

Pig安装

cp pig-0.16.0.tar.gz /home/hdp/
tar -zxvf pig-0.16.0.tar.gz
mv pig-0.16.0 pig

切换root设置环境变量

export PIG_INSTALL=/home/hdp/pig
export PATH=$PATH:$PIG_INSTALL/bin

source /etc/profile

本地模式（所有文件和执行过程都在本地，一般用于测试程序）

pig -x local
grunt>

Mapreduce模式

实际工作模式，在MapReduce模式下，Pig将查询翻译为MapReduce作业，然后在Hadoop集群上执行。Pig版本和Hadoop版本间有要求

切换root设置环境变量设置设置下HADOOP_HOME和PATH（一般装完hadoop之后都已经有了）

export PIG_CLASSPATH=$HADOOP_HOME/etc/hadoop
export HADOOP_HOME=/home/hdp/hadoop

准备文件

hadoop dfs -mkdir /test
hadoop dfs -put ./LICENSE.txt /test
hadoop dfs -ls /test

pig -x mapreduce
grunt> 
grunt> ls /
hdfs://mycluster/test <dir>
grunt> ls /test
hdfs://mycluster/test/LICENSE.txt<r 1> 84853
grunt>cat /test/LICENSE.txt

grunt>copyToLOcal /test/LICENSE.txt ttt
grunt>sh /usr/jdk1.7.0_80/bin/jps

Pig数据模型

Bag：表

Tuple：行，记录

Field：属性

Pig不要求同一个bag里的哥哥tuple有相同数量或者相同类型的field

PigLatin

Load：载入数据的方法

foreach：逐行扫描进行某种处理

filter：过滤行

dump：把结果显示到屏幕

store：把结果保存到文件

一个实例：为天气温度数据集编写脚本计算一年中的最高纪录

第二个例子，统计每个ip的出现次数

数据源，网站log文件，已经上传到hdfs

grunt> A = LOAD '/test/access_log.txt' USING PigStorage(' ') AS (ip,others);
grunt> B = FOREACH A GENERATE ip;          
grunt> C = FOREACH (GROUP B BY ip) GENERATE group AS ip,COUNT(B); 
grunt> E = ORDER D by amount DESC,ip;
grunt> DUMP E;


(218.20.24.203,4597)
(221.194.180.166,4576)
(119.146.220.12,1850)
(117.136.31.144,1647)
(121.28.95.48,1597)
(113.109.183.126,1596)
(182.48.112.2,870)
(120.84.24.200,773)
(61.144.125.162,750)
(27.115.124.75,470)
(115.236.48.226,439)
(59.41.62.100,339)
(89.126.54.40,305)
(114.247.10.132,243)
(125.46.45.78,236)
(220.181.94.221,205)
(218.19.42.168,181)
(118.112.183.164,179)
(116.235.194.89,171)
(114.43.237.117,167)
(61.155.206.81,165)
(202.108.18.253,164)
(218.107.55.254,164)
(14.213.176.184,133)
(121.14.162.28,125)
(123.150.182.147,125)
(121.14.162.124,124)
(123.150.182.180,124)
(222.73.191.55,124)
(27.9.110.75,122)
(116.30.81.181,111)
(116.7.101.166,97)
(27.188.55.59,96)
(220.178.27.142,93)
(183.31.209.149,88)
(192.250.46.129,87)
(118.118.150.192,84)
(124.74.27.218,84)
(203.208.60.225,82)
(203.208.60.227,82)
(203.208.60.226,81)
(112.4.2.51,80)
(14.217.19.126,80)
(59.108.111.207,78)
(210.51.195.5,77)
(218.31.116.143,71)
(61.164.101.246,69)
(117.136.31.147,65)
(218.202.106.203,65)
(117.136.12.6,61)
(61.154.14.122,61)
(99.76.10.239,60)
(182.204.8.4,59)
(59.151.120.38,59)
(112.224.3.119,58)
(180.168.111.114,57)
(117.136.20.78,55)
(122.89.138.26,54)
(119.164.105.9,53)
(116.116.8.161,46)
(113.57.218.226,45)
(114.248.114.208,45)
(124.128.220.146,45)
(71.45.41.139,45)
(211.137.59.33,43)
(211.140.5.103,43)
(221.236.79.251,43)
(121.28.205.250,42)
(60.2.99.33,42)
(211.139.92.11,40)
(117.136.2.237,37)
(123.147.244.39,37)
(124.132.106.179,37)
(211.137.199.56,37)
(211.140.5.100,34)
(117.136.12.192,32)
(117.136.24.85,32)
(117.136.8.11,32)
(1.192.138.149,31)
(183.12.74.40,31)
(222.128.144.26,31)
(59.151.120.36,31)
(61.163.236.155,31)
(117.136.10.141,30)
(117.136.16.201,30)
(117.136.23.238,30)
(117.136.32.23,30)
(218.89.132.133,30)
(111.226.162.122,28)
(218.213.137.2,28)
(60.247.116.29,28)
(110.16.198.88,27)
(114.224.177.194,27)
(121.41.128.23,27)
(218.1.102.166,27)
(61.164.72.118,27)
(112.246.185.253,26)
(114.98.146.181,26)
(116.231.109.204,26)
(120.68.17.229,26)
(121.31.62.3,26)
(124.238.242.47,26)
(175.171.179.121,26)
(180.95.186.78,26)
(211.139.163.168,26)
(220.191.226.141,26)
(59.61.141.119,26)
(111.161.72.31,25)
(112.64.190.54,25)
(117.136.15.96,25)
(125.77.31.163,25)
...
...

Pig适用场景

Pig并不适合所有的数据处理任务，和MapReduce一样，它是为数据批处理而设计的，如果想执行的查询只涉及一个大型数据集的一小部分数据，Pig的实现不会很好，因为它要扫描整个数据集或其中很大一部分。

随着新版本发布，Pig的表现和原生MapRedece程序差距越来越小，因为Pig的开发团队使用了复杂、精巧的算法来实现Pig的关系操作。除非你愿意花大量时间来优化Java MapReduce程序，否则使用Pig Latin来编写查询的确能帮你节约时间。

附录：

执行Pig程序的方法

脚本：Pig可以运行包含Pig命令的脚本文件，例如，pig script.pig，对于很短的脚本可以通过使用-e选项直接在命令行中输入脚本字符串。
Grunt：Pig shell，就是上文的运行模式
嵌入式方法：也可以在Java中运行Pig程序，和使用JDBC运行SQL程序很像，详情：https://wiki.apache.org/pig/EmbeddedPig

Pig与RDBMS、Hive比较

Pig Latin是一种数据流编程语言，而SQL是一种描述性编程语言。换句话说，Pig程序是相对于输入的一步步操作，其中每一步是对数据的一个简答的变换。相反，SQL语句是一个约束的集合，这些约束的集合在一起，定义了输出。
示例也可以看出，Pig其实是对Java的Mapreduce的封装，进一步的抽象，运行的也是java程序，并在此基础上提供其他特性。
Hive介于Pig和传统RDBMS(关系数据库管理系统Relational Database Management System)之间，Hive的设计目的是让精通SQL既能的分析师能够在存放在HDFS的大规模数据集上运行查询。
Hive在很多方面和传统数据库类似，但是它底层对HDFS和MapReduce的依赖意味着它的体系结构有别于传统数据库。
Hive本身不存储数据，完全依赖于HDFS和MapReduce，Hive可以将结构化的数据文件映射为一张数据库表，Hive中表纯逻辑，就是表的元数据。而HBase是物理表，定位是NoSQL。

以下SQL在Pig中的实现refer to http://guoyunsky.iteye.com/blog/1317084

我这里以Mysql 5.1.x为例,Pig的版本是0.8

同时我将数据放在了两个文件,存放在/tmp/data_file_1和/tmp/data_file_2中.文件内容如下:

tmp_file_1:

Txt代码

zhangsan 23 1
lisi 24 1
wangmazi 30 1
meinv 18 0
dama 55 0

tmp_file_2:

Txt代码

1 a
23 bb
50 ccc
30 dddd
66 eeeee

1.从文件导入数据

1)Mysql (Mysql需要先创建表).

CREATE TABLE TMP_TABLE(USER VARCHAR(32),AGE INT,IS_MALE BOOLEAN);

CREATE TABLE TMP_TABLE_2(AGE INT,OPTIONS VARCHAR(50)); -- 用于Join

LOAD DATA LOCAL INFILE '/tmp/data_file_1' INTO TABLE TMP_TABLE ;

LOAD DATA LOCAL INFILE '/tmp/data_file_2' INTO TABLE TMP_TABLE_2;

2)Pig

tmp_table = LOAD '/tmp/data_file_1' USING PigStorage('\t') AS (user:chararray, age:int,is_male:int);

tmp_table_2= LOAD '/tmp/data_file_2' USING PigStorage('\t') AS (age:int,options:chararray);

2.查询整张表

1)Mysql

SELECT * FROM TMP_TABLE;

2)Pig

DUMP tmp_table;

3. 查询前50行

1)Mysql

SELECT * FROM TMP_TABLE LIMIT 50;

2)Pig

tmp_table_limit = LIMIT tmp_table 50;

DUMP tmp_table_limit;

4.查询某些列

1)Mysql

SELECT USER FROM TMP_TABLE;

2)Pig

tmp_table_user = FOREACH tmp_table GENERATE user;

DUMP tmp_table_user;

5. 给列取别名

1)Mysql

SELECT USER AS USER_NAME,AGE AS USER_AGE FROM TMP_TABLE;

2)Pig

tmp_table_column_alias = FOREACH tmp_table GENERATE user AS user_name,age AS user_age;

DUMP tmp_table_column_alias;

6.排序

1)Mysql

SELECT * FROM TMP_TABLE ORDER BY AGE;

2)Pig

tmp_table_order = ORDER tmp_table BY age ASC;

DUMP tmp_table_order;

7.条件查询

1）Mysql

SELECT * FROM TMP_TABLE WHERE AGE>20;

2) Pig

tmp_table_where = FILTER tmp_table by age > 20;

DUMP tmp_table_where;

8.内连接Inner Join

1)Mysql

SELECT * FROM TMP_TABLE A JOIN TMP_TABLE_2 B ON A.AGE=B.AGE;

2)Pig

tmp_table_inner_join = JOIN tmp_table BY age,tmp_table_2 BY age;

DUMP tmp_table_inner_join;

9.左连接Left Join

1)Mysql

SELECT * FROM TMP_TABLE A LEFT JOIN TMP_TABLE_2 B ON A.AGE=B.AGE;

2)Pig

tmp_table_left_join = JOIN tmp_table BY age LEFT OUTER,tmp_table_2 BY age;

DUMP tmp_table_left_join;

10.右连接Right Join

1)Mysql

SELECT * FROM TMP_TABLE A RIGHT JOIN TMP_TABLE_2 B ON A.AGE=B.AGE;

2)Pig

tmp_table_right_join = JOIN tmp_table BY age RIGHT OUTER,tmp_table_2 BY age;

DUMP tmp_table_right_join;

11.全连接Full Join

1)Mysql

SELECT * FROM TMP_TABLE A JOIN TMP_TABLE_2 B ON A.AGE=B.AGE

UNION SELECT * FROM TMP_TABLE A LEFT JOIN TMP_TABLE_2 B ON A.AGE=B.AGE

UNION SELECT * FROM TMP_TABLE A RIGHT JOIN TMP_TABLE_2 B ON A.AGE=B.AGE;

2)Pig

tmp_table_full_join = JOIN tmp_table BY age FULL OUTER,tmp_table_2 BY age;

DUMP tmp_table_full_join;

12.同时对多张表交叉查询

1)Mysql

SELECT * FROM TMP_TABLE,TMP_TABLE_2;

2)Pig

tmp_table_cross = CROSS tmp_table,tmp_table_2;

DUMP tmp_table_cross;

13.分组GROUP BY

1)Mysql

SELECT * FROM TMP_TABLE GROUP BY IS_MALE;

2)Pig

tmp_table_group = GROUP tmp_table BY is_male;

DUMP tmp_table_group;

14.分组并统计

1)Mysql

SELECT IS_MALE,COUNT(*) FROM TMP_TABLE GROUP BY IS_MALE;

2)Pig

tmp_table_group_count = GROUP tmp_table BY is_male;

tmp_table_group_count = FOREACH tmp_table_group_count GENERATE group,COUNT($1);

DUMP tmp_table_group_count;

15.查询去重DISTINCT

1)MYSQL

SELECT DISTINCT IS_MALE FROM TMP_TABLE;

2)Pig

tmp_table_distinct = FOREACH tmp_table GENERATE is_male;

tmp_table_distinct = DISTINCT tmp_table_distinct;

DUMP tmp_table_distinct;

posted on 2017-04-16 10:33 大大的橙子阅读(759) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

大大的橙子

Hadoop Pig

Pig适用场景

附录：

执行Pig程序的方法

Pig与RDBMS、Hive比较

导航

公告