import mysql.connector
import sys

__author__ = 'codelast'

username = 'root'
password = 'xxx'
host = '127.0.0.1'
db = 'mydb'

connection = mysql.connector.connect(user=username, password=password, host=host, database=db)
cursor = connection.cursor()

sql = "SELECT * FROM my_table WHERE id = 9"
try:
    cursor.execute(sql)

    # 打印查询到的记录的行数
    data = cursor.fetchall()
    print(len(data))

    # 输出所有记录
    for (ID, name) in data:
        print("name:[%s]" % (name))

except mysql.connector.Error as err:
    print("Failed to query table, detail: {}".format(err.msg))
    sys.exit()

connection.commit()
cursor.close()
connection.close()

上面的代码很简单，无非就是从my_table表里查询一些记录，再打印出来。
注意 for (ID, name) 中的括号里要写全该表中，你查询的所有字段名，否则会报错。还有其他遍历查询结果的方法，后面会继续陈述。

 逆序遍历list

myList = [1, 2, 3]
for item in reversed(myList):
    print(item)

输出：

3
2
1

注意是 reversed 不是 reverse。这只是逆序遍历，myList中的数据顺序并不会改变。
文章来源：http://www.codelast.com/
 使用MySQLdb访问数据库时，“TypeError: execute() takes at most 3 arguments (4 given)”错误的解决办法
Python版本：2.7.3
使用2.7.3版本的Python时，访问MySQL的最佳方案应该数使用MySQLdb了。
如果在执行SQL时，你遇到了上面所说的问题，那么你可能是像下面这样写导致的：

sql = "INSERT INTO my_table (field1, field2) VALUES (%s, %s)"
cursor.execute(sql, "a", "b")

这是错误的，其实根本不是这样用的，当参数多于一个时，你要把它们放在一个tuple里传进去：

sql = "INSERT INTO my_table (field1, field2) VALUES (%s, %s)"
cursor.execute(sql, ("a", "b"))

例如这个链接有个例子。

 使用 lxml 库生成XML（字符串）
Python版本：2.7.3
直接看代码：

#coding:UTF-8
"""
XML生成器。文件名：xmlGenerator.py
"""

__author__ = 'Darran Zhang @ codelast.com'

from lxml import etree


class XMLGenerator:
    def __init__(self):
        pass

    def generate_xml(self):
        commands = etree.Element('Commands')
        command = etree.SubElement(commands, 'Command')
        from_user = etree.SubElement(command, 'FromUser')
        from_user.text = u'abc'
        cmd = etree.SubElement(command, 'Cmd')
        cmd.text = u'mmmmmmmmmmmmmm'
        cmd_extra_data = etree.SubElement(command, 'CmdExtraData')
        cmd_extra_data.text = u'eeeeeeeeee'

        return etree.tostring(commands, pretty_print=True, xml_declaration=True, encoding='utf-8')

测试代码：
from xmlGenerator import XMLGenerator

xmlGen = XMLGenerator()
print(xmlGen.generate_xml())

测试代码：

from xmlGenerator import XMLGenerator

xmlGen = XMLGenerator()
print(xmlGen.generate_xml())

输出：

<?xml version='1.0' encoding='utf-8'?>

<Commands>
  <Command>
    <FromUser>abc</FromUser>
    <Cmd>mmmmmmmmmmmmmm</Cmd>
    <CmdExtraData>eeeeeeeeee</CmdExtraData>
  </Command>

</Commands>

可见非常简单。

 对一个字典(dict)，按value进行排序
Python版本：2.6.6，2.6.9均测试可用（Python3里没有cmp方法了，所以不能用）

sortedList = sorted(myDict.items(), lambda x, y: cmp(x[1], y[1]), reverse=True)
for (k, v) in sortedList:
    print("{0}\t{1}".format(k,v))

其中，myDict是你要将其排序的字典，sortedList是排序之后的结果，变成了一个list，里面是若干个tuple，每个tuple里是一对(key,value)，所以后面用那样的方式对它进行了遍历。
文章来源：http://www.codelast.com/
 Python正则简单示例
先看代码：

code = 'String url = "http://item.jd.com/1148104.html?erpad_source=abc";'
pattern = re.compile('.*\"(.*)\"')
match = pattern.match(code)
if match:
    print(match.group(1))

输出：

http://item.jd.com/1148104.html?erpad_source=abc

说明：上面的代码是想把字符串“code”中的双引号里的那个URL打印出来。正则表达式 .*\"(.*)\" 中的小括号就是第1个group，匹配上的话可以用 group(1) 获取之。

 循环一个日期段
Python版本：3.6.8
循环打印出 2019-07-29 ～ 2019-08-05 的日期：

import datetime


def loop_date():
    begin = datetime.date(2019, 7, 29)
    end = datetime.date(2019, 8, 5)
    for i in range((end - begin).days + 1):
        day_str = str(begin + datetime.timedelta(days=i))
        print(day_str)


if __name__ == '__main__':
    loop_date()

输出：

2019-07-29

2019-07-30

2019-07-31

2019-08-01

2019-08-02

2019-08-03

2019-08-04

2019-08-05

文章来源：http://www.codelast.com/
 以 yyyy-MM-dd HH:mm:ss 格式打印出当前时间
Python版本：3.6.8

import time

print(time.strftime("%Y-%m-%d %H:%M:%S"))

 写MySQL
Python版本：3.6.8
在Anaconda下安装MySQLdb，会同时安装上的依赖包太多了，所以我转而使用 pymsql 来写MySQL：

conda install -c anaconda pymysql

之后的Python程序就非常简单了：
（1）连接MySQL

db = pymysql.connect("127.0.0.1", "root", "my_password", "my_db_name", charset='utf8')

（2）向MySQL写数据

cursor = db.cursor()

sql = "xxx"  # 必须为合法的SQL语句

cursor.execute(sql)

db.commit()

文章来源：http://www.codelast.com/
 set的 type hint 怎么写
Python版本：3.6.9
直接看代码：

from typing import Set


def type_hint_of_set() -> Set[int]:
    a = set()
    a.add(2)
    a.add(5)
    a.add(8)
    a.add(2)
    return a


b = type_hint_of_set()
print(type(b))
print(b)

输出：

<class 'set'>

{8, 2, 5}

文章来源：http://www.codelast.com/
 用阿里镜像为 pip install 命令加速
创建文件 ~/.pip/pip.conf
添加以下内容：

[global]

index-url = http://mirrors.aliyun.com/pypi/simple/

 

[install]

trusted-host=mirrors.aliyun.com

再使用 pip install 就会体验到飞一般的感觉。

 使用 f string 格式化字符串时控制小数位数
Python版本：3.6.9

a: float = 32.67890123
print(f'{a:.2f}')

输出：
32.68
其中，.2表示小数点后保留两位小数。如果不加“f”，则输出变成了科学计数法：
3.3e+01

 获取当前用户的home目录
Python版本：3.6.9

from pathlib import Path

home_dir = str(Path.home())
print(home_dir)

输出：
Mac下类似于：/Users/codelast
Linux下类似于：/home/codelast

 计算分位数
输入文件 1.txt 一行为一个数，要看一下它们的分布情况（输入文件中的数据顺序不会影响输出结果）：

import numpy as np

file = open('/home/codelast/1.txt')
list1 = []
for line in file:
    list1.append(int(line.strip()))

a = np.array(list1)
print(np.percentile(a, 0))
print(np.percentile(a, 10))
print(np.percentile(a, 20))
print(np.percentile(a, 30))
print(np.percentile(a, 40))
print(np.percentile(a, 50))
print(np.percentile(a, 60))
print(np.percentile(a, 70))
print(np.percentile(a, 80))
print(np.percentile(a, 90))
print(np.percentile(a, 100))

输出：

1.0

3.0

4.0

5.0

6.0

7.0

9.0

14.0

21.0

42.0

3572.0

这表示：有0%的值<1.0（或者说所有值都>=1.0），10%的值<3.0，20%的值<4.0，...，100%的值<=3572。

文章来源：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 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

 当你把一个文件加入distribution cache的时候，要注意：如果你是以addCacheFile()的方式添加的，而你在mapper中取出来的时候，却是以archive的方式取出来——getLocalCacheArchives()，那么，你将得不到cache文件的路径，因为放进去和取出来的方式要一致。

 在mapper中获取当前正在处理的HDFS文件名/HDFS目录名

有时候，Hadoop是按行来对数据进行处理的，由于对每一行数据，map()函数会被调用一次，我们有时可以根据文件名/目录名来获取一些信息，从而把它们输出，例如，目录名中包含了日期，则我们可以取出来并输出到Reducer。在map()函数中，我们可以这样取文件名：

InputSplit inputSplit = context.getInputSplit();
String fileName = ((FileSplit) inputSplit).getName();

假设当前正在处理的HDFS文件路径为：/user/hadoop/abc/myFile.txt，则上面的 fileName 取到的是“myFile.txt”这样的字符串。但如果要获取其目录名“abc”，则可以这样做：

InputSplit inputSplit = context.getInputSplit();
String dirName = ((FileSplit) inputSplit).getPath().getParent().getName();

文章来源：http://www.codelast.com/
再来一个问题：如何获取当前正在处理的HDFS文件的路径（例如 /user/hadoop/abc.txt）？方法如下：

InputSplit inputSplit = context.getInputSplit();
String filePath = ((FileSplit) inputSplit).getPath().toString();

上面的filePath得到的是形如“hdfs://xxx:43540/user/hadoop/abc.txt”的路径，如果你只想获取 /user 开始到最后的那一段路径（例如 /user/hadoop/abc.txt），需要这样做：

InputSplit inputSplit = context.getInputSplit();
String filePath = ((FileSplit) inputSplit).getPath().toUri().getPath();

 从HDFS上下载同一目录下的一堆文件
如果是从HDFS上下载一个文件到本地文件系统，这样做：

hadoop fs -get /your/hdfs/file /your/local/fs/file

但如果是要下载一个目录下的N个M-R输出文件（到一个文件），则应这样：

hadoop fs -getmerge /your/hdfs/directory /your/local/fs/file

或者你干脆把HDFS上的文件内容打印出来，重定向到一个文件：

hadoop fs -cat /your/hdfs/directory/part* > /your/local/fs/file

 关于InputFormat
具体可看这个链接。这里摘抄一段下来：

The InputFormat defines how to read data from a file into the Mapper instances. Hadoop comes with several implementations of InputFormat; some work with text files and describe different ways in which the text files can be interpreted. Others, like SequenceFileInputFormat, are purpose-built for reading particular binary file formats. These types are described in more detail in Module 4.

More powerfully, you can define your own InputFormat implementations to format the input to your programs however you want. For example, the default TextInputFormat reads lines of text files. The key it emits for each record is the byte offset of the line read (as a LongWritable), and the value is the contents of the line up to the terminating '\n' character (as a Text object). If you have multi-line records each separated by a $ character, you could write your own InputFormat that parses files into records split on this character instead.

即：InputFormat定义了如何从文件中将数据读取到Mapper的实例里。Hadoop已经自带了一些InputFormat的实现了，其中有一些用于处理文本文件，它们描述了如何解释文本文件的多个不同方法；其他的实现——例如SequenceFileInputFormat——是为读取特殊二进制文件格式而生的。
更加强大的是，你可以定义你自己的InputFormat实现来格式化输入到你程序的数据——无论你想要什么样的输入。例如，默认的TextInputFormat读取文本文件的一行行的数据。它为每条记录emit的key是正在读取的行的偏移字节（以LongWritable的形式体现），而value则是该行的内容直到结束的 \n 字符（以Text对象的形式体现）。如果你有多行记录，这些记录是以 $ 字符来分隔的，那么你可以写一个自己的InputFormat用于根据这个字符来分割解析文件。
文章来源：http://www.codelast.com/
 为什么要启用LZO压缩，现在有什么可用的Hadoop LZO实现
这篇文章很好地解释了Twitter的Hadoop LZO实践，看完它，你就明白为什么要用LZO了。
而这个项目，就是Twitter的Hadoop LZO实现，非常有用。
一句话总结就是：gzip不能将数据分块压缩，虽然减小了存储的数据量（同时也就减小了IO），但却无法利用Map-Reduce进行并行处理；bzip可以将数据分块压缩，虽然减小了存储的数据量（同时也就减小了IO），但是却在解压的时候很慢，耗费掉太多的CPU资源，从而导致CPU处理速度跟不上读取压缩文件的速度；LZO在这二者之间达到了一个平衡，虽然其压缩比没有gzip那么高，却可以分块压缩（从而可以利用Map-Reduce进行并行处理），并且其解压速度非常快，整体上达到的效果就是：减小了数据存储量，减小了IO，虽然CPU资源比原来占用多了一些，但是Hadoop集群整体上的计算能力提升了很多。

 启动Haoop进程时的错误及解决方法：localhost: ssh: connect to host localhost port 22: Connection refused
启动Hadoop进程时可用Hadoop安装目录下的 bin/start-all.sh 脚本，如果执行该脚本提示错误：

localhost: ssh: connect to host localhost port 22: Connection refused

sudo apt-get install openssh-server

检查防火墙状态：

sudo ufw status

如果防火墙是打开的，那么还要确保22端口是允许连接的。
可以在开机启动时就启动Hadoop进程：编辑 /etc/rc.local 文件，添加一行即可：

/usr/local/hadoop/bin/start-all.sh

当然，需视情况改成你的Hadoop安装路径。

 在 Hadoop Map/Reduce Administration 的web页面中看不到运行中的job（Running Jobs）的可能原因
可能是 TaskTracker 没有启动，导致无法在页面中看到任何Running Jobs。这时你可以先查看一下其是否启动了：

ps -ef | grep java

里面应该有 org.apache.hadoop.mapred.TaskTracker 这一项。
如果没有，则可以重启Hadoop进程试试看。

 向HDFS中put文件时揭示“Name node is in safe mode”的原因及解决办法
向HDFS中put文件时，如果揭示：

put: org.apache.hadoop.hdfs.server.namenode.SafeModeException: Cannot create file /XXX. Name node is in safe mode.

原因很显然了，name node处于安全模式，解决办法也很简单：kill掉name node的进程，然后重启之：

ps -ef | grep java

用该命令查看name node进程的PID，然后kill掉，然后再启动之：

start-dfs.sh

再确定一下name node进程是否启动了，如果成功启动了，就OK了。
文章来源：http://www.codelast.com/
这里有一个批量kill进程的技巧，其实就是几句shell语句：

PIDS=`ps -ef | grep -v grep | grep java | awk '{print $2}'`; for PID in $PIDS; do kill $PID; done

其中，“grep java”表示查找含有“java”关键字的进程名，“grep -v grep”表示过滤掉grep自己的这个进程名，awk 是用于打印出第2列的内容，即PID（进程号），而后面的 for 循环则是批量kill掉找到的进程。

 在shell中判断一个HDFS目录/文件是否存在
直接看shell代码：

hadoop fs -test -e /hdfs_dir
if [ $? -ne 0 ]; then
    echo "Directory not exists!"
fi

hadoop fs -test -e 用于判断HDFS目录/文件是否存在，下一步检测该命令的返回值，以确定其判断结果。

-test -[ezd] <path>: If file { exists, has zero length, is a directory

then return 0, else return 1.

hbase(main):005:0> describe 'TableName'
DESCRIPTION                                                             ENABLED                               
 {NAME => 'TableName', FAMILIES => [{NAME => 'fam', COMPRESSION = > 'NONE', VERSIONS => '2', TTL => '2147483647', BLOCKSIZE => '65536', IN_MEMORY => 'false', BLOCKCACHE => 'true'}]}

里面的TTL的单位是秒，不做特别设置的时候，就是这个默认值（约为69年），超过此时间的记录会被删除。

 HBase中的VERSIONS(版本)的含义
如上例所示，你已经看到了VERSIONS这个参数，假设其值为2，那么它表示：row key、column family、qualifier 都相同的记录最多可以有2条，这2条记录的timestamp不同。例如用hbase shell查到的下面两条记录：

abc     column=fam:\x11\x00\x00\x99, timestamp=1325260900000, value=?\x80\x00\x00
abc     column=fam:\x11\x00\x00\x99, timestamp=1326828800000, value=?\x80\x00\x00

其中，“abc”是row key，“fam”是column family，“\x11\x00\x00\x99”是qualifier，这三者均相同，而这两条记录的timestamp不同，也就是VERSIONS为2。

 context.progress()的作用
假设在map()方法中，你有一个从数据库读取大量数据的操作，是用一个循环来完成的，并且，在读完全部的数据之前，你不会有任何的数据输出（纯读），那么，读完全部数据所需的时间可能很长，一直没有输出的话，这个task就会因为超时被杀掉，为了避免这个问题，可在以读取数据的循环中使用context.progress()方法来报告进度，那么该task就会被认为还活着，从而解决超时问题。

 Map-Reduce的单元测试，用MRUnit来做
我们不可能把每个M-R job都放到到实际的环境中去运行，靠打印log来调试其中的问题，单元测试是必须的，M-R的单元测试用MRUnit来做。
①MRUnit有两个ReduceDriver，一个是 org.apache.hadoop.mrunit.mapreduce.ReduceDriver，另一个是 org.apache.hadoop.mrunit.ReduceDriver，其中，前者是为更新的Hadoop API准备的，如果你发现IDE在ReduceDriver这里提示错误，但是又不知道哪里写错了的时候，可以查看一下是否是这个问题。
②在测试一个mapper类中的时候，MRUnit的setUp()函数比mapper类的setup(Context context)函数要先执行。

 调用一个Java Map-Reduce程序时，在命令行传入参数“-D mapred.queue.name=XXX”的作用
Hadoop集群中的job被分在不同的队列中，如果不设置mapred.queue.name参数，则job被放置在默认队列中，否则就被放在指定的队列中。各队列之间是有优先级之分的，同一个队列中的各job也有优先级之分，所以，我们需要的话，可以既设置队列，又设置job的优先级：

-D mapred.queue.name=XXX
-D mapred.job.priority=HIGH

这表示设置优先级为HIGH。
文章来源：http://www.codelast.com/
 继承自org.apache.hadoop.hbase.mapreduce.TableMapper这个抽象类的一个mapper类，当它的map()方法每被调用一次时，就有HBase的一行(row)被读入处理，由于是处理一行，所以对一个map()方法来说，row key是唯一的，column family可能有N个，每个column family下又可能有M个qualifier，每一个qualifier还可能会对应X个timestamp的记录（取决于你HBase的VERSIONS设置），你可以在map()方法中，一级级地遍历得到所有记录。

 在大多数情况下，一个split里的数据（由一个mapper所处理）是来自于同一个文件的；少数情况下，一个split里的数据是来自多个文件的。

 org.apache.hadoop.mapreduce.lib.output 和 org.apache.hadoop.mapreduce.output 这两个package都有 TextOutputFormat 类，其中，前者比后者版本新，使用的时候注意。

 执行Map-Reduce Java程序时，传入 -D hadoop.job.ugi=hadoop,hadoop 参数可以使得该job以hadoop用户来执行，例如，你是以Linux root用户来执行一个脚本，脚本中执行了一个M-R Java程序，那么该程序就无法将输出结果写入到HDFS上的 /user/hadoop/ 目录下，如果按上面的方法传入一个参数，就解决了这个问题：

hadoop com.codelast.DoSomething -D hadoop.job.ugi=hadoop,hadoop

其中，com.codelast.DoSomething是你的M-R Java程序。

 用MRUnit怎么测试含有FileSplit.getPath()的方法
如果mapper中的一个方法myMethod(Context context)含有如下代码片段：

String fileName = ((FileSplit) context.getInputSplit()).getPath().getName();

这句话是用来取当前mapper正在处理的文件名。那么，方法myMethod()就不能用MRUnit来测，因为无法使用MRUnit来设置mapper中当前正在处理的文件。为了测这个方法，你需要把上面的代码段抽取出来，单独放在一个方法中，我们假设其为：

public int getName(Context context) {
    return ((FileSplit) context.getInputSplit()).getPath().getName();
}

然后，在单元测试文件中，你的tester类里重写这个方法，自己指定一个返回值：

@Test
public void test_1() throws IOException {
	mapper = new MyMapper() {
	  @Override
	  public int getName(Context context) {
		return "part-r-00000";
	  }
	};

	Configuration configuration = new Configuration();
	mapDriver.withConfiguration(configuration);
	mapDriver.withMapper(mapper);
	
	mapDriver.withInput(new LongWritable(1), new Text("XXXXXX"));
	//TODO:
}

其中，MyMapper是你的mapper类名，在这里我们强制指定了getName方法返回一个字段串“part-r-00000”，从而在下面的“//TODO:”测试代码中，就可以在调用待测的myMethod方法时（间接地会调用getName方法），自然会得到“part-r-00000”这个字符串。

 HBase中的Pair类
如果你只要保存一对对象，那么Map可能不好用，你可以用 org.apache.hadoop.hbase.util 包中的 Pair<T1, T2> 类：

Pair<String, String> aPair = new Pair<String, String>("abc", "def");
String firstStr = aPair.getFirst();
String secondStr = aPair.getSecond();

显然，getFirst()方法用于取第一个值，getScond()方法用于取第二个值。

 用MRUnit测试mapper时，如何避开从 DistributedCache 加载文件
可以在unit test里set一个值到 Configuration 对象中，在mapper里判断这个变量是否set了，set了就从用于测试的local file读数据，没有set就从DistributedCache读文件。
当然，也可以让DistributedCache加载一个本地文件：

Configuration conf = new Configuration();

String myFile = "localFile.txt";
DistributedCache.setLocalFiles(conf, myFile);

文章来源：http://www.codelast.com/
 只有map的job，如何在一定程度上控制map的数量
如果一个job只有map，那么，map的数量就是输出文件的数量，为了能减少输出文件的数量，可以采用减少map的数量的方法，那么，如何减少呢？其中一个办法是设置最小的input split size。例如以下代码：

FileInputFormat.setMinInputSplitSize(job, 2L * 1024 * 1024 * 1024);

将使得小于 2G 的输入文件不会被分割处理。如果你的输入文件中有很多都是小于2G的，并且你的Hadoop集群配置了一个split的大小是默认的64M，那么就会导致一个1点几G的文件就会被很多个map处理，从而导致输出文件数量很多。使用上面的方法设置了min input split size之后，减小输出文件数量的效果很明显。

 如何使用elephant-bird的 LzoTextOutputFormat 对纯文本数据进行LZO压缩
假设你有一堆纯文本数据，要将它们用LZO来压缩，那么，可以用elephant-bird的 LzoTextOutputFormat 来实现。
一个只有map的job就可以完成这个工作，你需要做的，首先是设置输出格式：

job.setMapperClass(MyMapper.class);
job.setOutputFormatClass(LzoTextOutputFormat.class);

其次，你需要这样的一个mapper类：

public static class MyMapper extends Mapper<LongWritable, Text, NullWritable, Text> {

  protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    context.write(null, value);
  }
}

其余代码此处省略。

 如何使MapReduce job执行开始时不检查某目录是否已经存在
如果M-R job的HDFS输出目录已经存在，那么job执行时会报错。为了让它不检查，或者改变默认的检查办法（例如，我们会在HDFS输出目录下生成几个子目录，在里面输出最终数据，只要确保这几个子目录不存在即可），那么就需要override checkOutputSpecs 这个方法：

  @Override
  public void checkOutputSpecs(JobContext job) throws IOException {
    //TODO:
  }

在这里面，你只要把exception吃掉即可使得输出目录存在时不会报错。

 使用HBase的程序报错“java.lang.NoSuchMethodError: org.apache.hadoop.hbase.client.HTable.<init>”的一个原因
如果你的程序使用了HBase，并且有HDFS操作（即使用了hadoop的jar包），那么出现上面所说的错误提示时，请检查Hadoop的安装路径下的lib目录下，HBase的jar包版本是否与你的程序路径下的HBase jar包版本相同，如果不同，那么就有可能导致这个问题。

 实现了接口 org.apache.hadoop.util.Tool 的类，必须要实现 setConf() 和 getConf() 方法吗
当然要实现。通常是下面这样的两个方法：

  @Override
  public void setConf(Configuration entries) {
    this.configuration = entries;
  }

  @Override
  public Configuration getConf() {
    return this.configuration;
  }

如果不想实现这两个方法，那么只需要把你的类继承自 org.apache.hadoop.conf.Configured 即可，例如：

public class A extends Configured implements Tool {
    //TODO:
}

这样可以少写两个方法，代码更简洁一些。

 如果mapper的输出value为一个 ThriftWritable 类型的对象，在设置Hadoop job属性时，setMapOutputValueClass() 应该怎样写
假设你的mapper类是这样定义的：

public class A extends Mapper<LongWritable, Text, Text, ThriftWritable<MyType>> {
	//TODO:
}

其中，MyType是一个实现了 org.apache.thrift.TBase 接口的类。那么，在设置Hadoop job的属性时，我们可以这样写：

Job job = new Job(configuration, "My example job.");
job.setMapOutputValueClass(ThriftWritable.class);

这样写要注意，在reducer中取出同一个key的各value值时，需要用 setConverter() 方法来指定Thrift对象类型：

protected void reduce(Text key, Iterable<ThriftWritable<MyType>> values, Context context)
	  throws IOException, InterruptedException {
  for (ThriftWritable<MyType> value : values) {
	  value.setConverter(MyType.class);    // must set the class
	  MyType obj = value.get();
	  //TODO:
  }
}

如果你不 setConverter() 的话，将抛出一个java.lang.IllegalStateException异常，提示你无法识别类型。
文章来源：http://www.codelast.com/
 要注意在reducer中对同一个key的多个value循环取值的方法
假设在一个reduce()方法中对同一个key的多个value循环，做一些处理后取出想要的那个value，并输出：

protected void reduce(Text key, Iterable<Text> values, Context context)
	  throws IOException, InterruptedException {
	Text outputValue = null;
	for (Text value : values) {
	  //TODO: some logic processing 
	  outputValue = value;
	}

	if (outputValue != null) {
	  context.write(key, outputValue);
	}
}

那么，输出的outputValue将永远是所有value里面，最后一个循环到的value，这是因为程序会复用value这个对象，当使用 outputValue = value 这种赋值方式时，outputValue得到的是value的引用，而value又被复用了，所以outputValue最后将被赋予最后一个value的值。这可能会导致你在“TODO”那里做的处理失效（例如取了一个含有最大数字值的value），所以，为了保持逻辑正确，可以把 outputValue = value 换成：

outputValue = new Text(value);

创建一个新的对象，这样就不会出现上面所说的问题了。

 Zookeeper client的基本使用方法
如果你的一个程序要注册到Zookeeper中，你如何验证结果是正确的？当然是利用Zookeeper client来查看Zookeeper中的数据啦。
Zookeeper client程序就是Zookeeper安装目录下的 bin/zkCli.sh 脚本，执行后会进入交互命令行：

[zk: localhost:2181(CONNECTED) 0] 

查看你的程序注册的路径是否存在（假设注册到了 /abc/def ）：

[zk: localhost:2181(CONNECTED) 0] ls /abc/def

查看你的程序注册的内容是否正确：

[zk: localhost:2181(CONNECTED) 0] get /abc/def

会输出一堆内容，其中，第一行就是你写入的内容，如果正确的话就OK了。

 获取HDFS文件的checksum
命令行我不知道怎么取HDFS的checksum（不把HDFS文件download到local fs的情况下），用Hadoop API获取checksum的Java程序片段如下：

Path path = new Path("/user/abc.txt");
try {
    FileSystem fs = FileSystem.get(path.toUri(), new Configuration());
    FileChecksum fileChecksum = fs.getFileChecksum(path);
    System.out.print(fileChecksum);
    System.exit(0);
} catch (IOException e) {
    System.exit(1);
}

需要import的package是：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileChecksum;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

特别需要注意的是：就算是同一个文件，在不同的Hadoop集群上，得到的checksum也可能是不同的！这是个非常大的陷阱，例如，我拿一个小文件在两个Hadoop集群上做了试验，得到的checksum是相同的；而对一个较大的文件（其大小超过了其中一个Hadoop集群的block size），取到的checksum是不相同的。这跟Hadoop集群的block size有关，具体可以看Hadoop的源码。
文章来源：http://www.codelast.com/
 用Hadoop的文件API来操作本地/HDFS文件的基本示例

Configuration conf = new Configuration();
FileSystem hdfs = FileSystem.get(conf);
FileSystem local = FileSystem.getLocal(conf);

FileStatus[] localFiles = local.listStatus("/home/codelast/");    // a local directory 
FSDataOutputStream outputStream = hdfs.create("/user/codelast/abc.txt");    // a HDFS file 

上面的代码只演示了：对本地的一个目录进行文件列表操作，以及试图在HDFS上创建一个文件。

 MultipleOutputs.setCountersEnabled()方法的作用
官方解释：

public static void setCountersEnabled(Job job, boolean enabled)

    Enables or disables counters for the named outputs. The counters group is the MultipleOutputs class name. The names of the counters are the same as the named outputs. These counters count the number records written to each output name. By default these counters are disabled.

 

Parameters:

    job - job to enable counters

    enabled - indicates if the counters will be enabled or not.

job.setOutputFormatClass(LzoOutputFormat.class);

job.setOutputFormatClass(TextOutputFormat.class);

hadoop com.codelast.MyJob \
    -D mapred.output.compression.codec=com.hadoop.compression.lzo.LzopCodec \
    -D mapred.output.compress=true \
    ......

public class MyJob extends Configured implements Tool {
  ...
}