用Apache Pig处理大数据时，经常会有这种需求：把输入数据按指定的字段group，并且每个group内只输出时间最新的一条记录。

举个例子。有数据文件 input.txt ：

10      a       1,2,3
9       b       1,2
8       a       2,3,4
13      a       1,2,3,4
6       b       1

该数据的三个字段分别代表：time（时间戳），userId（用户id），userInterest（用户兴趣id）
现在，要找出每个用户时间最新的userInterest，应该怎么做？
即：对用户 a，最新的时间戳是13，userInterest是1,2,3,4；对用户 b，最新的时间戳是9，userInterest是1,2。
直接上代码：

A = LOAD 'input.txt' AS (time: long, userId: chararray, userInterest: chararray);
A = FOREACH A GENERATE time, userId, userInterest;
B = GROUP A BY userId;
-- 每个userId取时间最新的一条记录
C = FOREACH B {
    SORTED = ORDER A BY time DESC;
    ONE_RECORD = LIMIT SORTED 1;
    GENERATE FLATTEN(ONE_RECORD);
};
DUMP C;

在嵌套的FOREACH语句中，首先用ORDER BY对同一个group内的数据进行了降序排序，再用LIMIT取一条记录，由于是按time降序排序，因此LIMIT 1取到的就是时间戳最大的那条记录，即时间最新的记录。
输出：

(13,a,1,2,3,4)

(9,b,1,2)

可见这个结果和我们前面人工判断出来的正确结果一致。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

在Apache Pig中，怎样把 2023-10-11_10:57:56 这种格式的时间字符串，转成整型的时间戳？
话不多说，直接上代码。
假设输入数据文件 1.txt，其格式是一行一个时间字符串。

A = LOAD '1.txt' AS (dt: chararray);
A = FOREACH A GENERATE ToDate(dt, 'yyyy-MM-dd_HH:mm:ss') AS date;
B = FOREACH A GENERATE ToUnixTime(date) AS ts;
DUMP B;

输出结果形如：

1696993076

可见，这样得到的时间戳单位是“秒”。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

查看更多Apache Pig的教程请点击这里。

用Apache Pig加载/解析/读取XML数据不是一个常见的需求，但有时为了方便我们又不得不用，其实Pig的UDF库piggybank已经帮大家做好了这个工作了：只需要使用其中的XMLLoader，就可以方便地实现XML文件解析。

假设有如下XML文件：

<?xml version="1.0" encoding="UTF-8"?>

<users>
    <user>
        <profileUrl>http://www.codelast.com/user/profile/159.html</profileUrl>
        <data>
            <id>159</id>
            <name>李四</name>
        </data>
    </user>
    <user>
        <profileUrl>http://www.codelast.com/user/profile/220.html</profileUrl>
        <data>
            <id>220</id>
            <name>王五</name>
        </data>
    </user>

</users>

首先我们欣赏一下这个XML文件，它用于存储多个用户的信息，<users></users> 标签把所有用户信息包裹在里面，<user></user> 标签则对应一个用户的信息。在每一个用户信息中，不仅有 profileUrl 这种第一层的属性，还有 data/id，data/name 这种更深层的属性，我们在下面的代码中，会把这些字段全部提取出来。
这个XML虽然结构简单，但层次分明，通过解析这个XML文件，我们可以引申出对复杂XML文件的读取方法。
这里需要特别说明一下，通常情况下存储在磁盘上的大数据都不会是这种“格式化过”的数据格式（为了方便大家观看，我把XML格式化成了上面的样子），而是一种紧凑的格式，例如可能是下面这个样子：

<?xml version="1.0" encoding="UTF-8"?><users><user><profileUrl>http://www.codelast.com/user/profile/159.html</profileUrl><data><id>159</id><name>李四</name></data></user><user><profileUrl>http://www.codelast.com/user/profile/220.html</profileUrl><data><id>220</id><name>王五</name></data></user></users>

但是对piggybank的XMLLoader来说，上面的各种格式并不会影响它对XML内容的解析，这一点很好。
文章来源：https://www.codelast.com/
话不多说，直接上代码：

-- 注册piggybank的jar包，视实际情况修改此路径
REGISTER /xxx/piggybank.jar;

DEFINE XPath org.apache.pig.piggybank.evaluation.xml.XPath();

A = LOAD 'users.xml' USING org.apache.pig.piggybank.storage.XMLLoader('user') AS (x: chararray);
B = FOREACH A GENERATE XPath(x, 'user/profileUrl') AS profileUrl, XPath(x, 'user/data/id') AS id, XPath(x, 'user/data/name') AS name;
DUMP B;

代码解读：
➤ XMLLoader 的参数"user"，应该是你的XML文件中，有多个标签的那个名字，例如，在上面的XML中，含有多个 user，但是只有一个 users，所以我们这里填的应该是 user
➤ AS (x: chararray) 中的 "x" 其实可以是任意名称，我们下面只用这个名字来解析其下的字段，所以这个名字不重要。
➤ 在 XPath() 中我们可以通过XML的层级关系来取出指定的字段，一看就明白。
文章来源：https://www.codelast.com/
上面的代码输出：

(http://www.codelast.com/user/profile/159.html,159,李四)
(http://www.codelast.com/user/profile/220.html,220,王五)

也就是我们提取的3个字段。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

用Apache Pig进行数据处理的时候，我们通常会在最后把处理结果保存到一个HDFS目录下：

STORE result INTO '/my_output_dir';

这是最常见的情况。
但是，如果我们想根据某个字段，把数据分成多组，分别存储在多个目录下呢？举个可能不恰当的例子，就有点像我们先把数据按某个字段分组：

GROUP data BY field;

再把各个group的数据分别存储在不同的目录下一样。

现在来看一个实例。
假设有如下数据（用 tab 分隔的四列分别为：人员类型的id，人员类型的描述，姓名，爱好）：

文章来源：https://www.codelast.com/
现在我们想按第1列 type，把这份数据处理之后分别存储到不同的目录下，即 type 2（学生）的数据保存到目录"2"里，type 3（老师）的数据保存到目录"3"里，依此类推。
一个最简单也最笨的方法是： 在Pig中把数据 SPLIT(拆分) 成多份，再分别 STORE(存储) 到指定的目录下：

A = LOAD '1.txt' AS (type: int, desc: chararray, name: chararray, hobby: chararray);
SPLIT A INTO A1 IF (type == 1), A2 IF (type == 2), A3 IF (type == 3);

STORE A1 INTO '/my_output_dir/1';
STORE A2 INTO '/my_output_dir/2';
STORE A3 INTO '/my_output_dir/3';

代码很直观，但当 type 有太多种数值的时候，比如说type有100种数值，难道你打算写100个 STORE 语句吗？会疯。
文章来源：https://www.codelast.com/
更好的办法是利用piggybank里的一个UDF MultiStorage来实现同样的功能：

A = LOAD '1.txt' AS (type: int, desc: chararray, name: chararray, hobby: chararray);
STORE A INTO '/my_output_dir' USING org.apache.pig.piggybank.storage.MultiStorage('/my_output_dir', '0', 'none', '\t', 'true');

看，只要一行代码就代替了无数的 SPLIT INTO 以及 STORE INTO 语句，多么优雅。
MultiStorage的参数含义分别是：

public MultiStorage(String parentPathStr, String splitFieldIndex, String compression, String fieldDel, String isRemoveKeys)

parentPathStr：输出文件的父目录。事实上这个参数不起作用，真正起作用的输出路径是在 "INTO" 关键字后面的那个路径里指定的，但开发团队为了向前兼容，保留了这个参数，因此，把这个参数里的路径，设置成和 "INTO" 后面的路径一样即可。
splitFieldIndex：使用数据里的第几个字段来拆分数据存储到不同的子目录下（从0开始）。我这里设置成0，是表示我使用数据里的 type 字段来拆分数据。
compression：输出数据的压缩方式，可以是 'bz2'，'bz'，'gz'，'none'这几种取值，其中 none 表示无压缩。
fieldDel：输出数据多个字段的分隔符。
isRemoveKeys：输出数据是否移除掉用于拆分数据的字段。我这里设置成 true 表示在输出数据中不会包含 type，因为我只想拿 type 用作输出子目录名，不想让它出现在输出数据中。
文章来源：https://www.codelast.com/
最后我们看一下执行结果。生成了3个目录，每个 type 一个目录：

/my_output_dir/1
/my_output_dir/2
/my_output_dir/3
/my_output_dir/_SUCCESS

再来看一下子目录"1"里的文件：

/my_output_dir/1/1-0,000

其文件内容是：

保安    许勤    下棋
保安    涂欣    看书

这里面全是 type 1 的数据。可见 MultiStorage 确实把数据按照 type 拆分并存储在了不同的子目录下。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

查看更多Apache Pig的教程请点击这里。

在大数据处理领域，JSON格式的数据非常常见，然而用Apache Pig读取JSON并正确取出其中的字段我觉得并不算方便（在某些情况下很容易写错），所以总结一下几个常见的JSON loader/UDF的用法。

假设有数据文件 1.txt，内容是一行JSON（为了简单，这里以一行为例）：

{"items":[{"id":"111","name":"aaa","extra":{"k":"ttt","v":"uuu"}},{"id":"222","name":"bbb","extra":{"k":"rrr","v":"sss"}}]}

为了便于观看，这里把它格式化如下（注意，Pig是按行读取数据，这里格式化只是为了写这篇文章便于展示，实际存储在文件里仍然是一行）：

{
    "items": [
        {
            "id": "111",
            "name": "aaa",
            "extra": {
                "k": "ttt",
                "v": "uuu"
            }
        },
        {
            "id": "222",
            "name": "bbb",
            "extra": {
                "k": "rrr",
                "v": "sss"
            }
        }
    ]
}

我们的目的是正确解析这个JSON。

➤ 来自于Elephant Bird的 com.twitter.elephantbird.pig.piggybank.JsonStringToMap()
其实它不是一个JSON loader而是一个UDF，它的作用是把JSON字符串转成一个map。由于JSON结构中都是key:value形式的数据，所以把JSON字符串转成map之后就可以取出指定字段的内容。
这个UDF对于只有“一层”的JSON非常好用，例如（格式化后）长下面这个样子的JSON：

{
    "id": "111",
    "name": "aaa"
}

此时，可以像下面这样取到字段 id 及 name 的值：

DEFINE Json2Map com.twitter.elephantbird.pig.piggybank.JsonStringToMap();

A = LOAD '1.txt' AS (jsonStr: chararray);
B = FOREACH A GENERATE Json2Map(jsonStr) AS jsonObj;
C = FOREACH B GENERATE (chararray) jsonObj#'id' AS id, (chararray) jsonObj#'name' AS name;
DUMP C;

在这里，JSON被转成了一个map对象，用 #'id' 的方式可以取出名为 id 的key对应的value。
可见这个UDF在某些场合下用起来很方便，但对本文一开始举例的那种嵌套有多层的JSON就不好处理了。
文章来源：https://www.codelast.com/
➤ Pig内置的 JsonLoader
对付本文开头的那种JSON，我们可以使用Pig内置的 JsonLoader 来加载数据，使用它唯一的坏处就是需要定义JSON的结构：

A = LOAD '1.txt' USING JsonLoader('items: {(id:chararray, name:chararray, extra:(k:chararray, v:chararray))}');
B = FOREACH A GENERATE FLATTEN(items);
C = FOREACH B GENERATE id, name, FLATTEN(extra) AS (k, v);
D = FOREACH C GENERATE id, name, k, v;
DUMP D;

我们仔细看一下本文开头的JSON，它的 items 是一个数组，对应到Pig里就是一个bag（bag里的每个元素是一个tuple），因此用JsonLoader定义JSON的结构时，items 是 items: {()} 这样一种结构。
而JSON中的 extra 字段对应的并不是一个数组，所以它对应到Pig里就是一个tuple，因此在JsonLoader中定义结构时 extra 是 extra:(k:chararray, v:chararray) 这样的形式。
文章来源：https://www.codelast.com/
注意：JsonLoader看似好用，然而这里有一个巨坑——JsonLoader中定义的字段名和JSON字符串中的字段名并不对应，它只跟顺序相关！
例如，你代码这样写：

A = LOAD '1.txt' USING JsonLoader('items: {(id:chararray, invalidField:chararray, extra:(k:chararray, v:chararray))}');
B = FOREACH A GENERATE FLATTEN(items);
C = FOREACH B GENERATE id, invalidField, FLATTEN(extra) AS (k, v);
D = FOREACH C GENERATE id, invalidField, k, v;
DUMP D;

竟然能正确输出：

(111,aaa,ttt,uuu)

(222,bbb,rrr,sss)

在上面的代码中，invalidField 是一个在JSON字符串中根本不存在的字段名，然而它却能被JsonLoader正确识别，那是因为JsonLoader是按字段的顺序来识别的，JSON字符串中的第2个字段 name，被JsonLoader映射到了 invalidField 这个字段上。
也正是因为这个原因，如果你的JSON字符串的各个字段顺序是不恒定的，就不能用这种方法来读取！
并且，在JsonLoader中定义JSON的结构时要非常小心，如果不小心写错了顺序，那么肯定会得到错误的值，例如，你这样写：

A = LOAD '1.txt' USING JsonLoader('items: {(name:chararray, id:chararray, extra:(k:chararray, v:chararray))}');

你以为JsonLoader会自动把JSON字符串中的 id 字段映射到你定义的第二个字段（id:chararray）上吗？根本不会！它会把它映射到 name:chararray 上，因为在JSON字符串中，id 字段是排在第1位的字段，而在JsonLoader中，name:chararray 也是排第1位的字段，因此它俩就映射上了。
所以，如果你有JSON数据的控制权，我建议在生成JSON数据的时候，固定生成字段的顺序。例如，如果是使用 Jackson的ObjectMapper生成JSON，那么可以通过 @JsonPropertyOrder 标注来控制JSON字段的顺序。
另外，如果你定义的结构中漏了一个字段，很可能会造成解析不成功，导致程序逻辑不能按设想的执行！

最后，这仅仅是一个嵌套层数非常少的JSON，如果层数非常多的话，会导致你代码很难写，这个时候还是用JAVA写Map-Reduce job去处理吧。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

来看这个例子。有数据文件 1.txt，内容为：

a[\t][\t]c

[\t]f[\t]g

h[\t]k[\t]
[\t][\t][\t]

A = LOAD '1.txt' AS (col1: chararray, col2: chararray, col3: chararray);
B = FOREACH A GENERATE (col1 IS NOT NULL ? col1 : '1') AS col1, (col2 IS NOT NULL ? col2 : '2') AS col2, (col3 IS NOT NULL ? col3 : '3') AS col3;
DUMP B;

A = LOAD '1.txt' AS (col1: chararray, col2: chararray, col3: chararray);
B = FOREACH A GENERATE (col1 IS NOT NULL ? col1 : (col2 IS NOT NULL ? col2 : (col3 IS NOT NULL ? col3 : '888'))) AS col;
DUMP B;

Apache DataFu™是用于在Hadoop中处理大规模数据的库的集合。

返回一个元组(tuple)的第一个非空值，就像SQL中的Coalesce一样。

DEFINE Coalesce datafu.pig.util.Coalesce();

A = LOAD '1.txt' AS (col1: chararray, col2: chararray, col3: chararray);
B = FOREACH A GENERATE Coalesce(col1, '1') AS col1, Coalesce(col2, '2') AS col2, Coalesce(col3, '3') AS col3;
DUMP B;

DEFINE Coalesce datafu.pig.util.Coalesce();

A = LOAD '1.txt' AS (col1: chararray, col2: chararray, col3: chararray);
B = FOREACH A GENERATE Coalesce(col1, col2, col3, '888') AS col;
DUMP B;

如果一个Pig job是map-only的job，并且其输入文件数很多的话，那么输出的文件数也会同样多，此时，如果每个文件大小又比较小的话，长久下去就会对Haodoop NameNode造成很大压力。我们可以通过给Pig job添加一个reduce过程来减少输出文件数。

话不多说，直接上代码：

D = LOAD '/user/abc/xxx' AS (col1: long, col2: chararray);  
E = FOREACH (GROUP D BY RANDOM() PARALLEL 100) GENERATE FLATTEN(D); 

文章来源：https://www.codelast.com/
其中：
加载到D里的数据就是文件数量巨大，并且每个文件大小都比较小的一份数据。
PARALLEL后的100可以视情况更改，设置为100则输出文件数为100。
这里的实现逻辑是：添加一个reduce过程，其shuffle key是由Pig的 RANDOM() 函数生成的一个随机数，因此不会出现让大量数据聚集在同一个reducer里的情况，这样做是试图使输出数据尽可能均匀地分布在100个输出文件里。

但实际上你会发现，实际输出的文件大小并不均衡，比如有些300多MB大，有些只有100多MB大，这是因为 RANDOM() 函数输出的是一个 [0.0, 1.0) 范围内的数，这个小数作为shuffle key的话，很难说会有什么后果，因此我们把它放大1000倍再转为int，就可以避免这个问题，真正让输出数据的大小很平均：

 E = FOREACH (GROUP D BY ((int) (RANDOM() * 1000)) PARALLEL 100) GENERATE FLATTEN(D); 

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

运行Pig脚本时报错：

Error before Pig is launched
----------------------------
ERROR 2997: Encountered IOException. org.apache.pig.tools.parameters.ParseException: Encountered "<EOF>" at line 1, column 8.
Was expecting one of:
    <IDENTIFIER> ...
    <OTHER> ...
    <LITERAL> ...
    <SHELLCMD> ...
java.io.IOException: org.apache.pig.tools.parameters.ParseException: Encountered "<EOF>" at line 1, column 8.
Was expecting one of:
    <IDENTIFIER> ...
    <OTHER> ...
    <LITERAL> ...
    <SHELLCMD> ...

        at org.apache.pig.impl.PigContext.doParamSubstitution(PigContext.java:408)
        at org.apache.pig.Main.runParamPreprocessor(Main.java:783)
        at org.apache.pig.Main.run(Main.java:446)
        at org.apache.pig.Main.main(Main.java:158)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:497)
        at org.apache.hadoop.util.RunJar.run(RunJar.java:221)
        at org.apache.hadoop.util.RunJar.main(RunJar.java:136)
Caused by: org.apache.pig.tools.parameters.ParseException: Encountered "<EOF>" at line 1, column 8.

In Pig Latin, how to check if an element is present in a bag?

假设一个bag是由 int 元素组成的（可以理解为一个list），那么，如何判断这个bag中是否包含指定的元素（例如 5）呢？
如果你看过Pig的doc，就知道它并没有自带这样一个函数，可以输入一个bag，以及另一个值作为参数，然后输出1或0来表示bag是否包含这个元素。
所以，我们该如何实现这个功能？

现在我就以一个实际的例子来说明这个问题。
假设我们有数据文件 1.txt：

[codelast@ ~]$ cat 1.txt 
a    {(1),(2),(3),(5),(6)}
b    {(1)}
c    {(1),(2)}
d    {(1),(3),(5)}
3    {(1),(2),(5),(6)}

一共有两列，用 \t 分隔。其中，第一列是一个字符串，第二列样子很怪，它之所以写成那样，是为了可以在Pig读入的时候直接加载为一个bag，在这里，你可以把第二列理解为一个list，以第一行为例，这个list包含的元素就是1、2、3、5、6。
如果我想判断每一行数据的第二列中，是否包含 5 这个元素，代码该怎么写？
文章来源：http://www.codelast.com/

• 方法一

我们不妨直接来看看正确的实现方法：

A = LOAD '1.txt' AS (name: chararray, aList:bag{(item:int)});
B = FOREACH A {
  FILTERED_LIST = FILTER aList BY ($0 == 5);
  GENERATE
  (IsEmpty(FILTERED_LIST) ? 'not-contain' : 'contain') AS flag,
  name;
}
DUMP B;

这段Pig代码的输出是：

(contain,a)

(not-contain,b)

(not-contain,c)

(contain,d)

(contain,e)

可以看到，第一行（a）是contain（包含5），第二行（b）是not-contain（不包含5），第三行（c）是not-contain（不包含5），等等。
从输入数据上我们可以很容易地判断出来，这个输出结果是完全正确的。所以，上面的Pig代码是怎么做到的呢？
且听我一行行分析下来。
文章来源：http://www.codelast.com/
第1行是加载数据， aList:bag{(item:int)} 这个形式有点怪，但它是由我们的输入数据 1.txt 里的格式决定的，这样做我们就能把第二列加载成一个bag，这个bag里有N个tuple，每个tuple里有一个int元素。
第2到第7行是用了一个嵌套的FOREACH来实现“判断一个bag中是否包含指定元素”的功能，这一句：

FILTERED_LIST = FILTER aList BY ($0 == 5);

会先filter得到包含 5 这个元素的bag，然后下面的这一句：

(IsEmpty(FILTERED_LIST) ? 'not-contain' : 'contain') AS flag,

会根根据filter得到的bag是否为空，来输出一个字符串，表示当前数据行是“不包含”还是“包含”指定的元素5。
但我觉得有很多人一定有疑问：为什么 FILTER 那一句可以得到包含5的bag？ $0 == 5 是个什么鬼？其实，这就是查找“包含5的bag”，千万不要认为 $0 只表示bag的第一个元素！大家可以看看这个Pig文档，然而它里面也没有对 $0 做具体的解释，大家就强行理解一下吧。
所有又有人会问，那我能不能不用嵌套的FOREACH，直接像下面这样：

B = FILTER A BY (aList.$0 == 5);

来得到那些包含5的记录呢？答案是不行，这样写语法都是错的，一试便知。
关于方法一，大家也可以参考这个stackoverflow的讨论（但它里面其实是有一些错误的）。
文章来源：http://www.codelast.com/

• 方法二

方法一会让第一次接触的同学有些费解。那么方法二就非常直接明了了。思路是：把bag FLATTEN（展开）出来，每一行数据展开成N行，然后第二列就变成了一个标量（int），就可以不用嵌套的FOREACH，也可以FILTER出来包含5的记录：

A = LOAD '1.txt' AS (name: chararray, aList:bag{(item:int)});
B = FOREACH A GENERATE name, FLATTEN(aList) AS item;
C = FILTER B BY (item == 5);
DUMP C;

输出结果：

(a,5)

(d,5)

(e,5)

可见结果是正确的。这里输出的只是bag中包含5的那些记录，如果要找到不包含5的那些记录，可以拿这个输出结果与原始数据做OUTER JOIN，但这显然比方法一麻烦，而且事实上它也不如方法一高效。所以，可以这么说，这算是“看上去很容易理解”的代价吧。
文章来源：http://www.codelast.com/

• 方法三

所以有没有一种方法，它既写起来简单，看起来又容易理解呢？那就是用UDF啦。但UDF终归还是要自己写的，这个工作量我们没有把它计算在内，所以，这算是方法三的劣势。

假设我们要编写的UDF名为BagContains，它接受两个参数，第一个参数是bag，第二个参数是我们要在bag中查找的值（例如5），当bag中包含指定元素时返回1，否则返回0。
根据这个定义，我们来看看UDF的用法：

REGISTER '/home/codelast/my-pig-lib.jar';

DEFINE BagContains com.codelast.BagContains();

A = LOAD '1.txt' AS (name: chararray, aList:bag{(item:int)});
B = FOREACH A GENERATE name, ((BagContains(aList, 5) == 1) ? 'contain' : 'not-contain') AS flag;
DUMP B;

其中，REGISTER 那行引入的jar包，是我编写的UDF编译生成的jar包的路径。
这段代码的输出结果：

(a,contain)

(b,not-contain)

(c,not-contain)

(d,contain)

(e,contain)

一言不合直接上UDF的代码：

package com.codelast;

import org.apache.pig.EvalFunc;
import org.apache.pig.data.DataBag;
import org.apache.pig.data.DataType;
import org.apache.pig.data.Tuple;

import java.io.IOException;

/**
 * Check whether a list contains a specified item.
 * Usage: suppose aList is a bag contains int items, then
 * ContainsItem(aList, 5)
 * will return 1(the list contains 5) or 0(the list doesn't contains 5)
 *
 * @author Darran Zhang @ codelast.com
 */
public class BagContains extends EvalFunc<Integer> {
  @Override
  public Integer exec(Tuple input) throws IOException {
    if (input == null || input.size() == 0 || input.get(0) == null) {
      return null;
    }
    DataBag inputBag = DataType.toBag(input.get(0));
    int item2Find = DataType.toInteger(input.get(1));
    for (Tuple entry : inputBag) {
      int item = DataType.toInteger(entry.get(0));
      if (item == item2Find) {
        return 1;
      }
    }
    return 0;
  }
}

在这里，我就不解释每一行代码了，Pig UDF（JAVA）的编写有一个比较类似的套路，很多简单的UDF都可以用上面的格式稍微改改得到。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

SequenceFile是Hadoop API提供的一种二进制文件，它将数据以<key,value>的形式序列化到文件中。

A = LOAD 'xxx' USING com.twitter.elephantbird.pig.load.SequenceFileLoader(
 '-c com.codelast.elephantbird.pig.util.BooleanWritableConverter',
 '-c com.twitter.elephantbird.pig.util.ThriftWritableConverter com.codelast.MyThriftClass');

STORE B INTO 'xxx' USING com.twitter.elephantbird.pig.store.SequenceFileStorage(
 '-c com.codelast.elephantbird.pig.util.BooleanWritableConverter',
 '-c com.twitter.elephantbird.pig.util.ThriftWritableConverter com.codelast.MyThriftClass');

SET output.compression.enabled 'true';
SET mapreduce.output.fileoutputformat.compress.type 'BLOCK';
SET output.compression.codec 'org.apache.hadoop.io.compress.DefaultCodec';

 LIMIT操作并不会减少读入的数据量
如果你只需要输出一个小数据集，通常你可以使用LIMIT来实现，例如：

A = LOAD '1.txt' AS (col1: int, col2: chararray);
B = LIMIT A 5;
DUMP B;

Pig会只加载5条记录，就不再读取其他的记录了吗？答案是：不会。Pig将读取数据文件中的所有记录，然后再从中挑5条。这是Pig可以做优化、却没有做的一点。
【更新】Pig 0.10已经有了这功能了：

Push Limit into Loader

Pig optimizes limit query by pushing limit automatically to the loader, thus requiring only a fraction of the entire input to be scanned.

文章来源：http://www.codelast.com/
 使用UDF不一定要在Pig脚本中REGISTER，也可以在命令行指定
大家知道，使用UDF需要在Pig脚本中REGISTER该UDF的jar包，但你可能不知道，你也可以不在Pig脚本中REGISTER它，而是通过命令行指定：

pig -Dpig.additional.jars=/home/codelast/a.jar:/home/codelast/b.jar:/home/codelast/c.jar test.pig

以上命令告诉了我们几件事：
①我们让Pig执行了test.pig脚本；
②我们向Pig传入了“pig.additional.jars”这样一个参数，此参数的作用相当于在Pig脚本中REGISTER jar包；
③如果你要REGISTER多个jar包，只需像上面的例子一样，用分号(:)把多个jar包路径隔开即可；
④test.pig必须写在最后，而不能写成“pig test.pig -Dpig.additional.jars=XXX”这样，否则Pig直接报错：

ERROR 2999: Unexpected internal error. Encountered unexpected arguments on command line - please check the command line.

当然，为了可维护性好，你最好把REGISTER jar包写在Pig脚本中，不要通过命令行传入。

 使用ORDER排序时，null会比所有值都小
用ORDER按一个字段排序，如果该字段的所有值中有null，那么null会比其他值都小。

 如何按指定的几个字段来去重
去重，即去除重复的记录。通常，我们使用DISTINCT来去除整行重复的记录，但是，如果我们只想用几个字段来去重，怎么做？
假设有以下数据文件：

[root@localhost ~]$ cat 1.txt 
1    2   3   4   uoip
1    2   3   4   jklm
9    7   5   3   sdfa
8    8   8   8   dddd
9    7   5   3   qqqq
8    8   8   8   sfew

我们要按第1、2、3、4个字段来去重，也就是说，去重结果应为：

1    2   3   4   uoip
9    7   5   3   sdfa
8    8   8   8   dddd

那么，我们可以这样做：

A = LOAD '1.txt' AS (col1: chararray, col2: chararray, col3: chararray, col4: chararray, col5: chararray);
B = GROUP A BY (col1, col2, col3, col4);
C = FOREACH B {
    D = LIMIT A 1;
    GENERATE FLATTEN(D);
};
DUMP C;

文章来源：http://www.codelast.com/
输出结果为：

(1,2,3,4,uoip)
(8,8,8,8,dddd)
(9,7,5,3,sdfa)

代码很简单，就是利用了GROUP时会自动对group的key去重的功能，这里不用多解释大家应该也能看懂。

 如何设置Pig job的名字，使得在Hadoop jobtracker中可以清晰地识别出来
在Pig脚本中的一开始处，写上这一句：

set job.name 'This is my job';

将使得Pig job name被设置为“This is my job”，从而在Hadoop jobtracker的web界面中可以很容易地找到你的job。如果不设置的话，其名字将显示为“PigLatin:DefaultJobName”。

 “scalar has more than one row in the output”错误的一个原因
遇到了这个错误？我来演示一下如何复现这个错误。
假设有两个文件：

[root@localhost ~]$ cat a.txt 
1    2
3    4
[root@localhost ~]$ cat b.txt 
3    4
5    6

现在我们来做一个JOIN：

A = LOAD 'a.txt' AS (col1: int, col2: int);
B = LOAD 'b.txt' AS (col1: int, col2: int);
C = JOIN A BY col1, B BY col1;
D = FOREACH C GENERATE A.col1;
DUMP D;

这段代码是必然会fail的，错误提示为：

org.apache.pig.backend.executionengine.ExecException: ERROR 0: Scalar has more than one row in the output. 1st : (1,2), 2nd :(3,4)

文章来源：http://www.codelast.com/
乍一看，似乎代码简单得一点问题都没有啊？其实仔细一看，“A.col1”的写法根本就是错误的，应该写成“A::col1”才对，因为你只要 DESCRIBE 一下 C 的schema就明白了：

C: {A::col1: int,A::col2: int,B::col1: int,B::col2: int}

Pig的这个错误提示得很不直观，在这个链接中也有人提到过了。

 如何输出LZO压缩格式的文本文件
借助于elephant-bird，可以轻易完成这个工作。
方法1:

A ＝LOAD 'input';
STORE A INTO 'output' USING com.twitter.elephantbird.pig.store.LzoPigStorage();

结果就会得到一堆名称类似于“part-m-00000.lzo”的文件。
注意以上省略了一堆的“REGISTER XXX.jar”代码，你需要自己添加上你的jar包路径。
方法2：
在Pig脚本的最前面添加两句话：

set mapred.output.compression.codec 'com.hadoop.compression.lzo.LzopCodec';
set mapred.output.compress 'true';

STORE的时候（不需要USING...）会自动将文件保存为LZO格式。
文章来源：http://www.codelast.com/
有人说，那加载LZO压缩的文本文件呢？很简单：

A = LOAD 'output' USING com.twitter.elephantbird.pig.store.LzoPigStorage(',');

这表示指定了分隔符为逗号，如果不想指定，省略括号中的内容即可。

 如何输出 gz 及 bz2 压缩格式的文件
首先请看这个链接的说明。摘录一段话：

Compression

 

Storing to a directory whose name ends in ".bz2" or ".gz" or ".lzo" (if you have installed support for LZO compression in Hadoop) will automatically use the corresponding compression codec.

output.compression.enabled and output.compression.codec job properties also work.

Loading from directories ending in .bz2 or .bz works automatically; other compression formats are not auto-detected on loading.

--压缩率稍低
A = LOAD '1.txt';
STORE A INTO 'z.gz';

--压缩率较高
A = LOAD '1.txt';
STORE A INTO 'z.bz2';

如果是 bz2，则后缀名为 .bz2。

有人可能觉得这种通过目录名实现的方式不直观，那么你也可以在Pig脚本中指定输入文件的压缩格式。下面的例子演示了如何输出gzip格式的压缩文件（此时，目录名就不用以.gz结尾了）：

set output.compression.enabled true;
set output.compression.codec org.apache.hadoop.io.compress.GzipCodec;

文章来源：http://www.codelast.com/
 类似于Java字符串的contains方法，在Pig中怎么做
例如，要判断一个字符串“abc”是否包含“bc”，怎么做？
有一个方法，利用Pig内置的INDEXOF函数来实现：

INDEXOF(string, 'character', startIndex)

string: The string to be searched.

'character': The character being searched for, in quotes.

startIndex: The index from which to begin the forward search. The string index begins with zero (0).

[root@localhost] ~$ cat a.txt 
abc    123

Pig脚本：

A = LOAD 'a.txt' AS (col1: chararray, col2: chararray);
B = FOREACH A GENERATE INDEXOF(col1, 'abc', 0), INDEXOF(col2, '9', 0);
DUMP B;

输出结果：

(0,-1)

可见，查不到的字符串，其返回值为-1。

 类型为long的字段做FILTER的时候，数字没有加“L”可能会导致结果错误！
我遇到的一个真实问题，下面的代码：

A = LOAD '/path/to/my/data' USING MyLOADER;
B = FILTER A BY (fieldId == 3125694275663397348L OR fieldId == 3125694275741155094L);

对LOAD进来的数据进行了一个简单的FILTER，其中，fieldId 是一个类型为 long 的字段，这样写没有任何问题。但是如果把FILTER条件里的数字后面的“L”去掉，Pig不会报错，但FILTER语句可能就会失效。所以在写字面数字的时候，一定要为long类型后面加上“L”！

 加载Sequence file不能当作纯文本文件来加载
假设Sequence file是 TAB制表符 分隔的两列数据，正确加载它可以这样写：

A = LOAD 'xxx' USING com.twitter.elephantbird.pig.load.SequenceFileLoader();
-- SequenceFileLoader加载出来的数据，自动会加上schema：{key: chararray,value: chararray}
B = FOREACH A GENERATE key AS col1, value AS col2;
C = LIMIT B 10;
DUMP C;

如果你把它当作未压缩的纯文本文件来加载（不使用USING XXX），则会发现job不报错，但实际上读出来的数据都是乱码。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

Apache Pig是用来处理大规模数据的高级查询语言，配合Hadoop使用，可以在处理海量数据时达到事半功倍的效果，比使用Java，C++等语言编写大规模数据处理程序的难度要小N倍，实现同样的效果的代码量也小N倍。

本文基于以下环境：
pig 0.8.1
文章来源：http://www.codelast.com/
（1）CROSS操作
由于求交叉积可能会导致结果数据量暴增，因此，CROSS操作是一个“昂贵”的操作，可能会耗费Hadoop集群较多的资源，使用的时候需要评估一下数据量的大小。

（2）JOIN操作的顺序
如教程《Apache Pig中文教程（进阶）》中的第(6)条所写，当JOIN的各数据集分布严重不均时，你最好考虑一下JOIN的顺序，可以对你的job效率提升有帮助。

（3）FLATTEN一个空的bag将不会输出任何结果

[root@localhost ~]$ cat 1.txt
1    2   {(a,b),(c,d)}
77    88  {(p,q),(r,s)}
123    555 {(u,w),(q,t)}

有三列，它们之间是以TAB分隔的。
以下代码：

A = LOAD '1.txt' AS (col1: int, col2: int, col3: bag{t: (first: chararray, second: chararray)});
B = FOREACH A GENERATE col1, col2, FLATTEN(col3);
DUMP B;

得到的结果是显而易见的：

(1,2,a,b)
(1,2,c,d)
(77,88,p,q)
(77,88,r,s)
(123,555,u,w)
(123,555,q,t)

可见记录被解嵌套了。
但是，如果第三列的bag是空的：

[root@localhost ~]$ cat 1.txt
1    2   {}
77    88  {}
123    555 {}

那么，与上面同样的代码将什么也不会输出（你可以自己试验一下）。
这一点需要特别注意，所以一般来说，你在FLATTEN一个bag之前，需要判断一下它是否是空的（IsEmpty），如果你需要在FLATTEN的结果中标记空的那些bag，那么你就需要自己在FLATTEN之前将空的bag替换为自己指定的内容。

（4）SAMPLE的结果数量是不确定的
SAMPLE操作符可以对一个关系（relation）进行取样，得到其一定百分比的数据（例如随机取其中10%的数据），但是，这并不保证对同一个relation进行同样比例的SAMPLE，得到的tuple的数量就是相同的。例如，对一个有千万行的数据集，SAMPLE 0.1的结果，可能第一次会得到100万行，重做一次却得到了101万行（这里只是举一个例子，具体的数字是未知的）。
我的试验结果可以肯定地告诉大家：我拿一个含上亿条记录的数据集SAMPLE 0.1两次的结果相差了4万多条记录（指的是数据条数）。

（5）输出几个简单数据的job，没必要单独跑，使用UNION整合在一个Pig脚本中即可
假设有几个Pig job，它们输出的都是一行数据（当然，一行可能有多列），那么没必要单独跑几个job再得到所有结果，你可以用UNION把它们整合放在一个Pig脚本中，例如：

A1 = LOAD '1.txt' AS (col: chararray);
A2 = LOAD 'a.txt' AS (col: chararray);
A2 = LOAD 'P.txt' AS (col: chararray);

B1 = GROUP A1 ALL;
C1 = FOREACH B1 GENERATE COUNT(A1);

B2 = GROUP A2 ALL;
C2 = FOREACH B2 GENERATE COUNT(A2);

B3 = GROUP A3 ALL;
C3 = FOREACH B3 GENERATE COUNT(A3);

U = UNION C1, C2, C3;

STORE U INTO 'res';

有人说，为什么不把A1，A2，A3使用通配符一起加载？答：这里我假设了一种非常简单的情况：三个数据文件都只有一列，而实际中，可能三个文件完全有不同的格式，而且后面的处理针对每个job也是不同的（在这里为简单起见才写成相同的），因此，单独加载有时候是必要的。
这样做之后，会输出3个文件，每个文件中有一个数。比跑3个Pig job方便。
文章来源：http://www.codelast.com/
（6）用ORDER排序时，Pig并不遵守“相同的key的记录会被发送到同一个partition”的惯例
处理海量数据时，我们常常会遇到这样一种情况：某些key的数据远远多于其他key的数据。例如，我们要分析用户的web访问日志，会发现用户访问Google的次数远远多于其他网站的次数。
所以，如果我们要按“访问的网站”这个字段来GROUP或者ORDER的话，就会造成落入某些reducer的数据远远多于其他reducer（GROUP、ORDER都会触发reduce过程）——注意，这里说“某些reducer”，是因为在这个例子中，不仅访问Google是个大户，可能还有其他的网站访问大户。
由于这些reducer需要处理的数据量特别大，也就会导致所需的时间特别长，从而整个job所需的总时间特别长。为了解决这一弊端，Pig使用了一种聪明的方法：先对需要ORDER的数据进行采样，获知其key分布情况，然后根据此分布构造一个可以均衡全体数据的partitioner，从而将数据比较均匀地送到N个reducer上。Pig的这种算法是很有效的，它使得各个reducer之间的执行时间相差不大。
正因为Pig做了这样的工作，所以，前面例子中所说的对Google的访问记录可能会被送到多个reducer中，它们有相同的key，却没有被送到同一reducer中，这没有遵守MapReduce的惯例。如果你的数据处理流程需要遵守此惯例，那么就不能用Pig的ORDER来排序。
同时，正因为Pig在ORDER时需要对输入数据进行采样，所以，ORDER的时候Pig会为你的数据流程添加一个额外的轻量job来完成采样工作——从Pig在控制台输出的信息中，你可以看到一个Feature为“SAMPLER”的job，这个job就是采样用的。

（7）关系操作符(Relational Operator)只能对关系(relation)进行操作，而不能对表达式(expression)进行操作吗？
有人说，从这一句的陈述来看，它根本就是废话——关系操作符当然是操作关系的啊！
不过，答案是：不一定。例如，DISTINCT 是一个关系操作符，但是它却可以对表达式进行操作！
我拿一个例子来说明这个问题。有以下数据文件：

[root@localhost ~]$ cat 1.txt 
1    2   3
2    5   3
2    6   7
8    6   3
1    5   7

有以下Pig代码（没什么计算上的意义，就是为了演示用）：

A = LOAD '1.txt' AS (col1: int, col2: int, col3: int);
B = GROUP A BY col3;
C = FOREACH B {
    E = DISTINCT A.col3;
    GENERATE group, COUNT(E);
};
DUMP C;

完全可以成功执行，结果为：

(3,1)
(7,1)

A = LOAD '1.txt' AS (col1: int, col2: int, col3: int);
B = GROUP A BY col3;
C = FOREACH B {
    D = A.col3;
    E = DISTINCT D;
    GENERATE group, COUNT(E);
};
DUMP C;

这段代码确实没有错误，它先通过 A.col3 这个表达式，生成了一个关系(relation) D，再将 DISTINCT 关系操作符应用于其上，这样就避开了所谓的“关系操作符只能操作关系”的限制。但事实上，我们完全没有必要这样做，正如上面的代码的试验结果，你完全可以直接用 DISTINCT A.col3，并不会出错。
所以说，书本也有坑爹的时候，不可全信。

（8）嵌套的 FOREACH 中的代码是串行执行的
嵌套的 FOREACH 语句可以完成复杂的操作，例如在嵌套的 FOREACH 中对bag进行排序等。FOREACH会被并行执行，但是对嵌套在其中的子语句来说，它们却是串行执行的。

（9）PARALLEL只对强制产生reduce过程的操作符有效
通过PARALLEL，你可以控制Pig程序的并行度（说白了就是控制reducer的数量）。PARALLEL可以附加在任何关系操作符上，但是它只对reduce端的并行度起控制作用，因为MapReduce不允许用户自己控制map端的并行度，它只允许用户控制reduce端的并行度，所以，这就是PARALLEL只对强制产生reduce过程的操作符有效的原因了。
另外，在本地模式（pig -x local）下，PARALLEL是不起任何作用的（被忽略），因为在本地模式下所有操作都是串行执行的。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

Apache Pig是用来处理大规模数据的高级查询语言，配合Hadoop使用，可以在处理海量数据时达到事半功倍的效果，比使用Java，C++等语言编写大规模数据处理程序的难度要小N倍，实现同样的效果的代码量也小N倍。

本文基于以下环境：
pig 0.8.1
文章来源：http://www.codelast.com/
如何编写及使用自定义函数（UDF）
首先给出一个链接：Pig 0.8.1 API，还有Pig UDF Manual。这两个文档能提供很多有用的参考。
自定义函数有何用？这里以一个极其简单的例子来说明一下。
假设你有如下数据：

[root@localhost pig]$ cat a.txt 
uidk    12  3
hfd    132 99
bbN    463 231
UFD    13  10

现在你要将第二列的值先+500，再-300，然后再÷2.6，那么我们可以这样写：

grunt> A = LOAD 'a.txt' AS(col1:chararray, col2:double, col3:int);
grunt> B = FOREACH A GENERATE col1, (col2 + 500 - 300)/2.6, col3;
grunt> DUMP B;
(uidk,81.53846153846153,3)
(hfd,127.6923076923077,99)
(bbN,255.0,231)
(UFD,81.92307692307692,10)

我们看到，对第二列进行了 (col2 + 500 - 300)/2.6 这样的计算。麻烦不？或许这点小意思没什么。但是，如果有比这复杂得多的处理，每次你需要输入多少pig代码呢？我们希望有这样一个函数，可以让第二行pig代码简化如下：

grunt> B = FOREACH A GENERATE col1, com.codelast.MyUDF(col2), col3;

这样的话，对于我们经常使用的操作，岂不是很方便？
pig的UDF（user-defined function）就是拿来做这个的。
文章来源：http://www.codelast.com/
下面，就以IntelliJ这个IDE为例（其实用什么IDE倒无所谓，大同小异吧），说明我们如何实现这样一个功能。
①新建一个新工程，在工程下创建“lib”目录，然后把pig安装包中的“pig-0.8.1-core.jar”文件放置到此lib目录下，然后在“Project Structure→Libraries”下添加（点击“+”号）一个库，就命名为“lib”，然后点击右侧的“Attach Classes”按钮，选择pig-0.8.1-core.jar文件，再点击下方的“Apply”按钮应用此更改。这样做之后，你就可以在IDE的编辑器中实现输入代码时看到智能提示了。
此外，你还需要用同样的方法，将一堆Hadoop的jar包添加到工程中，包括以下文件：

hadoop-XXX-ant.jar
hadoop-XXX-core.jar
hadoop-XXX-examples.jar
hadoop-XXX-test.jar
hadoop-XXX-tools.jar

其中，XXX是版本号。
如果没有这些文件，你在编译jar包的时候会报错。
文章来源：http://www.codelast.com/
②跟我一起，在工程目录下的 src/com/coldelast/ 目录下创建Java源代码文件 MyUDF.java，其内容如下：

package com.codelast;

import java.io.IOException;

import org.apache.pig.EvalFunc;
import org.apache.pig.data.Tuple;

/**
 * Author: Darran Zhang @ codelast.com
 * Date: 2011-09-29
 */

public class MyUDF extends EvalFunc<Double> {

  @Override
  public Double exec(Tuple input) throws IOException {
    if (input == null || input.size() == 0) {
      return null;
    }

    try {
      Double val = (Double) input.get(0);
      val = (val + 500 - 300) / 2.6;
      return val;
    } catch (Exception e) {
      throw new IOException(e.getMessage());
    }
  }
}

在上面的代码中，input.get(0)是获取UDF的第一个参数（可以向UDF传入多个参数）；同理，如果你的UDF接受两个参数（例如一个求和的UDF），那么input.get(1)可以取到第二个参数。
然后编写build.xml（相当于C++里面的Makefile），用ant来编译、打包此工程——这里就不把冗长的build.xml写上来了，而且这也不是关键，没有太多意义。
文章来源：http://www.codelast.com/
③假定编译、打包得到的jar包名为cl.jar，我们到这里几乎已经完成了大部分工作。下面就看看如何在pig中调用我们刚编写的自定义函数了。

grunt> REGISTER cl.jar;
grunt> A = LOAD 'a.txt' AS(col1:chararray, col2:double, col3:int);    
grunt> B = FOREACH A GENERATE col1, com.codelast.MyUDF(col2), col3;
grunt> DUMP B;
(uidk,81.53846153846153,3)
(hfd,127.6923076923077,99)
(bbN,255.0,231)
(UFD,81.92307692307692,10)

注：第一句是注册你编写的UDF，使用前必须先注册。
从结果可见，我们实现了预定的效果。
UDF大有用途！
注意：对如果你的UDF返回一个标量类型（类似于我上面的例子），那么pig就可以使用反射（reflection）来识别出返回类型。如果你的UDF返回的是一个包（bag）或一个元组（tuple），并且你希望pig能理解包（bag）或元组（tuple）的内容的话，那么你就要实现outputSchema方法，否则后果很不好。具体可看这个链接的说明。

 怎样自己写一个UDF中的加载函数(load function)
①加载函数(load function)是干什么的？
先举一个很简单的例子，来说明load function的作用。
假设有如下数据：

[root@localhost pig]# cat a.txt
1,2,3
a,b,c
9,5,7

我们知道，pig默认是以tab作为分隔符来加载数据的，所以，如果你没有指定分隔符的话，将使得每一行都被认为只有一个字段：

grunt> B = FOREACH A GENERATE $0;
grunt> DUMP B;
(1,2,3)
(a,b,c)
(9,5,7)

而我们想要以逗号作为分隔符，则应该使用pig内置函数PigStorage：

A = LOAD 'a.txt' using PigStorage(',');

这样的话，我们再用上面的方法DUMP B，得到的结果就是：

(1)
(a)
(9)

这个例子实在太简单了，在这里，PigStorage这个函数就是一个加载函数(load function)。
定义：

Load/Store Functions

 

These user-defined functions control how data goes into Pig and comes out of Pig. Often, the same function handles both input and output but that does not have to be the case.

即：加载函数定义了数据如何流入和流出pig。一般来说，同一函数即处理输入数据，又处理输出数据，但并不是必须要这样。
有了这个定义，就很好理解加载函数的作用了。再举个例子：你在磁盘上保存了只有你自己知道怎么读取其格式的数据（例如，数据是按一定规则加密过的，只有你知道如何解密成明文），那么，你想用pig来处理这些数据，把它们转换成一个个字段的明文时，你就必须要有这样一个加载函数(load function)，来进行LOAD数据时的转换工作。这就是加载函数(load function)的作用。
文章来源：http://www.codelast.com/
②知道了load function是干嘛的，现在怎么写一个load function？如果你看的是这个链接的UDF手册：Pig Wiki UDF Manual中，会发现它是这样说的——
加载函数必须要实现 LoadFunc 接口，这个接口类似于下面的样子：

public interface LoadFunc {
    public void bindTo(String fileName, BufferedPositionedInputStream is, long offset, long end) throws IOException;
    public Tuple getNext() throws IOException;
    // conversion functions
    public Integer bytesToInteger(byte[] b) throws IOException;
    public Long bytesToLong(byte[] b) throws IOException;
    ......
    public void fieldsToRead(Schema schema);
    public Schema determineSchema(String fileName, ExecType execType, DataStorage storage) throws IOException;
}

其中：

• bindTo函数在pig任务开始处理数据之前被调用一次，它试图将函数与输入数据关联起来。
• getNext函数读取输入的数据流并构造下一个元组（tuple）。当完成数据处理时该函数会返回null，当该函数无法处理输入的元组（tuple）时它会抛出一个IOException异常。
• 接下来就是一批转换函数，例如bytesToInteger，bytesToLong等。这些函数的作用是将数据从bytearray转换成要求的类型。
• fieldsToRead函数被保留作未来使用，应被留空。
• determineSchema函数对不同的loader应有不同的实现：对返回真实数据类型（而不是返回bytearray字段）的loader，必须要实现该函数；其他类型的loader只要将determineSchema函数返回null就可以了。

但是，如果你在IDE中import了pig 0.8.1的jar包“pig-0.8.1-core.jar”，会发现 LoadFunc 根本不是一个接口（interface），而是一个抽象类（abstract class），并且要实现的函数也与该文档中所说的不一致。因此，只能说是文档过时了。
所以，要看文档的话，还是要看这个Pig UDF Manual，这里面的内容才是对的。
同时，我也推荐另外一个关于Load/Store Function的链接：《Programming Pig》Chapter 11. Writing Load and Store Functions。这本书很好很强大。

③开始写一个loader。我们现在写一个①中所描述的、可以按逗号分隔符加载数据文件的loader——PigStorage已经有这个功能了，不过为了演示loader是怎么写出来的，这里还是用这个功能来说明。
代码如下：

package com.codelast.udf.pig;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.*;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.pig.*;
import org.apache.pig.backend.executionengine.ExecException;
import org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.*;
import org.apache.pig.data.*;

import java.io.IOException;
import java.util.*;

/**
 * A loader class of pig.
 *
 * @author Darran Zhang (codelast.com)
 * @version 11-10-11
 * @declaration These codes are only for non-commercial use, and are distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
 * You must not remove this declaration at any time.
 */

public class MyLoader extends LoadFunc {
  protected RecordReader recordReader = null;

  @Override
  public void setLocation(String s, Job job) throws IOException {
    FileInputFormat.setInputPaths(job, s);
  }

  @Override
  public InputFormat getInputFormat() throws IOException {
    return new PigTextInputFormat();
  }

  @Override
  public void prepareToRead(RecordReader recordReader, PigSplit pigSplit) throws IOException {
    this.recordReader = recordReader;
  }

  @Override
  public Tuple getNext() throws IOException {
    try {
      boolean flag = recordReader.nextKeyValue();
      if (!flag) {
        return null;
      }
      Text value = (Text) recordReader.getCurrentValue();
      String[] strArray = value.toString().split(",");
      List lst = new ArrayList<String>();
      int i = 0;
      for (String singleItem : strArray) {
        lst.add(i++, singleItem);
      }
      return TupleFactory.getInstance().newTuple(lst);
    } catch (InterruptedException e) {
      throw new ExecException("Read data error", PigException.REMOTE_ENVIRONMENT, e);
    }
  }
}

如上，你的loader类要继承自LoadFunc虚类，并且需要重写它的4个方法。其中，getNext方法是读取数据的方法，它做了读取出一行数据、按逗号分割字符串、构造一个元组（tuple）并返回的事情。这样我们就实现了按逗号分隔符加载数据的loader。
文章来源：http://www.codelast.com/
④关于load function不得不说的一些话题
如果你要加载一个数据文件，例如：

A = LOAD 'myfile' AS (col1:chararray, col2:int);

假设此文件的结构不复杂，你可以手工写 AS 语句，但如果此文件结构特别复杂，你总不可能每次都手工写上几十个甚至上百个字段名及类型定义吧？
这个时候，如果我们可以让pig从哪里读出来要加载的数据的schema（模式），就显得特别重要了。
在实现load function的时候，我们是通过实现 LoadMetadata 这个接口中的 getSchema 方法来做到这一点的。例如：

public class MyLoadFunc extends LoadFunc implements LoadMetadata {

  public ResourceSchema getSchema(String filename, Job job) throws IOException {
    //TODO:
  }
}

实现了 getSchema 方法之后，在pig脚本中加载数据的时候，就可以无需编写 AS 语句，就可以使用你在 getSchema 方法中指定的模式了。例如：

REGISTER 'myUDF.jar';
A = LOAD 'myfile' USING com.codelast.MyLoadFunc();
B = foreach A generate col1;
SOTRE B INTO 'output';

看清楚了，在 LOAD 的时候，我们并没有写 AS 语句来指定字段名，但是在后面的 FOREACH 中，我们却可以使用 col1 这样的字段名，这正是因为 getSchema 方法的实现为我们做到了这一点。在数据文件的结构特别复杂的时候，这个功能几乎是不可或缺的，否则难以想像会给分析数据的人带来多大的不便。

 重载(overloading)一个UDF
类似于C++的函数重载，pig中也可以重载UDF，例如一个函数ADD可以对两个int进行操作，也可以对两个double进行操作，那么我们可以为该函数实现 getArgToFuncMapping 方法，该函数返回一个 List<FuncSpec> 对象，这个对象中包含了参数的类型信息。具体怎么实现，可以看这个链接（搜索“Overloading UDFs”定位到所需章节）。

 pig运行不起来，提示“org.apache.hadoop.ipc.Client - Retrying connect to server: localhost/127.0.0.1:9000. Already tried 1 time(s)”错误的解决办法
发生这个错误时，请先检查Hadoop的各个进程是否都运行起来了，例如，在我的一次操作中，遇到这个错误时，我发现Hadoop namenode进程没有启动起来：

ps -ef | grep java | grep NameNode

应该有两个进程启动起来了：

org.apache.hadoop.hdfs.server.namenode.NameNode
org.apache.hadoop.hdfs.server.namenode.SecondaryNameNode

如果没有，那么你要到Hadoop安装目录下的“logs”目录下，查看NameNode的日志记录文件（视用户不同，日志文件的名字也会有不同），例如，我的NameNone日志文件 hadoop--namenode-root-XXX.log 的末尾，显示出有如下错误：

ERROR org.apache.hadoop.hdfs.server.namenode.NameNode: org.apache.hadoop.hdfs.server.common.InconsistentFSStateException: Directory /tmp/hadoop-root/dfs/name is in an inconsistent state: storage directory does not exist or is not accessible.

文章来源：http://www.codelast.com/
我到它提示的地方一看，果然不存在最后一级目录（我是伪分布式运行的Hadoop，不要觉得奇怪），于是手工创建了这个目录，然后停掉Hadoop：

stop-all.sh

稍候一会儿再重新启动Hadoop：

start-all.sh

然后再去看一下NameNode的日志，又发现了新的错误信息：

ERROR org.apache.hadoop.hdfs.server.namenode.NameNode: java.io.IOException: NameNode is not formatted.

这表明NameNode没有被格式化。于是将其格式化：

[root@localhost bin]# hadoop namenode -format

命令行问你是否要格式化的时候，选择YES即可。格式化完后会提示：

common.Storage: Storage directory /tmp/hadoop-root/dfs/name has been successfully formatted.

说明成功了。这个时候，再像前面一样重启Hadoop进程，再去看NameNode的日志文件的最后若干行，应该会发现前面的那些错误提示没了。这个时候，再检查Hadoop各进程是否都成功地启动了，如果是的话，那么这个时候你就可以在Hadoop的伪分布式模式下启动pig：

[root@localhost home]# pig

而不用以本地模式来运行pig了（pig -x local）。
总之，配置一个伪分布式的Hadoop来调试pig在某些情况下是很有用的，但是比较麻烦，因为还牵涉到Hadoop的正确配置，但是最好搞定它，以后大有用处啊。

 用Pig加载HBase数据时遇到的错误“ERROR 2999: Unexpected internal error. could not instantiate 'com.twitter.elephantbird.pig.load.HBaseLoader' with arguments XXX”的原因之一
你也许早就知道了：Pig可以加载HBase数据，从而更方便地进行数据处理。但是在使用HBase的loader的时候，可能会遇到这样那样的问题，我这里就遇到了一例，给大家分析一下原因。
使用 org.apache.pig.backend.hadoop.hbase.HBaseStorage() 可以加载HBase数据，例如：

A = LOAD 'hbase://table_name' USING org.apache.pig.backend.hadoop.hbase.HBaseStorage('column_family_name:qualifier_name', '-loadKey true -limit 100') AS (col1: chararray, col2:chararray);

其中，table_name 是你要加载数据的HBase表名，column_family_name:qualifier_name 是表的column family:qualifier（当然，可以有多个column family:qualifier，以空格隔开即可），-loadKey true -limit 100 是加载数据时指定的参数，支持的参数如下：

-loadKey=(true|false)  Load the row key as the first column

-gt=minKeyVal

-lt=maxKeyVal 

-gte=minKeyVal

-lte=maxKeyVal

-limit=numRowsPerRegion max number of rows to retrieve per region

-delim=char delimiter to use when parsing column names (default is space or comma)

-ignoreWhitespace=(true|false) ignore spaces when parsing column names (default true)

-caching=numRows  number of rows to cache (faster scans, more memory).

-noWAL=(true|false) Sets the write ahead to false for faster loading.

    To be used with extreme caution, since this could result in data loss

    (see http://hbase.apache.org/book.html#perf.hbase.client.putwal).

ERROR 2999: Unexpected internal error. could not instantiate 'com.twitter.elephantbird.pig.load.HBaseLoader' with arguments XXX
Details at logfile: XXX

m_conf = HBaseConfiguration.create();

可见它调用了HBase代码中的一个类HBaseConfiguration的create方法。按上面的提示，它是找不到这个方法，于是我们再看看使用的HBase的 HBaseConfiguration.java 里的代码，找遍全文，都找不到create方法！那么，我们再看看更新一点的版本的HBase的相同文件中是否有这个方法呢？下载0.90.4版本的HBase，果然在 HBaseConfiguration.java 中找到了create方法：

  /**                                                                                                                                                       
   * Creates a Configuration with HBase resources                                                                                                       
   * @return a Configuration with HBase resources                                                                                                       
   */
  public static Configuration create() {
    Configuration conf = new Configuration();
    return addHbaseResources(conf);
  }

所以，问题就在这里了：Pig的HBase loader不能使用某些版本的HBase，升级HBase吧！
另外，就算HBase版本适用了，你也得让Pig知道HBase的参数配置（要不然怎么可以指定一个HBase表名就可以加载其数据了呢），具体你可以看这个链接的说明。

 JOIN的优化
如果你对N个关系(relation)的某些字段进行JOIN，也就是所谓的“多路的”(multi-way)JOIN——我不知道用中文这样描述是否正确——在这种情况下，请遵循这样的原则来写JOIN语句：
JOIN用到的key所对应的记录最多的那个关系(relation)应该被排在最后。例如：

D = JOIN A BY col1, B BY col1, C BY col1;

在这里，假设C这个relation就是上面所说的那种情况，所以把它排在最后。
文章来源：http://www.codelast.com/
为什么要遵循这样的原则？这是由Pig处理JOIN的方式来决定的。在JOIN的n个关系中，前面的n-1个关系的处理结果会被cache在内存中，然后才会轮到第n个关系，因此，把最占内存的放在最后，有时候是能起到优化作用的。

 错误“Backend error : org.apache.pig.data.BinSedesTuple cannot be cast to org.apache.pig.data.DataBag”的原因
如果你正在使用Pig 0.8，那么要注意了：出现这个错误，可能是Pig的bug导致的，详见这个链接。
说得简单点就是：此bug会导致无法解引用一个tuple中的bag。通常我们取一个tuple中的bag，是为了FLATTEN它，将记录展开，但是此bug使得你根本连tuple中的bag都输出不了。
此bug并不会影响你的Pig脚本语法解析，也就是说，你的Pig脚本只要写对了，就能运行起来，但是它执行到后面会报错。

 如何加载LZO压缩的纯文本数据
如果你的数据是纯文本经由LZO压缩而成，那么你可以用elephant-bird的 com.twitter.elephantbird.pig.store.LzoPigStorage 来加载它：

A = LOAD '/user/codelast/text-lzo-file' USING com.twitter.elephantbird.pig.store.LzoPigStorage() AS (col1: chararray, col2: int);

注意，这里没有写REGISTER jar包的命令，你需要自己补上。

 如何用Pig设置map端的并行度(map数)
从这个链接中的第(9)条，我们知道，无法通过PARALLEL来设置Pig job map端的并行度，但是，有没有什么办法可以间接实现这一点呢？
在Java编写的MapReduce程序中，你可以像这个链接中的第(25)点所说的一样，通过FileInputFormat.setMinInputSplitSize()来间接更改map的数量，其实它就与设置 mapred.min.split.size 参数值的效果是一样的。
在Pig中，我们是可以通过set命令来设置job参数的，所以，我们如果在Pig脚本的开头写上：

set mapred.min.split.size 2147483648;

将使得对map来说，小于2G的文件将被作为一个split输入，从而一个小于2G的文件将只有一个map。假设我们的Pig job是一个纯map的job，那么，map数的减少将使得输出文件的数量减少，在某些情况下，这种功能还是很有用的。
注意：上面的命令中，set的参数的单位是字节，所以2G=2*1024*1024*1024=2147483648。

 Pig调用现存的静态Java方法
不是每个人都会开发UDF，或者每个人都愿意去写一个UDF来完成一件极其简单的操作的，例如，把一个编码过的URL解码，如果我只想临时用一下这个功能，那么我还要去写一个UDF，累不累啊？
我们知道，java.net.URLDecoder.decode 这个静态方法已经实现了URL解码功能：

static String decode(String s, String enc) 

使用指定的编码机制对 application/x-www-form-urlencoded 字符串解码

那么，如何在Pig中使用这个现成的静态方法呢？为了展示这个使用过程，我造了一个数据文件：

[root@localhost ~]$ cat a.txt 
http://zh.wikipedia.org/zh/%E6%90%9C%E7%B4%A2%E5%BC%95%E6%93%8E

就一行，这个URL解码之后应该是：
http://zh.wikipedia.org/wiki/搜索引擎
因为里面含中文，所以被编码了。
处理此文件的Pig脚本url.pig如下：

DEFINE DecodeURL InvokeForString('java.net.URLDecoder.decode', 'String String');
A = LOAD 'a.txt' AS (url: chararray);
B = FOREACH A GENERATE DecodeURL(url, 'UTF-8');
STORE B INTO 'url';

文章来源：http://www.codelast.com/
用 pig -x local url.pig 执行这个脚本，完成后我们查看输出目录下的 part-m-00000 文件内容，可见它确实被解码成了正确的字符串。
这样，我们就利用了现存的静态Java方法来偷了个懒，很方便。
需要注意的是：只能调用静态方法，并且此调用比同样的UDF实现速度要慢，这是因为调用器没有使用Accumulator或Algebraic接口。根据这位兄台的测试，百万条的记录规模下，调用Java静态方法比UDF大约要慢一倍。至于这样的代价能不能接受，就看你自己的判断了。
文章来源：http://www.codelast.com/
 REGISTER UDF的前后覆盖关系
在Pig脚本中使用多个UDF时，我们通常会使用通配符的方式来引入：

REGISTER /user/hadoop/*.jar

假设你有另一个包含UDF的jar：/user/codelast/my-pig-lib.jar
并且这个jar的旧版本已经包含在 /user/hadoop/*.jar 中，那么，当你使用下面的方式来引入jar的时候：

REGISTER /user/hadoop/*.jar
REGISTER /user/codelast/my-pig-lib.jar

my-pig-lib.jar这个jar，使用的是新版还是旧版呢？这是不一定的，并不是说以最后REGISTER的为准，而是取决于CLASSPATH中jar的顺序。所以，如果你想保证能用到新版的UDF，为了保险你应该不要把旧版的UDF用 /user/hadoop/*.jar 的方式引入，而应该把 my-pig-lib.jar 从 /user/hadoop/*.jar 中剔除出去再REGISTER。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

本文可以让刚接触pig的人对一些基础概念有个初步的了解。
很久很久以前，本文大概是互联网上第一篇公开发表的且涵盖大量实际例子的Apache Pig中文教程（由Google搜索可知），文中的大量实例都是作者Darran Zhang（website: codelast.com）在工作、学习中总结的经验或解决的问题，并且添加了较为详尽的说明及注解，希望能帮助一部分人。

Apache pig是用来处理大规模数据的高级查询语言，配合Hadoop使用，可以在处理海量数据时达到事半功倍的效果，比使用Java，C++等语言编写大规模数据处理程序的难度要小N倍，实现同样的效果的代码量也小N倍。
但是刚接触pig时，可能会觉得里面的某些概念以及程序实现方法与想像中的很不一样，所以，你需要仔细地研究一下基础概念，这样在写pig程序的时候，才不会觉得非常别扭。

本文大部分内容基于 Pig 0.8.1 写作而成。众所周知，这个版本的Pig现在已经非常过时，但是，无论新版旧版，Pig的基础用法在很多情况下都是一致的，所以，这并不影响你学习。
本文的部分内容来自Pig官方文档，但涉及到翻译的部分，也是我自己翻译的，因此可能理解与英文有偏差，如果你觉得有疑义，可参考英文内容。
文章来源：http://www.codelast.com/
下面开始学习Pig。

➤ 关系（relation）、包（bag）、元组（tuple）、字段（field）、数据（data）的关系

• 一个关系（relation）是一个包（bag），更具体地说，是一个外部的包（outer bag）。
• 一个包（bag）是一个元组（tuple）的集合。在pig中表示数据时，用大括号{}括起来的东西表示一个包——无论是在教程中的实例演示，还是在pig交互模式下的输出，都遵循这样的约定，请牢记这一点，因为不理解的话就会对数据结构的掌握产生偏差。
• 一个元组（tuple）是若干字段（field）的一个有序集（ordered set）。在pig中表示数据时，用小括号()括起来的东西表示一个元组。
• 一个字段是一块数据（data）。

“元组”这个词很抽象，你可以把它想像成关系型数据库表中的一行，它含有一个或多个字段，其中，每一个字段可以是任何数据类型，并且可以有或者没有数据。
“关系”可以比喻成关系型数据库的一张表，而上面说了，“元组”可以比喻成数据表中的一行，那么这里有人要问了，在关系型数据库中，同一张表中的每一行都有固定的字段数，pig中的“关系”与“元组”之间，是否也是这样的情况呢？不是的。“关系”并不要求每一个“元组”都含有相同数量的字段，并且也不会要求各“元组”中在相同位置处的字段具有相同的数据类型（太随意了，是吧？）
文章来源：http://www.codelast.com/
➤ 一个 计算多维度组合下的平均值 的实际例子
为了帮助大家理解pig的一个基本的数据处理流程，我造了一些简单的数据来举个例子——
假设有数据文件：a.txt（各数值之间是以tab分隔的）：

[root@localhost pig]$ cat a.txt 
a 1 2 3 4.2 9.8
a 3 0 5 3.5 2.1
b 7 9 9 - -
a 7 9 9 2.6 6.2
a 1 2 5 7.7 5.9
a 1 2 3 1.4 0.2

问题如下：怎样求出在第2、3、4列的所有组合的情况下，最后两列的平均值分别是多少？
例如，第2、3、4列有一个组合为（1，2，3），即第一行和最后一行数据。对这个维度组合来说，最后两列的平均值分别为：
（4.2+1.4）/2＝2.8
（9.8+0.2）/2＝5.0
而对于第2、3、4列的其他所有维度组合，都分别只有一行数据，因此最后两列的平均值其实就是它们自身。
特别地，组合（7，9，9）有两行记录：第三、四行，但是第三行数据的最后两列没有值，因此它不应该被用于平均值的计算，也就是说，在计算平均值时，第三行是无效数据。所以（7，9，9）组合的最后两列的平均值为 2.6 和 6.2。
我们现在用pig来算一下，并且输出最终的结果。
先进入本地调试模式（pig -x local），再依次输入如下pig代码：

A = LOAD 'a.txt' AS (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double);
B = GROUP A BY (col2, col3, col4);
C = FOREACH B GENERATE group, AVG(A.col5), AVG(A.col6);
DUMP C;

pig输出结果如下：

((1,2,3),2.8,5.0)

((1,2,5),7.7,5.9)

((3,0,5),3.5,2.1)

((7,9,9),2.6,6.2)

这个结果对吗？手工算一下就知道是对的。
文章来源：http://www.codelast.com/
下面，我们依次来看看每一句pig代码分别得到了什么样的数据。
①加载 a.txt 文件，并指定每一列的数据类型分别为 chararray（字符串），int，int，int，double，double。同时，我们还给予了每一列别名，分别为 col1，col2，……，col6。这个别名在后面的数据处理中会用到——如果你不指定别名，那么在后面的处理中，就只能使用索引（$0，$1，……）来标识相应的列了，这样可读性会变差，因此，在列固定的情况下，还是指定别名的好。
将数据加载之后，保存到变量A中，A的数据结构如下：

A: {col1: chararray,col2: int,col3: int,col4: int,col5: double,col6: double}

可见，A是用大括号括起来的东西。根据本文前面的说法，A是一个包（bag）。
这个时候，A与你想像中的样子应该是一致的，也就是与前面打印出来的 a.txt 文件的内容是一样的，还是一行一行的类似于“二维表”的数据。
文章来源：http://www.codelast.com/
②按照A的第2、3、4列，对A进行分组。pig会找出所有第2、3、4列的组合，并按照升序进行排列，然后将它们与对应的包A整合起来，得到如下的数据结构：

B: {group: (col2: int,col3: int,col4: int),A: {col1: chararray,col2: int,col3: int,col4: int,col5: double,col6: double}}

可见，A的第2、3、4列的组合被pig赋予了一个别名：group，这很形象。同时我们也观察到，B的每一行其实就是由一个group和若干个A组成的——注意，是若干个A。这里之所以只显示了一个A，是因为这里表示的是数据结构，而不表示具体数据有多少组。
实际的数据为：

((1,2,3),{(a,1,2,3,4.2,9.8),(a,1,2,3,1.4,0.2)})

((1,2,5),{(a,1,2,5,7.7,5.9)})

((3,0,5),{(a,3,0,5,3.5,2.1)})

((7,9,9),{(b,7,9,9,,),(a,7,9,9,2.6,6.2)})

可见，与前面所说的一样，组合（1，2，3）对应了两行数据，组合（7，9，9）也对应了两行数据。
这个时候，B的结构就不那么明朗了，可能与你想像中有一点不一样了。
文章来源：http://www.codelast.com/
③计算每一种组合下的最后两列的平均值。
根据上面得到的B的数据，你可以把B想像成一行一行的数据（只不过这些行不是对称的），FOREACH 的作用是对 B 的每一行数据进行遍历，然后进行计算。
GENERATE 可以理解为要生成什么样的数据，这里的 group 就是上一步操作中B的第一项数据（即pig为A的第2、3、4列的组合赋予的别名），所以它告诉了我们：在数据集 C 的每一行里，第一项就是B中的group——类似于（1，2，5）这样的东西）。
而 AVG(A.col5) 这样的计算，则是调用了pig的一个求平均值的函数 AVG，用于对 A 的名为 col5 的列求平均值。前文说了，在加载数据到A的时候，我们已经给每一列起了个别名，col5就是倒数第二列。
到这里，可能有人要迷糊了：难道 AVG(A.col5) 不是表示对 A 的col5这一列求平均值吗？也就是说，在遍历B（FOREACH B）的每一行时候，计算结果都是相同的啊！
事实上并不是这样。我们遍历的是B，我们需要注意到，B的数据结构中，每一行数据里，一个group对应的是若干个A，因此，这里的 A.col5，指的是B的每一行中的A，而不是包含全部数据的那个A。拿B的第一行来举例：
((1,2,3),{(a,1,2,3,4.2,9.8),(a,1,2,3,1.4,0.2)})
遍历到B的这一行时，要计算AVG(A.col5)，pig会找到 (a,1,2,3,4.2,9.8) 中的4.2，以及(a,1,2,3,1.4,0.2)中的1.4，加起来除以2，就得到了平均值。
同理，我们也知道了AVG(A.col6)是怎么算出来的。但还有一点要注意的：对(7,9,9)这个组，它对应的数据(b,7,9,9,,)里最后两列是无值的，这是因为我们的数据文件对应位置上不是有效数字，而是两个“-”，pig在加载数据的时候自动将它置为空了，并且计算平均值的时候，也不会把这一组数据考虑在内（相当于忽略这组数据的存在）。
到了这里，我们不难理解，为什么C的数据结构是这样的了：

C: {group: (col2: int,col3: int,col4: int),double,double}

文章来源：http://www.codelast.com/
④DUMP C就是将C中的数据输出到控制台。如果要输出到文件，需要使用：

STORE C INTO 'output';

这样pig就会在当前目录下新建一个“output”目录（该目录必须事先不存在），并把结果文件放到该目录下。

请想像一下，如果要实现相同的功能，用Java或C++写一个Map-Reduce应用程序需要多少时间？可能仅仅是写一个build.xml或者Makefile，所需的时间就是写这段pig代码的几十倍了！
正因为pig有如此优势，它才得到了广泛应用。
文章来源：http://www.codelast.com/
➤ 怎样统计数据行数
在SQL语句中，要统计表中数据的行数，很简单：

SELECT COUNT(*) FROM table_name WHERE condition

在pig中，也有一个COUNT函数，在pig手册中，对COUNT函数有这样的说明：

Computes the number of elements in a bag.

假设要计算数据文件a.txt的行数：

[root@localhost pig]$ cat a.txt 
a    1   2   3   4.2 9.8
a    3   0   5   3.5 2.1
b    7   9   9   -   -
a    7   9   9   2.6 6.2
a    1   2   5   7.7 5.9
a    1   2   3   1.4 0.2

你是否可以这样做呢：

A = LOAD 'a.txt' AS (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double);
B = COUNT(*);
DUMP B;

答案是：绝对不行。pig会报错。pig手册中写得很明白：

Note: You cannot use the tuple designator (*) with COUNT; that is, COUNT(*) will not work.

那么，这样对某一列计数行不行呢：

B = COUNT(A.col2);

答案是：仍然不行。pig会报错。
这就与我们想像中的“正确做法”有点不一样了：我为什么不能直接统计一个字段的数目有多少呢？刚接触pig的时候，一定非常疑惑这样明显“不应该出错”的写法为什么行不通。
要统计A中含col2字段的数据有多少行，正确的做法是：

A = LOAD 'a.txt' AS (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double);
B = GROUP A ALL;
C = FOREACH B GENERATE COUNT(A.col2);
DUMP C;

输出结果：

(6)

表明有6行数据。
如此麻烦？没错。这是由pig的数据结构决定的。
文章来源：http://www.codelast.com/
在这个例子中，统计COUNT(A.col2)和COUNT(A)的结果是一样的，但是，如果col2这一列中含有空值：

[root@localhost pig]$ cat a.txt 
a    1   2   3   4.2 9.8
a        0   5   3.5 2.1
b    7   9   9   -   -
a    7   9   9   2.6 6.2
a    1   2   5   7.7 5.9
a    1   2   3   1.4 0.2

则以下pig程序及执行结果为：

grunt> A = LOAD 'a.txt' AS (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double);
grunt> B = GROUP A ALL;
grunt> C = FOREACH B GENERATE COUNT(A.col2);
grunt> DUMP C;
(5)

可见，结果为5行。那是因为你LOAD数据的时候指定了col2的数据类型为int，而a.txt的第二行数据是空的，因此数据加载到A以后，有一个字段就是空的：

grunt> DUMP A;
(a,1,2,3,4.2,9.8)
(a,,0,5,3.5,2.1)
(b,7,9,9,,)
(a,7,9,9,2.6,6.2)
(a,1,2,5,7.7,5.9)
(a,1,2,3,1.4,0.2)

在COUNT的时候，null的字段不会被计入在内，所以结果是5。

The COUNT function follows syntax semantics and ignores nulls. What this means is that a tuple in the bag will not be counted if the first field in this tuple is NULL. If you want to include NULL values in the count computation, use COUNT_STAR.

文章来源：http://www.codelast.com/

[root@localhost pig]$ cat a.txt 
a    1   2   3   4.2 9.8
a    3   0   5   3.5 2.1
b    7   9   9   -   -
a    7   9   9   2.6 6.2
a    1   2   5   7.7 5.9
a    1   2   3   1.4 0.2

如果我们按照前文的做法，计算多维度组合下的最后两列的平均值，则：

grunt> A = LOAD 'a.txt' AS (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double);
grunt> B = GROUP A BY (col2, col3, col4);
grunt> C = FOREACH B GENERATE group, AVG(A.col5), AVG(A.col6);
grunt> DUMP C;
((1,2,3),2.8,5.0)
((1,2,5),7.7,5.9)
((3,0,5),3.5,2.1)
((7,9,9),2.6,6.2)

可见，输出结果中，每一行的第一项是一个tuple（元组），我们来试试看 FLATTEN 的作用：

grunt> A = LOAD 'a.txt' AS (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double);
grunt> B = GROUP A BY (col2, col3, col4);
grunt> C = FOREACH B GENERATE FLATTEN(group), AVG(A.col5), AVG(A.col6);
grunt> DUMP C;
(1,2,3,2.8,5.0)
(1,2,5,7.7,5.9)
(3,0,5,3.5,2.1)
(7,9,9,2.6,6.2)

看到了吗？被 FLATTEN 的group本来是一个元组，现在变成了扁平的结构了。按照pig文档的说法，FLATTEN用于对元组（tuple）和包（bag）“解嵌套”（un-nest）：

The FLATTEN operator looks like a UDF syntactically, but it is actually an operator that changes the structure of tuples and bags in a way that a UDF cannot. Flatten un-nests tuples as well as bags. The idea is the same, but the operation and result is different for each type of structure.

 

For tuples, flatten substitutes the fields of a tuple in place of the tuple. For example, consider a relation that has a tuple of the form (a, (b, c)). The expression GENERATE $0, flatten($1), will cause that tuple to become (a, b, c).

文章来源：http://www.codelast.com/
所以我们就看到了上面的结果。
在有的时候，不“解嵌套”的数据结构是不利于观察的，输出这样的数据可能不利于外围数程序的处理（例如，pig将数据输出到磁盘后，我们还需要用其他程序做后续处理，而对一个元组，输出的内容里是含括号的，这就在处理流程上又要多一道去括号的工序），因此，FLATTEN提供了一个让我们在某些情况下可以清楚、方便地分析数据的机会。

➤ 关于GROUP操作符
在上文的例子中，已经演示了GROUP操作符会生成什么样的数据。在这里，需要说得更理论一些：

• 用于GROUP的key如果多于一个字段（正如本文前面的例子），则GROUP之后的数据的key是一个元组（tuple），否则它就是与用于GROUP的key相同类型的东西。
• GROUP的结果是一个关系（relation），在这个关系中，每一组包含一个元组（tuple），这个元组包含两个字段：（1）第一个字段被命名为“group”——这一点非常容易与GROUP关键字相混淆，但请区分开来。该字段的类型与用于GROUP的key类型相同。（2）第二个字段是一个包（bag），它的类型与被GROUP的关系的类型相同。

➤ 把数据当作“元组”（tuple）来加载
还是假设有如下数据：

[root@localhost pig]$ cat a.txt 
a    1   2   3   4.2 9.8
a    3   0   5   3.5 2.1
b    7   9   9   -   -
a    7   9   9   2.6 6.2
a    1   2   5   7.7 5.9
a    1   2   3   1.4 0.2

如果我们按照以下方式来加载数据：

A = LOAD 'a.txt' AS (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double); 

那么得到的A的数据结构为：

grunt> DESCRIBE A;
A: {col1: chararray,col2: int,col3: int,col4: int,col5: double,col6: double}

如果你要把A当作一个元组（tuple）来加载：

A = LOAD 'a.txt' AS (T : tuple (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double));

也就是想要得到这样的数据结构：

grunt> DESCRIBE A;
A: {T: (col1: chararray,col2: int,col3: int,col4: int,col5: double,col6: double)}

那么，上面的方法将得到一个空的A：

grunt> DUMP A;
()
()
()
()
()
()

那是因为数据文件a.txt的结构不适合于这样加载成元组（tuple）。
文章来源：http://www.codelast.com/
如果有数据文件b.txt：

[root@localhost pig]$ cat b.txt 
(a,1,2,3,4.2,9.8)
(a,3,0,5,3.5,2.1)
(b,7,9,9,-,-)
(a,7,9,9,2.6,6.2)
(a,1,2,5,7.7,5.9)
(a,1,2,3,1.4,0.2)

则使用上面所说的加载方法及结果为：

grunt> A = LOAD 'b.txt' AS (T : tuple (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double));
grunt> DUMP A;
((a,1,2,3,4.2,9.8))
((a,3,0,5,3.5,2.1))
((b,7,9,9,,))
((a,7,9,9,2.6,6.2))
((a,1,2,5,7.7,5.9))
((a,1,2,3,1.4,0.2))

可见，加载的数据的结构确实被定义成了元组（tuple）。

➤ 在多维度组合下，如何计算某个维度组合里的不重复记录的条数
以数据文件 c.txt 为例：

[root@localhost pig]$ cat c.txt 
a    1   2   3   4.2 9.8 100
a    3   0   5   3.5 2.1 200
b    7   9   9   -   -   300
a    7   9   9   2.6 6.2 300
a    1   2   5   7.7 5.9 200
a    1   2   3   1.4 0.2 500

问题：如何计算在第2、3、4列的所有维度组合下，最后一列不重复的记录分别有多少条？例如，第2、3、4列有一个维度组合是（1，2，3），在这个维度维度下，最后一列有两种值：100 和 500，因此不重复的记录数为2。同理可求得其他的记录条数。
pig代码及输出结果如下：

grunt> A = LOAD 'c.txt' AS (col1:chararray, col2:int, col3:int, col4:int, col5:double, col6:double, col7:int);
grunt> B = GROUP A BY (col2, col3, col4);
grunt> C = FOREACH B {D = DISTINCT A.col7; GENERATE group, COUNT(D);};
grunt> DUMP C;
((1,2,3),2)
((1,2,5),1)
((3,0,5),1)
((7,9,9),1)

我们来看看每一步分别生成了什么样的数据：
①LOAD不用说了，就是加载数据；
②GROUP也不用说了，和前文所说的一样。GROUP之后得到了这样的数据：

grunt> DUMP B;
((1,2,3),{(a,1,2,3,4.2,9.8,100),(a,1,2,3,1.4,0.2,500)})
((1,2,5),{(a,1,2,5,7.7,5.9,200)})
((3,0,5),{(a,3,0,5,3.5,2.1,200)})
((7,9,9),{(b,7,9,9,,,300),(a,7,9,9,2.6,6.2,300)})

其实到这里，我们肉眼就可以看出来最后要求的结果是什么了，当然，必须要由pig代码来完成，要不然怎么应对海量数据？
文章来源：http://www.codelast.com/
③这里的 FOREACH 与前面有点不一样，这就是所谓的“嵌套的FOREACH”。第一次看到这种写法，肯定会觉得很奇怪。先看一下用于去重的DISTINCT关键字的说明：

Removes duplicate tuples in a relation.

然后再解释一下：FOREACH 是对B的每一行进行遍历，其中，B的每一行里含有一个包（bag），每一个包中含有若干元组（tuple）A，因此，FOREACH 后面的大括号里的操作，其实是对所谓的“内部包”（inner bag）的操作（详情请参看FOREACH的说明），在这里，我们指定了对A的col7这一列进行去重，去重的结果被命名为D，然后再对D计数（COUNT），就得到了我们想要的结果。
④输出结果数据，与前文所述的差不多。
这样就达成了我们的目的。从总体上说，刚接触pig不久的人会觉得这些写法怪怪的，就是扭不过来，但是要坚持，时间长了，连倒影也会让你觉得是正的了。

➤ 如何将关系（relation）转换为标量（scalar）
在前文中，我们要统计符合某些条件的数据的条数，使用了COUNT函数来计算，但在COUNT之后，我们得到的还是一个关系（relation），而不是一个标量的数字，如何把一个关系转换为标量，从而可以在后续处理中便于使用呢？
具体请看这个链接。

➤ pig中如何使用shell进行辅助数据处理
pig中可以嵌套使用shell进行辅助处理，下面，就以一个实际的例子来说明。
假设我们在某一步pig处理后，得到了类似于下面 b.txt 中的数据：

[root@localhost pig]$ cat b.txt 
1    5   98  =   7
34    8   6   3   2
62    0   6   =   65

问题：如何将数据中第4列中的“=”符号全部替换为9999？
pig代码及输出结果如下：

grunt> A = LOAD 'b.txt' AS (col1:int, col2:int, col3:int, col4:chararray, col5:int);
grunt> B = STREAM A THROUGH `awk '{if($4 == "=") print $1"\t"$2"\t"$3"\t9999\t"$5; else print $0}'`;
grunt> DUMP B;
(1,5,98,9999,7)
(34,8,6,3,2)
(62,0,6,9999,65)

我们来看看这段代码是如何做到的：
①加载数据，这个没什么好说的。
②通过“STREAM … THROUGH …”的方式，我们可以调用一个shell语句，用该shell语句对A的每一行数据进行处理。此处的shell逻辑为：当某一行数据的第4列为“=”符号时，将其替换为“9999”；否则就照原样输出这一行。
③输出B，可见结果正确。

➤ 向pig脚本中传入参数
假设你的pig脚本输出的文件是通过外部参数指定的，则此参数不能写死，需要传入。在pig中，使用传入的参数如下所示：

STORE A INTO '$output_dir';

则这个“output_dir”就是个传入的参数。在调用这个pig脚本的shell脚本中，我们可以这样传入参数：

pig -param output_dir="/home/my_ourput_dir/" my_pig_script.pig

这里传入的参数“output_dir”的值为“/home/my_output_dir/”。
文章来源：http://www.codelast.com/
➤ 就算是同样一段pig代码，多次计算所得的结果也有可能是不同的
例如用AVG函数来计算平均值时，同样一段pig代码，多次计算所得的结果中，小数点的最后几位也有可能是不相同的（当然也有可能相同），大概是因为精度的原因吧。不过，一般来说小数点的最后几位已经不重要了。例如我对一个数据集进行处理后，小数点后13位才开始有不同，这样的精度完全足够了。

➤ 如何编写及使用自定义函数（UDF）
请看这个链接：《Apache Pig中文教程（进阶）》

➤ 什么是聚合函数（Aggregate Function）
在pig中，聚合函数就是那些接受一个输入包（bag），返回一个标量（scalar）值的函数。COUNT函数就是一个例子。

➤ COGROUP做了什么
与GROUP操作符一样，COGROUP也是用来分组的，不同的是，COGROUP可以按多个关系中的字段进行分组。
还是以一个实例来说明，假设有以下两个数据文件：

[root@localhost pig]$ cat a.txt 
uidk    12  3
hfd    132 99
bbN    463 231
UFD    13  10

[root@localhost pig]$ cat b.txt 
908    uidk    888
345    hfd 557
28790    re  00000

现在我们用pig做如下操作及得到的结果为：

grunt> A = LOAD 'a.txt' AS (acol1:chararray, acol2:int, acol3:int);
grunt> B = LOAD 'b.txt' AS (bcol1:int, bcol2:chararray, bcol3:int);
grunt> C = COGROUP A BY acol1, B BY bcol2;
grunt> DUMP C;
(re,{},{(28790,re,0)})
(UFD,{(UFD,13,10)},{})
(bbN,{(bbN,463,231)},{})
(hfd,{(hfd,132,99)},{(345,hfd,557)})
(uidk,{(uidk,12,3)},{(908,uidk,888)})

每一行输出的第一项都是分组的key，第二项和第三项分别都是一个包（bag），其中，第二项是根据前面的key找到的A中的数据包，第三项是根据前面的key找到的B中的数据包。
来看看第一行输出：“re”作为group的key时，其找不到对应的A中的数据，因此第二项就是一个空的包“{}”，“re”这个key在B中找到了对应的数据（28790    re    00000），因此第三项就是bag {(28790,re,0)}。
其他输出数据也类似。

➤ 安装pig后，运行pig命令时提示“Cannot find hadoop configurations in classpath”等错误的解决办法
pig安装好后，运行pig命令时提示以下错误：

ERROR org.apache.pig.Main - ERROR 4010: Cannot find hadoop configurations in classpath (neither hadoop-site.xml nor core-site.xml was found in the classpath).If you plan to use local mode, please put -x local option in command line

显而易见，提示找不到与hadoop相关的配置文件。所以我们需要把hadoop安装目录下的“conf”子目录添加到系统环境变量PATH中：
修改 /etc/profile 文件，添加：

export HADOOP_HOME=/usr/local/hadoop
export PIG_CLASSPATH=$HADOOP_HOME/conf

PATH=$JAVA_HOME/bin:$HADOOP_HOME/bin:$PIG_CLASSPATH:$PATH

然后重新加载 /etc/profile 文件：

source /etc/profile

文章来源：http://www.codelast.com/
➤ piggybank是什么东西

Pig also hosts a UDF repository called piggybank that allows users to share UDFs that they have written.

说白了就是Apache把大家写的自定义函数放在一块儿，起了个名字，就叫做piggybank。你可以把它理解为一个SVN代码仓库。具体请看这里。

➤ UDF的构造函数会被调用几次
你可能会想在UDF的构造函数中做一些初始化的工作，例如创建一些文件，等等。但是你不能假设UDF的构造函数只被调用一次，因此，如果你要在构造函数中做一些只能做一次的工作，你就要当心了——可能会导致错误。

➤ LOAD数据时，如何一次LOAD多个目录下的数据
例如，我要LOAD两个HDFS目录下的数据：/abc/2010 和 /abc/2011，则我们可以这样写LOAD语句：

A = LOAD '/abc/201{0,1}';

➤ 怎样自己写一个UDF中的加载函数(load function)
请看这个链接：《Apache Pig中文教程（进阶）》

➤ 重载(overloading)一个UDF
请看这个链接：《Apache Pig中文教程（进阶）》。

➤ pig运行不起来，提示“org.apache.hadoop.ipc.Client - Retrying connect to server: 
请看这个链接：《Apache Pig中文教程（进阶）》

➤ 用含有null的字段来GROUP，结果会如何
假设有数据文件 a.txt 内容为：

1    2   5
1        3
1    3   
6    9   8

其中，每两列数据之间是用tab分割的，第二行的第2列、第三行的第3列没有内容（也就是说，加载到Pig里之后，对应的数据会变成null），如果把这些数据按第1、第2列来GROUP的话，第1、2列中含有null的行会被忽略吗？
来做一下试验：

A = LOAD 'a.txt' AS (col1:int, col2:int, col3:int);
B = GROUP A BY (col1, col2);
DUMP B;

输出结果为：

((1,2),{(1,2,5)})
((1,3),{(1,3,)})
((1,),{(1,,3)})
((6,9),{(6,9,8)})

从上面的结果（第三行）可见，原数据中第1、2列里含有null的行也被计入在内了，也就是说，GROUP操作是不会忽略null的，这与COUNT有所不同（见本文前面的部分）。

➤ 如何统计数据中某些字段的组合有多少种
假设有如下数据：

[root@localhost]# cat a.txt 
1    3   4   7
1    3   5   4
2    7   0   5
9    8   6   6

现在我们要统计第1、2列的不同组合有多少种，对本例来说，组合有三种：

1    3
2    7
9    8

也就是说我们要的答案是3。
用Pig怎么计算？
文章来源：http://www.codelast.com/
先写出全部的Pig代码：

A = LOAD 'a.txt' AS (col1:int, col2:int, col3:int, col4:int);
B = GROUP A BY (col1, col2); 
C = GROUP B ALL;
D = FOREACH C GENERATE COUNT(B); 
DUMP D;

然后再来看看这些代码是如何计算出上面的结果的：
①第一行代码加载数据，没什么好说的。
②第二行代码，得到第1、2列数据的所有组合。B的数据结构为：

grunt> DESCRIBE B;
B: {group: (col1: int,col2: int),A: {col1: int,col2: int,col3: int,col4: int}}

把B DUMP出来，得到：

((1,3),{(1,3,4,7),(1,3,5,4)})
((2,7),{(2,7,0,5)})
((9,8),{(9,8,6,6)})

非常明显，(1,3)，(2,7)，(9,8)的所有组合已经被排列出来了，这里得到了若干行数据。下一步我们要做的就是统计这样的数据一共有多少行，也就得到了第1、2列的组合有多少组。
③第三和第四行代码，就实现了统计数据行数的功能。参考本文前面部分的“怎样统计数据行数”一节。就明白这两句代码是什么意思了。
这里需要特别说明的是：
a)为什么倒数第二句代码中是COUNT(B)，而不是COUNT(group)？
我们是对C进行FOREACH，所以要先看看C的数据结构：

grunt> DESCRIBE C;
C: {group: chararray,B: {group: (col1: int,col2: int),A: {col1: int,col2: int,col3: int,col4: int}}}

可见，你可以把C想像成一个map的结构，key是一个group，value是一个包（bag），它的名字是B，这个包中有N个元素，每一个元素都对应到②中所说的一行。根据②的分析，我们就是要统计B中元素的个数，因此，这里当然就是COUNT(B)了。
b)COUNT函数的作用是统计一个包（bag）中的元素的个数：

COUNT

Computes the number of elements in a bag.

这是把Tuple传给COUNT函数时发生的错误。

➤ 两个整型数相除，如何转换为浮点型，从而得到正确的结果
这个问题其实很傻，或许不用说你也知道了：假设有int a = 3 和 int b = 2两个数，在大多数编程语言里，a/b得到的是1，想得到正确结果1.5的话，需要转换为float再计算。在Pig中其实和这种情况一样，下面就拿几行数据来做个实验：

[root@localhost ~]# cat a.txt 
3    2
4    5

在Pig中：

grunt> A = LOAD 'a.txt' AS (col1:int, col2:int);                  
grunt> B = FOREACH A GENERATE col1/col2;
grunt> DUMP B;
(1)
(0)

可见，不加类型转换的计算结果是取整之后的值。
那么，转换一下试试：

grunt> A = LOAD 'a.txt' AS (col1:int, col2:int);
grunt> B = FOREACH A GENERATE (float)(col1/col2);
grunt> DUMP B;
(1.0)
(0.0)

这样转换还是不行的，这与大多数编程语言的结果一致——它只是把取整之后的数再转换为浮点数，因此当然是不行的。
文章来源：http://www.codelast.com/
正确的做法应该是：

grunt> A = LOAD 'a.txt' AS (col1:int, col2:int); 
grunt> B = FOREACH A GENERATE (float)col1/col2;  
grunt> DUMP B;
(1.5)
(0.8)

或者这样也行：

grunt> A = LOAD 'a.txt' AS (col1:int, col2:int);
grunt> B = FOREACH A GENERATE col1/(float)col2;       
grunt> DUMP B;
(1.5)
(0.8)

这与我们的通常做法是一致的，因此，你要做除法运算的时候，需要注意这一点。

➤ UNION的一个例子
假设有两个数据文件为：

[root@localhost ~]# cat 1.txt 
0    3
1    5
0    8

[root@localhost ~]# cat 2.txt 
1    6
0    9

现在要求出：在第一列相同的情况下，第二列的和分别为多少？
例如，第一列为 1 的时候，第二列有5和6两个值，和为11。同理，第一列为0的时候，第二列的和为 3+8+9=20。
计算此问题的Pig代码如下：

A = LOAD '1.txt' AS (a: int, b: int); 
B = LOAD '2.txt' AS (c: int, d: int); 
C = UNION A, B;
D = GROUP C BY $0; 
E = FOREACH D GENERATE FLATTEN(group), SUM(C.$1);
DUMP E;

输出为：

(0,20)
(1,11)

文章来源：http://www.codelast.com/
我们来看看每一步分别做了什么：
①第1行、第2行代码分别加载数据到关系A、B中，没什么好说的。
②第3行代码，将关系A、B合并起来了。合并后的数据结构为：

grunt> DESCRIBE C;
C: {a: int,b: int}

其数据为：

grunt> DUMP C;
(0,3)
(1,5)
(0,8)
(1,6)
(0,9)

③第4行代码按第1列（即$0）进行分组，分组后的数据结构为：

grunt> DESCRIBE D;
D: {group: int,C: {a: int,b: int}}

其数据为：

grunt> DUMP D;
(0,{(0,9),(0,3),(0,8)})
(1,{(1,5),(1,6)})

④最后一行代码，遍历D，将D中每一行里的所有bag(即C)的第2列(即$1)进行累加，就得到了我们要的结果。

➤ 错误“ERROR org.apache.pig.tools.grunt.Grunt - ERROR 2042: Error in new logical plan. Try -Dpig.usenewlogicalplan=false.”的可能原因
①Pig的bug，详见此链接；
②其他原因。我遇到并解决了一例。具体的代码不便在此陈列，但是基本可以说是由于自己写的Pig代码对复杂数据结构的处理不当导致的，后来我尝试更改了一种实现方式，就绕过了这个问题。关于这点，确实还是要具体问题具体分析的，在这里没有实例的话，无法给大家一个明确的解决问题的指南。

➤ 如何在Pig中使用正则表达式对字符串进行匹配
假设你有如下数据文件：

[root@localhost ~]# cat a.txt 
1    http://ui.qq.com/abcd.html
5    http://tr.qq.com/743.html
8    http://vid.163.com/trees.php
9    http:auto.qq.com/us.php

现在要找出该文件中，第二列符合“*//*.qq.com/*”模式的所有行（此处只有前两行符合条件），怎么做？
Pig代码如下：

A = LOAD 'a.txt' AS (col1: int, col2: chararray);
B = FILTER A BY col2 matches '.*//.*\\.qq\\.com/.*';  
DUMP B;

我们看到，matches关键字对 col2 进行了正则匹配，它使用的是Java格式的正则表达式匹配规则。
. 表示任意字符，* 表示字符出现任意次数；\. 对 . 进行了转义，表示匹配 . 这个字符；/ 就是表示匹配 / 这个字符。
这里需要注意的是，在引号中，用于转义的字符 \ 需要打两个才能表示一个，所以上面的 \\. 就是与正则中的 \. 是一样的，即匹配 . 这个字符。所以，如果你要匹配数字的话，应该用这种写法（\d表示匹配数字，在引号中必须用\\d）：

B = FILTER A BY (col matches '\\d.*');

文章来源：http://www.codelast.com/
最后输出结果为：

(1,http://ui.qq.com/abcd.html)
(5,http://tr.qq.com/743.html)

可见结果是正确的。

➤ 如何截取一个字符串中的某一段
在处理数据时，如果你想提取出一个日期字符串的年份，例如提取出“2011-10-26”中的“2011”，可以用内置函数 SUBSTRING 来实现：

SUBSTRING

Returns a substring from a given string.

Syntax

SUBSTRING(string, startIndex, stopIndex)

下面举一个例子。假设有数据文件：

[root@localhost ~]# cat a.txt 
2010-05-06    abc
2008-06-18    uio
2011-10-11    tyr
2010-12-23    fgh
2011-01-05    vbn

第一列是日期，现在要找出所有不重复的年份有哪些，可以这样做：

A = LOAD 'a.txt' AS (dateStr: chararray, flag: chararray);
B = FOREACH A GENERATE SUBSTRING(dateStr, 0, 4);
C = DISTINCT B;
DUMP C;

输出结果为：

(2008)
(2010)
(2011)

可见达到了我们想要的效果。
上面的代码太简单了，不必多言，唯一需要说明一下的是 SUBSTRING 函数，它的第一个参数是要截取的字符串，第二个参数是起始索引（从0开始），第三个参数是结束索引。
文章来源：http://www.codelast.com/
➤ 如何拼接两个字符串
假设有以下数据文件：

[root@localhost ~]# cat 1.txt 
abc    123
cde    456
fgh    789
ijk    200

现在要把第一列和第二列作为字符串拼接起来，例如第一行会变成“abc123”，那么使用CONCAT这个求值函数（eval function）就可以做到：

A = LOAD '1.txt' AS (col1: chararray, col2: int);
B = FOREACH A GENERATE CONCAT(col1, (chararray)col2);
DUMP B;

输出结果为：

(abc123)
(cde456)
(fgh789)
(ijk200)

注意这里故意在加载数据的时候把第二列指定为int类型，这是为了说明数据类型不一致的时候CONCAT会出错（你可以试验一下）：

ERROR org.apache.pig.tools.grunt.Grunt - ERROR 1045: Could not infer the matching function for org.apache.pig.builtin.CONCAT as multiple or none of them fit. Please use an explicit cast.

所以在后面CONCAT的时候，对第二列进行了类型转换。
另外，如果数据文件内容为：

[root@localhost ~]# cat 1.txt 
5    123
7    456
8    789
0    200

那么，如果对两列整数CONCAT：

A = LOAD '1.txt' AS (col1: int, col2: int);
B = FOREACH A GENERATE CONCAT(col1, col2);

同样也会出错：

ERROR org.apache.pig.tools.grunt.Grunt - ERROR 1045: Could not infer the matching function for org.apache.pig.builtin.CONCAT as multiple or none of them fit. Please use an explicit cast.

要注意这一点。
有人可能会问：要拼接几个字符串的话怎么办？CONCAT 套 CONCAT 就要可以了（有点笨，但管用）： CONCAT(a, CONCAT(b, c))

➤ 如何求两个数据集的重合 & 不同的数据类型JOIN会失败
假设有以下两个数据文件：

[root@localhost ~]# cat 1.txt 
123
456
789
200

以及：

[root@localhost ~]# cat 2.txt 
200
333
789

现在要找出两个文件中，相同的数据有多少行，怎么做？这也就是所谓的求两个数据集的重合。
用关系操作符JOIN，我们可以达到这个目的。在处理海量数据时，经常会有求重合的需求。所以JOIN是Pig中一个极其重要的操作。
在本例中，两个文件中有两个相同的数据行：789以及200，因此，结果应该是2。
我们先来看看正确的代码：

A = LOAD '1.txt' AS (a: int);   
B = LOAD '2.txt' AS (b: int);
C = JOIN A BY a, B BY b;
D = GROUP C ALL;
E = FOREACH D GENERATE COUNT(C);
DUMP E;

解释一下：
①第一、二行是加载数据，不必多言。
②第三行按A的第1列、B的第二列进行“结合”，JOIN之后，a、b两列不相同的数据就被剔除掉了。C的数据结构为：

C: {A::a: int,B::b: int}

C的数据为：

(200,200)
(789,789)

③由于我们要统计的是数据行数，所以上面的Pig代码中的第4、5行就进行了计数的运算。
④如果文件 2.txt 多一行数据“200”，结果会是什么？答案是：结果为3行。这个时候C的数据为：

(200,200)
(200,200)
(789,789)

所以如果你要去除重复的，还需要用DISTINCE对C处理一下：

A = LOAD '1.txt' AS (a: int);
B = LOAD '2.txt' AS (b: int);
C = JOIN A BY a, B BY b;
uniq_C = DISTINCT C;
D = GROUP uniq_C ALL;
E = FOREACH D GENERATE COUNT(uniq_C);
DUMP E;

这样得到的结果就是2了。
文章来源：http://www.codelast.com/
尤其需要注意的是，如果JOIN的两列具有不同的数据类型，是会失败的。例如以下代码：

A = LOAD '1.txt' AS (a: int);   
B = LOAD '2.txt' AS (b: chararray);
C = JOIN A BY a, B BY b;
D = GROUP C ALL;
E = FOREACH D GENERATE COUNT(C);
DUMP E;

ERROR org.apache.pig.tools.grunt.Grunt - ERROR 1107: Cannot merge join keys, incompatible types

[root@localhost ~]# cat a.txt 
5    8   9
6        0
4    3   1

其中，第二行的第二列数据是有缺失的，因此，加载数据之后，它会成为null。顺便废话一句，在处理海量数据时，数据有缺失是经常遇到的现象。
现在，我们如果要把所有缺失的数据填为 -1， 可以使用三目运算符来操作：

A = LOAD 'a.txt' AS (col1:int, col2:int, col3:int);
B = FOREACH A GENERATE col1, ((col2 is null)? -1 : col2), col3;
DUMP B;

输出结果为：

(5,8,9)
(6,-1,0)
(4,3,1)

((col2 is null)? -1 : col2) 的含义不用解释你也知道，就是当col2为null的时候将其置为-1，否则就保持原来的值，但是注意，它最外面是用括号括起来的，如果去掉括号，写成 (col2 is null)? -1 : col2，那么就会有语法错误：

ERROR org.apache.pig.tools.grunt.Grunt - ERROR 1000: Error during parsing. Encountered " "is" "is "" at line 1, column 36.

Was expecting one of （后面省略）

[root@localhost ~]# cat 1.txt 
1    (4,9)
5    
8    (3,0)
5    (9,2)
6    

这些数据的布局比较怪，我们要把它加载成什么样的schema呢？答：第一列为一个int，第二列为一个tuple，此tuple又含两个int。加载成这样的模式不是为了制造复杂度，而是为了说明后面的问题而设计的。
同时，我们也注意到，第二列数据是有缺失的。
问题：怎样求在第一列数据相同的情况下，第二列数据中的第一个整数的和分别为多少？
例如，第一列为1的数据只有一行（即第一行），因此，第二列的第一个整数的和就是4。
但是对最后一行，也就是第一列为6时，由于其第二列数据缺失，我们希望它输出的结果是0。
先来看看Pig代码：

A = LOAD '1.txt' AS (a:int, b:tuple(x:int, y:int));
B = FOREACH A GENERATE a, FLATTEN(b);
C = GROUP B BY a;
D = FOREACH C GENERATE group, SUM(B.x);
DUMP D;

结果为：

(1,4)
(5,9)
(6,)
(8,3)

我们注意到，(5,9) 这一行是由数据文件 1.txt 的第 2、4行计算得到的，其中，第2行数据有缺失，但这并不影响求和计算，因为另一行数据没有缺失。你可以这样想：一个包（bag）中有多个数，当其中一个为null，而其他不为null时，把它们相加会自动忽略null。
然而，第三行 (6,) 是不是太刺眼了？没错，因为数据文件 1.txt 的最后一行缺失了第二列，所以，在 SUM(B.x) 中的 B.x 为null就会导致计算结果为null，从而什么也输出不了。
这就与我们期望的输出有点不同了。我们希望这种缺失的数据不要空着，而是输出0。该怎么做呢？
文章来源：http://www.codelast.com/
想法1：

D = FOREACH C GENERATE group, ((IsEmpty(B.x)) ? 0 : SUM(B.x));

输出结果为：

(1,4)
(5,9)
(6,)
(8,3)

可见行不通。从这个结果我们知道，IsEmpty(B.x) 为false，即B.x不是empty的，所以不能这样做。
想法2：

D = FOREACH C GENERATE group, ((B.x is null) ? 0 : SUM(B.x));

输出结果还是与上面一样！仍然行不通。这更奇怪了：B.x既非empty，也非null，那么它是什么情况？按照我的理解，当group为6时，它应该是一个非空的包（bag），里面有一个null的东西，所以，这个包不是empty的，它也非null。我不知道这样理解是否正确，但是它看上去就像是这样的。
想法3：

D = FOREACH C GENERATE group, SUM(B.x) AS s;
E = FOREACH D GENERATE group, ((s is null) ? -1 : s);
DUMP E;

输出结果为：

(1,4)
(5,9)
(6,-1)
(8,3)

可见达到了我们想要的结果。这与本文前面部分的做法是一致的，即：先得到含null的结果，再把这个结果中的null替换为指定的值。
有人会问：就没有办法在生成数据集D的时候，就直接通过判断语句来实现这个效果吗？据我目前所知是不行的，如果哪位读者知道，不妨告知。

➤ DISTINCT操作用于去重，正因为它要把数据集合到一起，才知道哪些数据是重复的，因此，它会产生reduce过程。同时，在map阶段，它也会利用combiner来先去除一部分重复数据以加快处理速度。

➤ 如何将Pig job的优先级设为HIGH
嫌Pig job运行太慢？只需在Pig脚本的开头加上一句：

set job.priority HIGH;

即可将Pig job的优先级设为高了。

➤ “Scalars can be only used with projections”错误的原因
这个错误提示比较不直观，光看这句话是不容易发现错误所在的，但是，只要你一Google，可能就找到原因了，例如这个链接里的反馈。
在这里，我也想用一个简单的例子给大家用演示一下产生这个错误的原因之一。
假设有如下数据文件：

[root@localhost ~]$ cat 1.txt 
a    1
b    8
c    3
c    3
d    6
d    3
c    5
e    7

现在要统计：在第1列的每一种组合下，第二列为3和6的数据分别有多少条？
例如，当第1列为 c 时，第二列为3的数据有2条，为6的数据有0条；当第1列为d时，第二列为3的数据有1条，为6的数据有1条。其他的依此类推。
Pig代码如下：

A = LOAD '1.txt' AS (col1:chararray, col2:int);
B = GROUP A BY col1;
C = FOREACH B {
    D = FILTER A BY col2 == 3;
    E = FILTER A BY col2 == 6;
    GENERATE group, COUNT(D), COUNT(E);
};
DUMP C;

输出结果为：

(a,0,0)
(b,0,0)
(c,2,0)
(d,1,1)
(e,0,0)

可见结果是正确的。
文章来源：http://www.codelast.com/
那么，如果我在上面的代码中，把“D = FILTER A BY col2 == 3”不小心写成了“D = FILTER B BY col2 == 3”，就肯定会得到“Scalars can be only used with projections”的错误提示。
说白了，还是要时刻注意你每一步生成的数据的结构，眼睛睁大，千万不要用错了relation。

➤ 什么是嵌套的FOREACH/内部的FOREACH
嵌套的（nested）FOREACH和内部的（inner）FOREACH是一个意思，正如你在本文第(35)条中所见，一个FOREACH可以对每一条记录施以多种不同的关系操作，然后再GENERATE得到想要的结果，这就是嵌套的/内部的FOREACH。

➤ 错误“Could not infer the matching function for org.apache.pig.builtin.CONCAT”的原因之一
如果你遇到这个错误，那么有可能是你在多级CONCAT嵌套的时候，没有写对语句，例如“CONCAT(CONCAT(CONCAT(a, b), c), d)”这样的嵌套，由于括号众多，所以写错了是一点也不奇怪的。我遇这个错误的时候，是由于CONCAT太多，自己多写了一个都没有发现。希望我的提醒能给你一点解决问题的提示。

➤ 用Pig加载HBase数据时遇到的错误“ERROR 2999: Unexpected internal error. could not instantiate 'com.twitter.elephantbird.pig.load.HBaseLoader' with arguments XXX”的原因之一
请看这个链接：《Apache Pig中文教程（进阶）》

➤ 错误“ERROR 1039: In alias XX, incompatible types in EqualTo Operator left hand side:XXX right hand side:XXX”的原因
其实这个错误提示太明显了，就是类型不匹配造成的。上面的XXX可以指代不同的类型。
这说明，前面可能有一个类型为long的字段，后面你却把它当chararray来用了，例如：

A = LOAD '1.txt' AS (col1: int, col2: long);
B = FILTER A BY col2 == '123456789';
C = GROUP B ALL;
D = FOREACH C GENERATE COUNT(B);
DUMP D;

就会出错：

ERROR 1039: In alias B, incompatible types in EqualTo Operator left hand side:long right hand side:chararray

只要把col2强制类型转换一下（或者一开始就将其类型指定为chararray）就可以解决问题。
文章来源：http://www.codelast.com/
不仅在进行数据比较中，在JOIN时也经常出现数据类型不匹配导致的错误问题。我在实际工作中发现，有的同学写了比较长的Pig代码，出现了这样的错误却不会仔细去看错误提示，而是绞尽脑汁地逐句去检查语法（语法是没有错的），结果费了很大的劲才知道是类型问题，得不偿失，还不如仔细看错误提示想想为什么。

➤ 在grunt交互模式下，如何在编辑Pig代码的时候跳到行首和行末/行尾
在grunt模式下，如果你写了一句超长的Pig代码，那么，你想通过HOME/END键跳到行首和行末是做不到的。
按HOME时，Pig会在你的光标处插入一个“1~”：

A = LOAD '1.txt' AS (col: int1~);

按END时，Pig会在你的光标处插入一个“4~”：

A = LOAD '1.txt' AS (col: int4~);

正确的做法是：按Ctrl+A 和 Ctrl+E 代替 HOME 和 END，就可以跳到行首和行末了。

➤ 不能对同一个关系（relation）进行JOIN
假设有如下文件：

[root@localhost ~]# cat 1.txt 
1    a
2    e
3    v
4    n

我想对第一列这样JOIN：

A = LOAD '1.txt' AS (col1: int, col2: chararray); 
B = JOIN A BY col1, A BY col1;

那么当你试图 DUMP B 的时候，会报如下的错：

ERROR org.apache.pig.tools.grunt.Grunt - ERROR 1108: Duplicate schema alias: A::col1 in "B"

这是因为Pig会弄不清JOIN之后的字段名——两个字段均为A::col1，使得一个关系（relation）中出现了重复的名字，这是不允许的。
文章来源：http://www.codelast.com/
要解决这个问题，只需将数据LOAD两次，并且给它们起不同的名字就可以了：

grunt> A = LOAD '1.txt' AS (col1: int, col2: chararray);
grunt> B = LOAD '1.txt' AS (col1: int, col2: chararray);
grunt> C = JOIN A BY col1, B BY col1;                   
grunt> DESCRIBE C;
C: {A::col1: int,A::col2: chararray,B::col1: int,B::col2: chararray}
grunt> DUMP C;
(1,a,1,a)
(2,e,2,e)
(3,v,3,v)
(4,n,4,n)

从上面的 C 的schema，你可以看出来，如果对同一个关系A的第一列进行JOIN，会导致schema中出现相同的字段名，所以当然会出错。

➤ 外部的JOIN(outer JOIN)
初次使用JOIN时，一般人使用的都是所谓的“内部的JOIN”(inner JOIN)，也即类似于 C = JOIN A BY col1, B BY col2 这样的JOIN。Pig也支持“外部的JOIN”(outer JOIN)，下面就举一个例子。
假设有文件：

[root@localhost ~]# cat 1.txt 
1    a
2    e
3    v
4    n

以及：

[root@localhost ~]# cat 2.txt 
9    a
2    e
3    v
0    n

现在来对这两个文件的第一列作一个outer JOIN：

grunt> A = LOAD '1.txt' AS (col1: int, col2: chararray);
grunt> B = LOAD '2.txt' AS (col1: int, col2: chararray);
grunt> C = JOIN A BY col1 LEFT OUTER, B BY col1;
grunt> DESCRIBE C;
C: {A::col1: int,A::col2: chararray,B::col1: int,B::col2: chararray}
grunt> DUMP C;
(1,a,,)
(2,e,2,e)
(3,v,3,v)
(4,n,,)

在outer JOIN中，“OUTER”关键字是可以省略的。从上面的结果，我们注意到：如果换成一个inner JOIN，则两个输入文件的第一、第四行都不会出现在结果中（因为它们的第一列不相同），而在LEFT OUTER JOIN中，文件1.txt的第一、四行却被输出了，所以这就是LEFT OUTER JOIN的特点：对左边的记录来说，即使它与右边的记录不匹配，它也会被包含在输出数据中。
文章来源：http://www.codelast.com/
同理可知RIGHT OUTER JOIN的功能——把上面的 LEFT 换成 RIGHT，结果如下：

(,,0,n)
(2,e,2,e)
(3,v,3,v)
(,,9,a)

可见，与左边的记录不匹配的右边的记录被保存了下来，而左边的记录没有保存下来（两个逗号表明其为空），这就是RIGHT OUTER JOIN的效果，与我们想像的一样。
有人会问，OUTER JOIN在实际中可以用来做什么？举一个例子：可以用来求“不在某数据集中的那些数据（即：不重合的数据）”。还是以上面的两个数据文件为例，现在我要求出 1.txt 中，第一列不在 2.txt 中的第一列的那些记录，肉眼一看就知道，1和4这两个数字在 2.txt 的第一列里没有出现，而2和3出现了，因此，我们要找的记录就是：

1    a
4    n

要实现这个效果，Pig代码及结果为：

grunt> A = LOAD '1.txt' AS (col1: int, col2: chararray);
grunt> B = LOAD '2.txt' AS (col1: int, col2: chararray);
grunt> C = JOIN A BY col1 LEFT OUTER, B BY col1;        
grunt> DESCRIBE C;                 
C: {A::col1: int,A::col2: chararray,B::col1: int,B::col2: chararray}
grunt> D = FILTER C BY (B::col1 is null); 
grunt> E = FOREACH D GENERATE A::col1 AS col1, A::col2 AS col2;
grunt> DUMP E;
(1,a)
(4,n)

可见，我们确实找出了“不重合的记录”。在作海量数据分析时，这种功能是极为有用的。
最后来一个总结：
假设有两个数据集（在1.txt和2.txt中），分别都只有1列，则如下代码：

A = LOAD '1.txt' AS (col1: chararray);
B = LOAD '2.txt' AS (col1: chararray);  
C = JOIN A BY col1 LEFT OUTER, B BY col1;
D = FILTER C BY (B::col1 is null);
E = FOREACH D GENERATE A::col1 AS col1;                 
DUMP E;

计算结果为：在A中，但不在B中的记录。

➤ JOIN的优化
请看这个链接：《Apache Pig中文教程（进阶）》

➤ GROUP时按所有字段分组可以用GROUP ALL吗
假设你有如下数据文件：

[root@localhost ~]# cat 3.txt 
1    9
2    2
3    3
4    0
1    9
1    9
4    0

现在要找出第1、2列的组合中，每一种的个数分别为多少，例如，(1,9)组合有3个，(4,0)组合有两个，依此类推。
显而易见，我们只需要用GROUP就可以轻易完成这个任务。于是写出如下代码：

A = LOAD '3.txt' AS (col1: int, col2: int);
B = GROUP A ALL;
C = FOREACH B GENERATE group, COUNT(A);
DUMP C;

可惜，结果不是我们想要的：

(all,7)

为什么呢？我们的本意是按所有列来GROUP，于是使用了GROUP ALL，但是这实际上变成了统计行数，下面的代码就是一段标准的统计数据行数的代码：

A = LOAD '3.txt' AS (col1: int, col2: int);
B = GROUP A ALL;
C = FOREACH B GENERATE COUNT(A);
DUMP C;

因此，上面的 C = FOREACH B GENERATE group, COUNT(A) 也无非就是多打印了一个group的名字（all）而已——group的名字被设置为“all”，这是Pig帮你做的。
文章来源：http://www.codelast.com/
正确的做法很简单，只需要按所有字段GROUP，就可以了：

A = LOAD '3.txt' AS (col1: int, col2: int);
B = GROUP A BY (col1, col2);
C = FOREACH B GENERATE group, COUNT(A);
DUMP C;

结果如下：

((1,9),3)
((2,2),1)
((3,3),1)
((4,0),2)

这与我们前面分析的正确结果是一样的。

➤ 在Pig中使用中文字符串
有读者来信问我，如何在Pig中使用中文作为FILTER的条件？我做了如下测试，结论是可以使用中文。
数据文件 data.txt 内容为（每一列之间以TAB为分隔符）：

1    北京市 a
2    上海市 b
3    北京市 c
4    北京市 f
5    天津市 e

Pig脚本文件 test.pig 内容为：

A = LOAD 'data.txt' AS (col1: int, col2: chararray, col3: chararray);
B = FILTER A BY (col2 == '北京市');
DUMP B;

首先，我这两个文件的编码都是UTF-8(无BOM)，在Linux命令行下，我直接以本地模式执行Pig脚本 test.pig：

pig -x local test.pig

得到的输出结果为：

(1,北京市,a)
(3,北京市,c)
(4,北京市,f)

可见结果是正确的。
文章来源：http://www.codelast.com/
但是，如果我在grunt交互模式下，把 test.pig 的内容粘贴进去执行，是得不到任何输出结果的：

grunt> A = LOAD 'data.txt' AS (col1: int, col2: chararray, col3: chararray);
grunt> B = FILTER A BY (col2 == '北京市');
grunt> DUMP B;

具体原因我不清楚，但是至少有一点是肯定的：可以使用中文作为FILTER的条件，只要不在交互模式下执行你的Pig脚本即可。

➤ 如何统计 tuple 中的 field 数，bag 中的 tuple 数，map 中的 key/value 组数
一句话：用Pig内建的 SIZE 函数：

Computes the number of elements based on any Pig data type.

具体可看这个链接。

➤ 一个字符串为null，与它为空不一定等价
在某些情况下，要获取“不为空”的字符串，仅仅用 is not null 来判断是不够的，还应该加上 SIZE(field_name) > 0 的条件：

B = FILTER A BY (field_name is not null AND (SIZE(field_name) > 0L));

注意，这只是在某些情况下需要这样做，在一般情况下，仅用 is not null 来过滤就可以了。我并没有总结出特殊情况是哪些情况，我只能说我我不是第一次遇到此情况了，所以才有了这一个结论。
注意上面使用的是“0L”，因为SIZE()返回的是long类型，如果不加L，在Pig0.10下会出现一个警告，例如：

[main] WARN  org.apache.pig.PigServer - Encountered Warning IMPLICIT_CAST_TO_LONG 1 time(s)

➤ Pig中的各operator（操作符），哪些会触发reduce过程
①GROUP：由于GROUP操作会将所有具有相同key的记录收集到一起，所以数据如果正在map中处理的话，就会触发shuffle→reduce的过程。
②ORDER：由于需要将所有相等的记录收集到一起（才能排序），所以ORDER会触发reduce过程。同时，除了你写的那个Pig job之外，Pig还会添加一个额外的M-R job到你的数据流程中，因为Pig需要对你的数据集做采样，以确定数据的分布情况，从而解决数据分布严重不均的情况下job效率过于低下的问题。
③DISTINCT：由于需要将记录收集到一起，才能确定它们是不是重复的，因此DISTINCT会触发reduce过程。当然，DISTINCT也会利用combiner在map阶段就把重复的记录移除。
④JOIN：JOIN用于求重合，由于求重合的时候，需要将具有相同key的记录收集到一起，因此，JOIN会触发reduce过程。
⑤LIMIT：由于需要将记录收集到一起，才能统计出它返回的条数，因此，LIMIT会触发reduce过程。
⑥COGROUP：与GROUP类似（参看本文前面的部分），因此它会触发reduce过程。
⑦CROSS：计算两个或多个关系的叉积。

➤ 如何统计一个字符串中包含的指定字符数
这可以不算是个Pig的问题了，你可以把它认为是一个shell的问题。从本文前面部分我们已经知道，Pig中可以用 STREAM ... THROUGH 来调用shell进行辅助数据处理，所以在这我们也能这样干。
假设有文本文件：

[root@localhost ~]$ cat 1.txt 
123    abcdef:243789174
456    DFJKSDFJ:3646:555558888
789    yKDSF:00000%0999:2343324:11111:33333

现在要统计：每一行中，第二列里所包含的冒号（“:”）分别为多少？代码如下：

A = LOAD '1.txt' AS (col1: chararray, col2: chararray);
B = STREAM A THROUGH `awk -F":" '{print NF-1}'` AS (colon_count: int);
DUMP B;

结果为：

(1)
(2)
(4)

文章来源：http://www.codelast.com/
➤ UDF是区分大小写的
因为UDF是由Java类来实现的，所以区分大小写，就这么简单。

➤ 设置Pig job的job name
在Pig脚本开头加上一句：

set job.name 'My-Job-Name';

那么，执行该Pig脚本之后，在Hadoop的Job Tracker中看到的“Name”就是“My-Job-Name”了。
如果不设置，显示的name是类似于“Job6245768625829738970.jar”这样的东西，job多的时候完全没有标识度，建议一定要设置一个特殊的job name。

➤ 把纯文本转化为JSON
假设输入文件 a.txt 内容为：

1    2
9    8

则如下Pig代码将把它转化为JSON格式：

A = LOAD 'a.txt' AS (col1: chararray, col2: chararray);
B = STORE A INTO 'result' USING JsonStorage();

查看输出文件的内容是：

{"col1":"1","col2":"2"}
{"col1":"9","col2":"8"}

可见，你LOAD输入数据时定义的字段名，就是输出文件中的JSON字段名。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：