pig课件框架组件安装配置使用运算符运行脚本常用函数

来源：互联网发布：四川省广电网络官网编辑：程序博客网时间：2024/06/17 06:14

Apache Pig架构

用于使用Pig分析Hadoop中的数据的语言称为 Pig Latin ，是一种高级数据处理语言，它提供了一组丰富的数据类型和操作符来对数据执行各种操作。

要执行特定任务时，程序员使用Pig，需要用Pig Latin语言编写Pig脚本，并使用任何执行机制（Grunt Shell，UDFs，Embedded）执行它们。执行后，这些脚本将通过应用Pig框架的一系列转换来生成所需的输出。

在内部，Apache Pig将这些脚本转换为一系列MapReduce作业，因此，它使程序员的工作变得容易。Apache Pig的架构如下所示。

Apache Pig组件

如图所示，Apache Pig框架中有各种组件。让我们来看看主要的组件。

Parser（解析器）

最初，Pig脚本由解析器处理，它检查脚本的语法，类型检查和其他杂项检查。解析器的输出将是DAG（有向无环图），它表示Pig Latin语句和逻辑运算符。在DAG中，脚本的逻辑运算符表示为节点，数据流表示为边。

Optimizer（优化器）

逻辑计划（DAG）传递到逻辑优化器，逻辑优化器执行逻辑优化，例如投影和下推。

Compiler（编译器）

编译器将优化的逻辑计划编译为一系列MapReduce作业。

Execution engine（执行引擎）

最后，MapReduce作业以排序顺序提交到Hadoop。这些MapReduce作业在Hadoop上执行，产生所需的结果。

Pig Latin数据模型

Pig Latin的数据模型是完全嵌套的，它允许复杂的非原子数据类型，例如 map 和 tuple 。下面给出了Pig Latin数据模型的图形表示。

Atom（原子）

Pig Latin中的任何单个值，无论其数据类型，都称为 Atom 。它存储为字符串，可以用作字符串和数字。int，long，float，double，chararray和bytearray是Pig的原子值。一条数据或一个简单的原子值被称为字段。例:“raja“或“30"

Tuple（元组）

由有序字段集合形成的记录称为元组，字段可以是任何类型。元组与RDBMS表中的行类似。例:（Raja，30）

Bag（包）

一个包是一组无序的元组。换句话说，元组（非唯一）的集合被称为包。每个元组可以有任意数量的字段（灵活模式）。包由“{}"表示。它类似于RDBMS中的表，但是与RDBMS中的表不同，不需要每个元组包含相同数量的字段，或者相同位置（列）中的字段具有相同类型。

例:{（Raja，30），（Mohammad，45）}

包可以是关系中的字段；在这种情况下，它被称为内包（inner bag）。

例:{Raja，30， {9848022338，raja@gmail.com，} }

Map（映射）

映射（或数据映射）是一组key-value对。key需要是chararray类型，且应该是唯一的。value可以是任何类型，它由“[]"表示，

例:[name＃Raja，age＃30]

Relation（关系）

一个关系是一个元组的包。Pig Latin中的关系是无序的（不能保证按任何特定顺序处理元组）。

Apache Pig 安装

先决条件

在你运行Apache Pig之前，必须在系统上安装好Hadoop和Java。

下载ApachePig

首先，从以下网站下载最新版本的Apache Pig:https://pig.apache.org/

pig-0.16.0.tar.gz

安装ApachePig

下载Apache Pig软件后，按照以下步骤将其安装在Linux环境中。

步骤1

在安装了 Hadoop，Java和其他软件的安装目录的同一目录中创建一个名为Pig的目录。（在我们的教程中，我们在名为Hadoop的用户中创建了Pig目录）。

$ mkdir Pig

第2步

提取下载的tar文件，如下所示。

$ cd Downloads/

$ tar zxvf pig-0.15.0-src.tar.gz

$ tar zxvf pig-0.15.0.tar.gz

步骤3

将 pig-0.16.0-src.tar.gz 文件的内容移动到之前创建的 Pig 目录，如下所示。

$ mv pig-0.16.0-src.tar.gz/* /home/Hadoop/Pig/

配置ApachePig

安装Apache Pig后，我们必须配置它。要配置，我们需要编辑两个文件 - bashrc和pig.properties 。

.bashrc文件

在 .bashrc 文件中，设置以下变量

l PIG_HOME 文件夹复制到Apache Pig的安装文件夹

l PATH 环境变量复制到bin文件夹

l PIG_CLASSPATH 环境变量复制到安装Hadoop的etc（配置）文件夹（包含core-site.xml，hdfs-site.xml和mapred-site.xml文件的目录）。

export PIG_HOME = /home/Hadoop/Pig

export PATH  = PATH:/home/Hadoop/pig/bin

export PIG_CLASSPATH = $HADOOP_HOME/conf

pig.properties文件

在Pig的 conf 文件夹中，我们有一个名为 pig.properties 的文件。在pig.properties文件中，可以设置如下所示的各种参数。

pig -h properties

支持以下属性:

Logging: verbose = true|false; default is false. This property is the same as -v

       switch brief=true|false; default is false. This property is the same

       as -b switch debug=OFF|ERROR|WARN|INFO|DEBUG; default is INFO.

       This property is the same as -d switch aggregate.warning = true|false; default is true.

       If true, prints count of warnings of each type rather than logging each warning.

Performance tuning: pig.cachedbag.memusage=<mem fraction>; default is 0.2 (20% of all memory).

       Note that this memory is shared across all large bags used by the application.

       pig.skewedjoin.reduce.memusagea=<mem fraction>; default is 0.3 (30% of all memory).

       Specifies the fraction of heap available for the reducer to perform the join.

       pig.exec.nocombiner = true|false; default is false.

           Only disable combiner as a temporary workaround for problems.

       opt.multiquery = true|false; multiquery is on by default.

           Only disable multiquery as a temporary workaround for problems.

       opt.fetch=true|false; fetch is on by default.

           Scripts containing Filter, Foreach, Limit, Stream, and Union can be dumped without MR jobs.

       pig.tmpfilecompression = true|false; compression is off by default.

           Determines whether output of intermediate jobs is compressed.

       pig.tmpfilecompression.codec = lzo|gzip; default is gzip.

           Used in conjunction with pig.tmpfilecompression. Defines compression type.

       pig.noSplitCombination = true|false. Split combination is on by default.

           Determines if multiple small files are combined into a single map.

       pig.exec.mapPartAgg = true|false. Default is false.

           Determines if partial aggregation is done within map phase, before records are sent to combiner.

       pig.exec.mapPartAgg.minReduction=<min aggregation factor>. Default is 10.

           If the in-map partial aggregation does not reduce the output num records by this factor, it gets disabled.

Miscellaneous: exectype = mapreduce|tez|local; default is mapreduce. This property is the same as -x switch

       pig.additional.jars.uris=<comma seperated list of jars>. Used in place of register command.

       udf.import.list=<comma seperated list of imports>. Used to avoid package names in UDF.

       stop.on.failure = true|false; default is false. Set to true to terminate on the first error.

       pig.datetime.default.tz=<UTC time offset>. e.g. +08:00. Default is the default timezone of the host.

           Determines the timezone used to handle datetime datatype and UDFs.

Additionally, any Hadoop property can be specified.

验证安装

通过键入version命令验证Apache Pig的安装。如果安装成功，你将获得Apache Pig的正式版本，如下所示。

$ pig –version

Apache Pig version 0.16.0 (r1682971)

compiled Jun 01 2015, 11:44:35

Apache Pig 执行

Apache Pig执行模式

你可以以两种模式运行Apache Pig，即Local（本地）模式和HDFS模式。

Local模式

在此模式下，所有文件都从本地主机和本地文件系统安装和运行，不需要Hadoop或HDFS。此模式通常用于测试目的。

MapReduce模式

MapReduce模式是我们使用Apache Pig加载或处理Hadoop文件系统（HDFS）中存在的数据的地方。在这种模式下，每当我们执行Pig Latin语句来处理数据时，会在后端调用一个MapReduce作业，以对HDFS中存在的数据执行特定的操作。

Apache Pig执行机制

Apache Pig脚本可以通过三种方式执行，即交互模式，批处理模式和嵌入式模式。

交互模式（Gruntshell） - 你可以使用Grunt shell以交互模式运行Apache Pig。在此shell中，你可以输入Pig Latin语句并获取输出（使用Dump运算符）。

批处理模式（脚本） -你可以通过将Pig Latin脚本写入具有 .pig 扩展名的单个文件中，以批处理模式运行Apache Pig。

嵌入式模式（UDF） - Apache Pig允许在Java等编程语言中定义我们自己的函数（UDF用户定义函数），并在我们的脚本中使用它们。

调用GruntShell

你可以使用“-x"选项以所需的模式（local/MapReduce）调用Grunt shell，如下所示。

Local模式

MapReduce模式

Command（命令） -

$ ./pig -x local

Command（命令）-

$ ./pig -x mapreduce

Output（输出） -

Output（输出）-

这两个命令都给出了Grunt shell提示符，如下所示。

grunt>

你可以使用“ctrl+d"退出Grunt shell。

在调用Grunt shell之后，可以通过直接输入Pig中的Pig Latin语句来执行Pig脚本。

grunt> customers = LOAD 'customers.txt' USING PigStorage(',');

在批处理模式下执行Apache Pig

你可以在文件中编写整个Pig Latin脚本，并使用 -xcommand 执行它。我们假设在一个名为 sample_script.pig 的文件中有一个Pig脚本，如下所示。

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING

   PigStorage(',') as (id:int,name:chararray,city:chararray);

Dump student;

现在，你可以在上面的文件中执行脚本，如下所示。

Local模式

MapReduce模式

$ pig -x local Sample_script.pig

$ pig -x mapreduce Sample_script.pig

注意:我们将详细讨论如何在批处理模式和嵌入模式中运行Pig脚本。

Apache Pig Grunt Shell

调用Grunt shell后，可以在shell中运行Pig脚本。除此之外，还有由Grunt shell提供的一些有用的shell和实用程序命令。本章讲解的是Grunt shell提供的shell和实用程序命令。

注意:在本章的某些部分中，使用了Load和Store等命令。请参阅相应章节以获取有关它们的详细信息。

Shell 命令

Apache Pig的Grunt shell主要用于编写PigLatin脚本。在此之前，我们可以使用 sh 和 fs 来调用任何shell命令。

sh 命令

使用 sh 命令，我们可以从Gruntshell调用任何shell命令，但无法执行作为shell环境（ ex - cd）一部分的命令。

语法

下面给出了 sh 命令的语法。

grunt> sh shell command parameters

示例

我们可以使用 sh 选项从Gruntshell中调用Linux shell的 ls 命令，如下所示。在此示例中，它列出了 /pig/bin/ 目录中的文件。

grunt> sh ls

pig

pig_1444799121955.log

pig.cmd

pig.py

fs命令

使用 fs 命令，我们可以从Gruntshell调用任何FsShell命令。

语法

下面给出了 fs 命令的语法。

grunt> sh File System command parameters

示例

我们可以使用fs命令从Grunt shell调用HDFS的ls命令。在以下示例中，它列出了HDFS根目录中的文件。

grunt> fs –ls

Found 3 items

drwxrwxrwx   - Hadoop supergroup          0 2015-09-08 14:13 Hbase

drwxr-xr-x   - Hadoop supergroup          0 2015-09-09 14:52 seqgen_data

drwxr-xr-x   - Hadoop supergroup          0 2015-09-08 11:30 twitter_data

以同样的方式，我们可以使用 fs 命令从Grunt shell中调用所有其他文件系统的shell命令。

实用程序命令

Grunt shell提供了一组实用程序命令。这些包括诸如clear，help，history，quit和set等实用程序命令；以及Grunt shell中诸如 exec，kill和run等命令来控制Pig。下面给出了Grunt shell提供的实用命令的描述。

clear命令

clear 命令用于清除Grunt shell的屏幕。

语法

你可以使用 clear 命令清除gruntshell的屏幕，如下所示。

grunt> clear

help命令

help 命令提供了Pig命令或Pig属性的列表。

使用

你可以使用 help 命令获取Pig命令列表，如下所示。

grunt> help

Commands: <pig latin statement>; - See the PigLatin manual for details:

http://hadoop.apache.org/pig

File system commands:fs <fs arguments> - Equivalent to Hadoop dfs  command:

http://hadoop.apache.org/common/docs/current/hdfs_shell.html

Diagnostic Commands:describe <alias>[::<alias] - Show the schema for the alias.

Inner aliases can be described as A::B.

    explain [-script <pigscript>] [-out <path>] [-brief] [-dot|-xml]

       [-param <param_name>=<pCram_value>]

       [-param_file <file_name>] [<alias>] -

       Show the execution plan to compute the alias or for entire script.

       -script - Explain the entire script.

       -out - Store the output into directory rather than print to stdout.

       -brief - Don't expand nested plans (presenting a smaller graph for overview).

       -dot - Generate the output in .dot format. Default is text format.

       -xml - Generate the output in .xml format. Default is text format.

       -param <param_name - See parameter substitution for details.

       -param_file <file_name> - See parameter substitution for details.

       alias - Alias to explain.

       dump <alias> - Compute the alias and writes the results to stdout.

Utility Commands: exec [-param <param_name>=param_value] [-param_file <file_name>] <script> -

       Execute the script with access to grunt environment including aliases.

       -param <param_name - See parameter substitution for details.

       -param_file <file_name> - See parameter substitution for details.

       script - Script to be executed.

    run [-param <param_name>=param_value] [-param_file <file_name>] <script> -

       Execute the script with access to grunt environment.

                   -param <param_name - See parameter substitution for details.

       -param_file <file_name> - See parameter substitution for details.

       script - Script to be executed.

    sh  <shell command> - Invoke a shell command.

    kill <job_id> - Kill the hadoop job specified by the hadoop job id.

    set <key> <value> - Provide execution parameters to Pig. Keys and values are case sensitive.

       The following keys are supported:

       default_parallel - Script-level reduce parallelism. Basic input size heuristics used

       by default.

       debug - Set debug on or off. Default is off.

       job.name - Single-quoted name for jobs. Default is PigLatin:<script name>

       job.priority - Priority for jobs. Values: very_low, low, normal, high, very_high.

       Default is normal stream.skippath - String that contains the path.

       This is used by streaming any hadoop property.

    help - Display this message.

    history [-n] - Display the list statements in cache.

       -n Hide line numbers.

    quit - Quit the grunt shell.

history命令

此命令显示自Grunt shell被调用以来执行/使用的语句的列表。

使用

假设我们自打开Grunt shell之后执行了三个语句。

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',');

grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',');

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',');

然后，使用 history 命令将产生以下输出。

grunt> history

customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',');

orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',');

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',');

set命令

set 命令用于向Pig中使用的key显示/分配值。

使用

使用此命令，可以将值设置到以下key。

Key

说明和值

default_parallel

通过将任何整数作为值传递给此key来设置映射作业的reducer数。

debug

关闭或打开Pig中的调试功能通过传递on/off到这个key。

job.name

通过将字符串值传递给此key来将作业名称设置为所需的作业。

job.priority

通过将以下值之一传递给此key来设置作业的优先级:

· very_low

· low

· normal

· high

· very_high

stream.skippath

对于流式传输，可以通过将所需的路径以字符串形式传递到此key，来设置不传输数据的路径。

quit命令

你可以使用此命令从Grunt shell退出。

使用

从Grunt shell中退出，如下所示。

grunt> quit

现在让我们看看从Grunt shell控制Apache Pig的命令。

exec命令

使用 exec 命令，我们可以从Grunt shell执行Pig脚本。

语法

下面给出了实用程序命令 exec 的语法。

grunt> exec [–param param_name = param_value] [–param_file file_name] [script]

示例

我们假设在HDFS的 /pig_data/ 目录中有一个名为 student.txt 的文件，其中包含以下内容。

Student.txt

001,Rajiv,Hyderabad

002,siddarth,Kolkata

003,Rajesh,Delhi

并且，假设我们在HDFS的 /pig_data/ 目录中有一个名为 sample_script.pig 的脚本文件，并具有以下内容。

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',')

   as (id:int,name:chararray,city:chararray);

Dump student;

现在，让我们使用 exec 命令从Gruntshell中执行上面的脚本，如下所示。

grunt> exec /sample_script.pig

输出

exec 命令执行 sample_script.pig 中的脚本。按照脚本中的指示，它会将 student.txt 文件加载到Pig中，并显示Dump操作符的结果，显示以下内容。

(1,Rajiv,Hyderabad)

(2,siddarth,Kolkata)

(3,Rajesh,Delhi)

kill命令

你可以使用此命令从Grunt shell中终止一个作业。

语法

下面给出了 kill 命令的语法。

grunt> kill JobId

示例

假设有一个具有id Id_0055 的正在运行的Pig作业，使用 kill 命令从Grunt shell中终止它，如下所示。

grunt> kill Id_0055

run命令

你可以使用run命令从Grunt shell运行Pig脚本

语法

下面给出了 run 命令的语法。

grunt> run [–param param_name = param_value] [–param_file file_name] script

示例

假设在HDFS的 /pig_data/ 目录中有一个名为 student.txt 的文件，其中包含以下内容。

Student.txt

001,Rajiv,Hyderabad

002,siddarth,Kolkata

003,Rajesh,Delhi

并且，假设我们在本地文件系统中有一个名为 sample_script.pig 的脚本文件，并具有以下内容。

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING

   PigStorage(',') as (id:int,name:chararray,city:chararray);

现在，让我们使用run命令从Grunt shell运行上面的脚本，如下所示。

grunt> run /sample_script.pig

你可以使用Dump操作符查看脚本的输出，如下所示。

grunt> Dump;

(1,Rajiv,Hyderabad)

(2,siddarth,Kolkata)

(3,Rajesh,Delhi)

注意: exec 和 run 命令之间的区别是，如果使用run，则脚本中的语句在history命令中可用。

Pig Latin 基础

Pig Latin是用于使用Apache Pig分析Hadoop中数据的语言。在本章中，我们将讨论Pig Latin的基础知识，如Pig Latin语句，数据类型，通用运算符，关系运算符和Pig Latin UDF。

Pig Latin - 数据模型

如前面章节所讨论的，Pig的数据模型是完全嵌套的。Relation是Pig Latin数据模型的最外层结构。它是一个包其中:

· 包是元组的集合。

· 元组是有序的字段集。

· 字段是一段数据。

Pig Latin - 语句

在使用Pig Latin处理数据时，语句是基本结构。

这些语句使用关系（relation），它们包括表达式（expression）和模式（schema）。

每个语句以分号（;）结尾。

我们将使用Pig Latin提供的运算符通过语句执行各种操作。

除了LOAD和STORE，在执行所有其他操作时，Pig Latin语句采用关系作为输入，并产生另一个关系作为输出。

只要在Grunt shell中输入 Load 语句，就会执行语义检查。要查看模式的内容，需要使用 Dump 运算符。只有在执行 dump 操作后，才会执行将数据加载到文件系统的MapReduce作业。

例子

下面给出一个Pig Latin语句，它将数据加载到Apache Pig中。

grunt> Student_data = LOAD 'student_data.txt' USING PigStorage(',')as

   ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

Pig Latin - 数据类型

下面给出的表描述了Pig Latin数据类型。

序号

数据类型

说明＆示例

int

表示有符号的32位整数。

示例:8

long

表示有符号的64位整数。

示例:5L

float

表示有符号的32位浮点。

示例:5.5F

double

表示64位浮点。

示例:10.5

chararray

表示Unicode UTF-8格式的字符数组（字符串）。

示例:‘w3cschool’

Bytearray

表示字节数组（blob）。

Boolean

表示布尔值。

示例:true / false。

Datetime

表示日期时间。

示例:1970-01-01T00:00:00.000 + 00:00

Biginteger

表示Java BigInteger。

示例:60708090709

Bigdecimal

表示Java BigDecimal

示例:185.98376256272893883

复杂类型

Tuple

元组是有序的字段集。

示例:（raja,30）

Bag

包是元组的集合。

示例:{（raju,30）,（Mohhammad,45）}

Map

地图是一组键值对。

示例:['name'＃'Raju','age'＃30]

Null值

所有上述数据类型的值可以为NULL。Apache Pig以与SQL类似的方式处理空值。null可以是未知值或不存在值，它用作可选值的占位符。这些空值可以自然出现或者可以是操作的结果。

Pig Latin - 算术运算符

下表描述了Pig Latin的算术运算符。假设a = 10和b = 20。

运算符

描述

示例

加 - 运算符的两侧的值相加

a+b将得出30

−

减 - 从运算符左边的数中减去右边的数

a-b将得出-10

乘 - 运算符两侧的值相乘

a*b将得出200

除 - 用运算符左边的数除右边的数

b / a将得出2

系数 - 用运算符右边的数除左边的数并返回余数

b％a将得出0

？ :

Bincond - 评估布尔运算符。它有三个操作数，如下所示。

变量 x =（expression）？ value1 （如果为true）: value2（如果为false）。

b =（a == 1）？ 20:30;

如果a = 1，则b的值为20。

如果a！= 1，则b的值为30。

CASE

WHEN

THEN

ELSE

END

Case - case运算符等效于嵌套的bincond运算符。

CASE f2 ％ 2

WHEN 0

THEN

'even'

WHEN 1

THEN

'odd'

END

Pig Latin - 比较运算符

下表描述了Pig Latin的比较运算符。

运算符

描述

示例

等于 - 检查两个数的值是否相等；如果是，则条件变为true。

（a = b）不为true。

不等于 - 检查两个数的值是否相等。如果值不相等，则条件为true。

（a！= b）为true。

大于 - 检查左边数的值是否大于右边数的值。如果是，则条件变为true。

（a> b）不为true。

小于 - 检查左边数的值是否小于右边数的值。如果是，则条件变为true。

（a<b）为true。

大于或等于 - 检查左边数的值是否大于或等于右边数的值。如果是，则条件变为true。

（a>=b）不为true。

小于或等于 - 检查左边数的值是否小于或等于右边数的值。如果是，则条件变为true。

（a<=b）为true。

matches

模式匹配 - 检查左侧的字符串是否与右侧的常量匹配。

f1 matches '.* tutorial.*'

Pig Latin - 类型结构运算符

下表描述了Pig Latin的类型结构运算符。

运算符

描述

示例

()

元组构造函数运算符 - 此运算符用于构建元组。

（Raju,30）

{}

包构造函数运算符 - 此运算符用于构造包。

{（Raju,30）,（Mohammad,45）}

[]

映射构造函数运算符 - 此运算符用于构造一个映射。

[name＃Raja,age＃30]

Pig Latin - 关系运算符

下表描述了Pig Latin的关系运算符。

运算符

描述

加载和存储

LOAD

将数据从文件系统（local/ HDFS）加载到关系中。

STORE

将数据从文件系统（local/ HDFS）存储到关系中。

过滤

FILTER

从关系中删除不需要的行。

DISTINCT

从关系中删除重复行。

FOREACH，GENERATE

基于数据列生成数据转换。

STREAM

使用外部程序转换关系。

分组和连接

JOIN

连接两个或多个关系。

COGROUP

将数据分组为两个或多个关系。

GROUP

在单个关系中对数据进行分组。

CROSS

创建两个或多个关系的向量积。

排序

ORDER

基于一个或多个字段（升序或降序）按排序排列关系。

LIMIT

从关系中获取有限数量的元组。

合并和拆分

UNION

将两个或多个关系合并为单个关系。

SPLIT

将单个关系拆分为两个或多个关系。

诊断运算符

DUMP

在控制台上打印关系的内容。

DESCRIBE

描述关系的模式。

EXPLAIN

查看逻辑，物理或MapReduce执行计划以计算关系。

ILLUSTRATE

查看一系列语句的分步执行。

Apache Pig 加载数据

一般来说，Apache Pig在Hadoop之上工作。它是一种分析工具，用于分析 Hadoop File System中存在的大型数据集。要使用Apache Pig分析数据，我们必须首先将数据加载到Apache Pig中。本章介绍如何从HDFS将数据加载到Apache Pig。

准备HDFS

在MapReduce模式下，Pig从HDFS读取（加载）数据并将结果存回HDFS。因此，让我们先从HDFS开始，在HDFS中创建以下示例数据。

学生ID

名字

姓氏

电话号码

城市

001

Rajiv

Reddy

9848022337

Hyderabad

002

siddarth

Battacharya

9848022338

Kolkata

003

Rajesh

Khanna

9848022339

Delhi

004

Preethi

Agarwal

9848022330

Pune

005

Trupthi

Mohanthy

9848022336

Bhuwaneshwar

006

Archana

Mishra

9848022335

Chennai

上述数据集包含六个学生的个人详细信息，如id，名字，姓氏，电话号码和城市。

步骤1:验证Hadoop

首先，使用Hadoop version命令验证安装，如下所示。

$ hadoop version

如果你的系统里有Hadoop，并且已设置PATH变量，那么你将获得以下输出 -

Hadoop 2.6.0

Subversion https://git-wip-us.apache.org/repos/asf/hadoop.git -r

e3496499ecb8d220fba99dc5ed4c99c8f9e33bb1

Compiled by jenkins on 2014-11-13T21:10Z

Compiled with protoc 2.5.0

From source with checksum 18e43357c8f927c0695f1e9522859d6a

This command was run using /home/Hadoop/hadoop/share/hadoop/common/hadoop

common-2.6.0.jar

步骤2:启动HDFS

步骤3:在HDFS中创建目录

在Hadoop DFS中，可以使用 mkdir 命令创建目录。在HDFS所需路径中创建一个名为 Pig_Data 的新目录，如下所示。

$cd /$Hadoop_Home/bin/

$ hdfs dfs -mkdir hdfs://localhost:9000/Pig_Data

步骤4:将数据放在HDFS中

Pig的输入文件包含单个行中的每个元组/记录。记录的实体由分隔符分隔（在我们的示例中，我们使用“，”）。在本地文件系统中，创建一个包含数据的输入文件 student_data.txt ，如下所示。

001,Rajiv,Reddy,9848022337,Hyderabad

002,siddarth,Battacharya,9848022338,Kolkata

003,Rajesh,Khanna,9848022339,Delhi

004,Preethi,Agarwal,9848022330,Pune

005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar

006,Archana,Mishra,9848022335,Chennai.

现在，使用 put 命令将文件从本地文件系统移动到HDFS，如下所示。（你也可以使用 copyFromLocal 命令。）

$ cd $HADOOP_HOME/bin

$ hdfs dfs -put /home/Hadoop/Pig/Pig_Data/student_data.txt dfs://localhost:9000/pig_data/

验证文件

使用 cat 命令验证文件是否已移入HDFS，如下所示。

$ cd $HADOOP_HOME/bin

$ hdfs dfs -cat hdfs://localhost:9000/pig_data/student_data.txt

35,Chennai

Load运算符

你可以使用 Pig Latin 的 LOAD 运算符，从文件系统（HDFS / Local）将数据加载到Apache Pig中。

语法

load语句由两部分组成，用“=”运算符分隔。在左侧，需要提到我们想要存储数据的关系的名称；而在右侧，我们需要定义如何存储数据。下面给出了 Load运算符的语法。

Relation_name = LOAD 'Input file path' USING function as schema;

说明:

relation_name - 我们必须提到要存储数据的关系。

Input file path - 我们必须提到存储文件的HDFS目录。（在MapReduce模式下）

function - 我们必须从ApachePig提供的一组加载函数中选择一个函数（ BinStorage，JsonLoader，PigStorage，TextLoader ）。

Schema - 我们必须定义数据的模式，可以定义所需的模式如下 -

(column1 : data type, column2 : data type, column3 : data type);

注意:我们加载数据而不指定模式。在这种情况下，列将被寻址为$01，$02，等...（检查）。

例如，我们使用 LOAD 命令，在名为学生的模式下在Pig中的 student_data.txt 加载数据。

启动PigGrunt Shell

首先，打开Linux终端。在MapReduce模式下启动Pig Grunt shell，如下所示。

$ Pig –x mapreduce

grunt>

执行Load语句

现在，通过在Grunt shell中执行以下Pig Latin语句，将文件 student_data.txt 中的数据加载到Pig中。

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt'

   USING PigStorage(',')

   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray,

   city:chararray );

以下是对上述说明的描述。

Relation name

我们已将数据存储在学生（student）模式中。

Input file path

我们从HDFS的/pig_data/目录中的 student_data.txt 文件读取数据。

Storage function

我们使用了 PigStorage() 函数，将数据加载并存储为结构化文本文件。它采用分隔符，使用元组的每个实体作为参数分隔。默认情况下，它以“\t"作为参数。

schema

我们已经使用以下模式存储了数据。

column

名字

姓氏

电话号码

城市

datatype

int

char array

注意: Load语句会简单地将数据加载到Pig的指定的关系中。要验证Load语句的执行情况，必须使用Diagnostic运算符，这将在后续的章节中讨论。

Apache Pig 存储数据

语法

下面给出了Store语句的语法。

STORE Relation_name INTO ' required_directory_path ' [USING function];

例

假设我们在HDFS中有一个包含以下内容的文件 student_data.txt 。

001,Rajiv,Reddy,9848022337,Hyderabad

002,siddarth,Battacharya,9848022338,Kolkata

003,Rajesh,Khanna,9848022339,Delhi

004,Preethi,Agarwal,9848022330,Pune

005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar

006,Archana,Mishra,9848022335,Chennai.

使用LOAD运算符将它读入关系 student ，如下所示。

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt'

   USING PigStorage(',')

   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray,

   city:chararray );

现在，让我们将关系存储在HDFS目录“/pig_Output/"中，如下所示。

grunt> STORE student INTO ' hdfs://localhost:9000/pig_Output/ ' USING PigStorage (',');

输出

执行 store 语句后，将获得以下输出。使用指定的名称创建目录，并将数据存储在其中。

验证

你可以如下所示验证存储的数据。

步骤1

首先，使用 ls 命令列出名为 pig_output 的目录中的文件，如下所示。

hdfs dfs -ls 'hdfs://localhost:9000/pig_Output/'

Found 2 items

rw-r--r-   1 Hadoop supergroup          0 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/_SUCCESS

rw-r--r-   1 Hadoop supergroup        224 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/part-m-00000

可以观察到在执行 store 语句后创建了两个文件。

步骤2

使用 cat 命令，列出名为 part-m-00000 的文件的内容，如下所示。

$ hdfs dfs -cat 'hdfs://localhost:9000/pig_Output/part-m-00000'

1,Rajiv,Reddy,9848022337,Hyderabad

2,siddarth,Battacharya,9848022338,Kolkata

3,Rajesh,Khanna,9848022339,Delhi

4,Preethi,Agarwal,9848022330,Pune

5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar

6,Archana,Mishra,9848022335,Chennai

Apache Pig Diagnostic运算符

Load 语句会简单地将数据加载到Apache Pig中的指定关系中。要验证Load语句的执行，必须使用Diagnostic运算符。Pig Latin提供四种不同类型的诊断运算符:

· Dump运算符

· Describe运算符

· Explanation运算符

· Illustration运算符

在本章中，我们将讨论Pig Latin的Dump运算符。

Dump运算符

Dump 运算符用于运行Pig Latin语句，并在屏幕上显示结果，它通常用于调试目的。

语法

下面给出了 Dump 运算符的语法。

grunt> Dump Relation_Name

例

假设在HDFS中有一个包含以下内容的文件 student_data.txt 。

001,Rajiv,Reddy,9848022337,Hyderabad

002,siddarth,Battacharya,9848022338,Kolkata

003,Rajesh,Khanna,9848022339,Delhi

004,Preethi,Agarwal,9848022330,Pune

005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar

006,Archana,Mishra,9848022335,Chennai.

我们使用LOAD运算符将它读入关系 student ，如下所示。

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt'

   USING PigStorage(',')

   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray,

   city:chararray );

现在，使用Dump运算符打印关系的内容，如下所示。

grunt> Dump student

一旦执行上述 Pig Latin 语句，将启动一个MapReduce作业以从HDFS读取数据，将产生以下输出。

(1,Rajiv,Reddy,9848022337,Hyderabad)

(2,siddarth,Battacharya,9848022338,Kolkata)

(3,Rajesh,Khanna,9848022339,Delhi)

(4,Preethi,Agarwal,9848022330,Pune)

(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)

(6,Archana,Mishra,9848022335,Chennai)

Apache Pig Describe运算符

describe 运算符用于查看关系的模式。

语法

describe 运算符的语法如下

grunt> Describe Relation_name

例

假设在HDFS中有一个包含以下内容的文件 student_data.txt 。

001,Rajiv,Reddy,9848022337,Hyderabad

002,siddarth,Battacharya,9848022338,Kolkata

003,Rajesh,Khanna,9848022339,Delhi

004,Preethi,Agarwal,9848022330,Pune

005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar

006,Archana,Mishra,9848022335,Chennai.

使用LOAD运算符将它读入关系 student ，如下所示。

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')

   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

现在，让我们描述名为student的关系，并验证模式如下所示。

grunt> describe student;

输出

执行上述 Pig Latin 语句后，将生成以下输出。

grunt> student: { id: int,firstname: chararray,lastname: chararray,phone: chararray,city: chararray }

Apache Pig Explain运算符

explain 运算符用于显示关系的逻辑，物理和MapReduce执行计划。

语法

下面给出了 explain 运算符的语法。

grunt> explain Relation_name;

例

假设在HDFS中有一个包含以下内容的文件 student_data.txt 。

001,Rajiv,Reddy,9848022337,Hyderabad

002,siddarth,Battacharya,9848022338,Kolkata

003,Rajesh,Khanna,9848022339,Delhi

004,Preethi,Agarwal,9848022330,Pune

005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar

006,Archana,Mishra,9848022335,Chennai.

使用LOAD运算符将它读入关系 student ，如下所示。

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')

   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

现在，让我们使用 explain 运算符解释名为student的关系，如下所示。

grunt> explain student;

输出

它将产生以下输出。

$ explain student;

Apache Pig illustrate运算符

illustrate 运算符为你提供了一系列语句的逐步执行。

语法

下面给出了illustrate运算符的语法。

grunt> illustrate Relation_name;

例

假设在HDFS中有一个包含以下内容的文件 student_data.txt 。

001,Rajiv,Reddy,9848022337,Hyderabad

002,siddarth,Battacharya,9848022338,Kolkata

003,Rajesh,Khanna,9848022339,Delhi

004,Preethi,Agarwal,9848022330,Pune

005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar

006,Archana,Mishra,9848022335,Chennai.

使用LOAD运算符将它读入关系 student ，如下所示。

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')

   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

现在，让我们说明如下所示的名为student的关系。

grunt> illustrate student;

输出

在执行上面的语句时，将获得以下输出。

grunt> illustrate student;

Apache Pig Group运算符

GROUP 运算符用于在一个或多个关系中对数据进行分组，它收集具有相同key的数据。

语法

下面给出了 group 运算符的语法。

grunt> Group_data = GROUP Relation_name BY age;

例

假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad

002,siddarth,Battacharya,22,9848022338,Kolkata

003,Rajesh,Khanna,22,9848022339,Delhi

004,Preethi,Agarwal,21,9848022330,Pune

005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar

006,Archana,Mishra,23,9848022335,Chennai

007,Komal,Nayak,24,9848022334,trivendram

008,Bharathi,Nambiayar,24,9848022333,Chennai

将这个文件加载到Apache Pig中，关系名称为student_details，如下所示。

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

现在，让我们按照年龄关系中的记录/元组进行分组，如下所示。

grunt> group_data = GROUP student_details by age;

验证

使用 DUMP 运算符验证关系 group_data ，如下所示。

grunt> Dump group_data;

输出

将获得显示名为group_data关系的内容的输出，如下所示。在这里你可以观察到结果模式有两列:

一个是age，通过它我们将关系分组。

另一个是bag，其中包含一组元组，有各自年龄的学生记录。

(21,{(4,Preethi,Agarwal,21,9848022330,Pune),(1,Rajiv,Reddy,21,9848022337,Hydera bad)})

(22,{(3,Rajesh,Khanna,22,9848022339,Delhi),(2,siddarth,Battacharya,22,984802233 8,Kolkata)})

(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)})

(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)})

在使用 describe 命令分组数据后，可以看到表的模式，如下所示。

grunt> Describe group_data;

group_data: {group: int,student_details: {(id: int,firstname: chararray,

               lastname: chararray,age: int,phone: chararray,city: chararray)}}

以同样的方式，可以使用illustrate命令获取模式的示例说明，如下所示。

$ Illustrate group_data;

它将产生以下输出

-------------------------------------------------------------------------------------------------

|group_data|  group:int | student_details:bag{:tuple(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray)}|

-------------------------------------------------------------------------------------------------

|          |     21     | { 4, Preethi, Agarwal, 21, 9848022330, Pune), (1, Rajiv, Reddy, 21, 9848022337, Hyderabad)}|

|          |     2      | {(2,siddarth,Battacharya,22,9848022338,Kolkata),(003,Rajesh,Khanna,22,9848022339,Delhi)}|

-------------------------------------------------------------------------------------------------

按多列分组

让我们按年龄和城市对关系进行分组，如下所示。

grunt> group_multiple = GROUP student_details by (age, city);

可以使用Dump运算符验证名为 group_multiple 的关系的内容，如下所示。

grunt> Dump group_multiple;

((21,Pune),{(4,Preethi,Agarwal,21,9848022330,Pune)})

((21,Hyderabad),{(1,Rajiv,Reddy,21,9848022337,Hyderabad)})

((22,Delhi),{(3,Rajesh,Khanna,22,9848022339,Delhi)})

((22,Kolkata),{(2,siddarth,Battacharya,22,9848022338,Kolkata)})

((23,Chennai),{(6,Archana,Mishra,23,9848022335,Chennai)})

((23,Bhuwaneshwar),{(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)})

((24,Chennai),{(8,Bharathi,Nambiayar,24,9848022333,Chennai)})

(24,trivendram),{(7,Komal,Nayak,24,9848022334,trivendram)})

Group All

你可以按所有的列对关系进行分组，如下所示。

grunt> group_all = GROUP student_details All;

现在，请验证关系 group_all 的内容，如下所示。

grunt> Dump group_all;

(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334 ,trivendram),

(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336,Bhuw aneshwar),

(4,Preethi,Agarwal,21,9848022330,Pune),(3,Rajesh,Khanna,22,9848022339,Delhi),

(2,siddarth,Battacharya,22,9848022338,Kolkata),(1,Rajiv,Reddy,21,9848022337,Hyd erabad)})

Apache Pig Cogroup运算符

COGROUP 运算符的运作方式与 GROUP运算符相同。两个运算符之间的唯一区别是 group 运算符通常用于一个关系，而 cogroup 运算符用于涉及两个或多个关系的语句。

使用Cogroup分组两个关系

假设在HDFS目录 /pig_data/ 中有两个文件，即 student_details.txt 和 employee_details.txt ，如下所示。

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad

002,siddarth,Battacharya,22,9848022338,Kolkata

003,Rajesh,Khanna,22,9848022339,Delhi

004,Preethi,Agarwal,21,9848022330,Pune

005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar

006,Archana,Mishra,23,9848022335,Chennai

007,Komal,Nayak,24,9848022334,trivendram

008,Bharathi,Nambiayar,24,9848022333,Chennai

employee_details.txt

001,Robin,22,newyork

002,BOB,23,Kolkata

003,Maya,23,Tokyo

004,Sara,25,London

005,David,23,Bhuwaneshwar

006,Maggy,22,Chennai

将这些文件分别加载到Pig中，关系名称分别为 student_details 和 employee_details ，如下所示。

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

grunt> employee_details = LOAD 'hdfs://localhost:9000/pig_data/employee_details.txt' USING PigStorage(',')

   as (id:int, name:chararray, age:int, city:chararray);

现在，将 student_details 和 employee_details 关系的记录/元组按关键字age进行分组，如下所示。

grunt> cogroup_data = COGROUP student_details by age, employee_details by age;

验证

使用 DUMP 运算符验证关系 cogroup_data ，如下所示。

grunt> Dump cogroup_data;

输出

它将产生以下输出，显示名为 cogroup_data 的关系的内容，如下所示。

(21,{(4,Preethi,Agarwal,21,9848022330,Pune), (1,Rajiv,Reddy,21,9848022337,Hyderabad)},

   {    })

(22,{ (3,Rajesh,Khanna,22,9848022339,Delhi), (2,siddarth,Battacharya,22,9848022338,Kolkata) },

   { (6,Maggy,22,Chennai),(1,Robin,22,newyork) })

(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)},

   {(5,David,23,Bhuwaneshwar),(3,Maya,23,Tokyo),(2,BOB,23,Kolkata)})

(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)},

   { })

(25,{   },

   {(4,Sara,25,London)})

cogroup 运算符根据年龄对来自每个关系的元组进行分组，其中每个组描述特定的年龄值。

例如，如果我们考虑结果的第一个元组，它按照年龄21分组，那它包含两个包：

第一个包保存了具有21岁的第一关系（在这种情况是 student_details ）的所有元组；

第二个包具有第二关系（在这种情况下为 employee_details ）的所有元组，其年龄为21岁。

如果关系不具有年龄值为21的元组，则返回一个空包。

Apache Pig Join运算符

JOIN 运算符用于组合来自两个或多个关系的记录。在执行连接操作时，我们从每个关系中声明一个（或一组）元组作为key。当这些key匹配时，两个特定的元组匹配，否则记录将被丢弃。连接可以是以下类型：

· Self-join

· Inner-join

· Outer-join − left join, right join, and full join

本章介绍了如何在Pig Latin中使用join运算符的示例。假设在HDFS的 /pig_data/ 目录中有两个文件，即 customers.txt 和 orders.txt ，如下所示。

customers.txt

1,Ramesh,32,Ahmedabad,2000.00

2,Khilan,25,Delhi,1500.00

3,kaushik,23,Kota,2000.00

4,Chaitali,25,Mumbai,6500.00

5,Hardik,27,Bhopal,8500.00

6,Komal,22,MP,4500.00

7,Muffy,24,Indore,10000.00

orders.txt

102,2009-10-08 00:00:00,3,3000

100,2009-10-08 00:00:00,3,1500

101,2009-11-20 00:00:00,2,1560

103,2008-05-20 00:00:00,4,2060

我们将这两个文件与 customers 和 orders 关系一起加载到Pig中，如下所示。

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')

   as (id:int, name:chararray, age:int, address:chararray, salary:int);

grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')

   as (oid:int, date:chararray, customer_id:int, amount:int);

现在让我们对这两个关系执行各种连接操作。

Self-join（自连接）

Self-join 用于将表与其自身连接，就像表是两个关系一样，临时重命名至少一个关系。通常，在ApachePig中，为了执行self-join，我们将在不同的别名（名称）下多次加载相同的数据。那么，将文件 customers.txt 的内容加载为两个表，如下所示。

grunt> customers1 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')

   as (id:int, name:chararray, age:int, address:chararray, salary:int);

grunt> customers2 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')

   as (id:int, name:chararray, age:int, address:chararray, salary:int);

语法

下面给出使用 JOIN 运算符执行self-join操作的语法。

grunt> Relation3_name = JOIN Relation1_name BY key, Relation2_name BY key ;

例

通过如图所示加入两个关系 customers1 和 customers2 ，对关系 customers 执行self-join 操作。

grunt> customers3 = JOIN customers1 BY id, customers2 BY id;

验证

使用 DUMP 运算符验证关系 customers3 ，如下所示。

grunt> Dump customers3;

输出

将产生以下输出，显示关系 customers 的内容。

(1,Ramesh,32,Ahmedabad,2000,1,Ramesh,32,Ahmedabad,2000)

(2,Khilan,25,Delhi,1500,2,Khilan,25,Delhi,1500)

(3,kaushik,23,Kota,2000,3,kaushik,23,Kota,2000)

(4,Chaitali,25,Mumbai,6500,4,Chaitali,25,Mumbai,6500)

(5,Hardik,27,Bhopal,8500,5,Hardik,27,Bhopal,8500)

(6,Komal,22,MP,4500,6,Komal,22,MP,4500)

(7,Muffy,24,Indore,10000,7,Muffy,24,Indore,10000)

Inner Join（内部连接）

Inner Join使用较为频繁；它也被称为等值连接。当两个表中都存在匹配时，内部连接将返回行。基于连接谓词（join-predicate），通过组合两个关系（例如A和B）的列值来创建新关系。查询将A的每一行与B的每一行进行比较，以查找满足连接谓词的所有行对。当连接谓词被满足时，A和B的每个匹配的行对的列值被组合成结果行。

语法

以下是使用 JOIN 运算符执行inner join操作的语法。

grunt> result = JOIN relation1 BY columnname, relation2 BY columnname;

例

让我们对customers和orders执行inner join操作，如下所示。

grunt> coustomer_orders = JOIN customers BY id, orders BY customer_id;

验证

使用 DUMP 运算符验证 coustomer_orders 关系，如下所示。

grunt> Dump coustomer_orders;

输出

将获得以下输出，是名为 coustomer_orders 的关系的内容。

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)

(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)

(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)

(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

注意：

Outer Join：与inner join不同，outer join返回至少一个关系中的所有行。outer join操作以三种方式执行：

· Left outer join

· Right outer join

· Full outer join

Left Outer Join（左外连接）

left outer join操作返回左表中的所有行，即使右边的关系中没有匹配项。

语法

下面给出使用 JOIN 运算符执行left outer join操作的语法。

grunt> Relation3_name = JOIN Relation1_name BY id LEFT OUTER, Relation2_name BY customer_id;

例

让我们对customers和orders的两个关系执行left outer join操作，如下所示。

grunt> outer_left = JOIN customers BY id LEFT OUTER, orders BY customer_id;

验证

使用 DUMP 运算符验证关系 outer_left ，如下所示。

grunt> Dump outer_left;

输出

它将产生以下输出，显示关系 outer_left 的内容。

(1,Ramesh,32,Ahmedabad,2000,,,,)

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)

(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)

(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)

(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

(5,Hardik,27,Bhopal,8500,,,,)

(6,Komal,22,MP,4500,,,,)

(7,Muffy,24,Indore,10000,,,,)

Right Outer Join（右外连接）

right outer join操作将返回右表中的所有行，即使左表中没有匹配项。

语法

下面给出使用 JOIN 运算符执行right outer join操作的语法。

grunt> outer_right = JOIN customers BY id RIGHT, orders BY customer_id;

例

让我们对customers和orders执行right outer join操作，如下所示。

grunt> outer_right = JOIN customers BY id RIGHT, orders BY customer_id;

验证

使用 DUMP 运算符验证关系 outer_right ，如下所示。

grunt> Dump outer_right

输出

它将产生以下输出，显示关系 outer_right 的内容。

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)

(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)

(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)

(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

Full Outer Join（全外连接）

当一个关系中存在匹配时，fullouter join操作将返回行。

语法

下面给出使用 JOIN 运算符执行full outer join的语法。

grunt> outer_full = JOIN customers BY id FULL OUTER, orders BY customer_id;

例

让我们对customers和orders执行full outer join操作，如下所示。

grunt> outer_full = JOIN customers BY id FULL OUTER, orders BY customer_id;

验证

使用 DUMP 运算符验证关系 outer_full ，如下所示。

grun> Dump outer_full;

输出

它将产生以下输出，显示关系 outer_full 的内容。

(1,Ramesh,32,Ahmedabad,2000,,,,)

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)

(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)

(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)

(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

(5,Hardik,27,Bhopal,8500,,,,)

(6,Komal,22,MP,4500,,,,)

(7,Muffy,24,Indore,10000,,,,)

使用多个Key

我们可以使用多个key执行JOIN操作。

语法

下面是如何使用多个key对两个表执行JOIN操作。

grunt> Relation3_name = JOIN Relation2_name BY (key1, key2), Relation3_name BY (key1, key2);

假设在HDFS的 /pig_data/ 目录中有两个文件，即 employee.txt 和 employee_contact.txt ，如下所示。

employee.txt

001,Rajiv,Reddy,21,programmer,003

002,siddarth,Battacharya,22,programmer,003

003,Rajesh,Khanna,22,programmer,003

004,Preethi,Agarwal,21,programmer,003

005,Trupthi,Mohanthy,23,programmer,003

006,Archana,Mishra,23,programmer,003

007,Komal,Nayak,24,teamlead,002

008,Bharathi,Nambiayar,24,manager,001

employee_contact.txt

001,9848022337,Rajiv@gmail.com,Hyderabad,003

002,9848022338,siddarth@gmail.com,Kolkata,003

003,9848022339,Rajesh@gmail.com,Delhi,003

004,9848022330,Preethi@gmail.com,Pune,003

005,9848022336,Trupthi@gmail.com,Bhuwaneshwar,003

006,9848022335,Archana@gmail.com,Chennai,003

007,9848022334,Komal@gmail.com,trivendram,002

008,9848022333,Bharathi@gmail.com,Chennai,001

将这两个文件加载到Pig中，通过关系 employee 和 employee_contact ，如下所示。

grunt> employee = LOAD 'hdfs://localhost:9000/pig_data/employee.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray, age:int, designation:chararray, jobid:int);

grunt> employee_contact = LOAD 'hdfs://localhost:9000/pig_data/employee_contact.txt' USING PigStorage(',')

   as (id:int, phone:chararray, email:chararray, city:chararray, jobid:int);

现在，让我们使用 JOIN 运算符连接这两个关系的内容，如下所示。

grunt> emp = JOIN employee BY (id,jobid), employee_contact BY (id,jobid);

验证

使用 DUMP 运算符验证关系 emp ，如下所示。

grunt> Dump emp;

输出

它将产生以下输出，显示名为 emp 的关系的内容，如下所示。

(1,Rajiv,Reddy,21,programmer,113,1,9848022337,Rajiv@gmail.com,Hyderabad,113)

(2,siddarth,Battacharya,22,programmer,113,2,9848022338,siddarth@gmail.com,Kolka ta,113)

(3,Rajesh,Khanna,22,programmer,113,3,9848022339,Rajesh@gmail.com,Delhi,113)

(4,Preethi,Agarwal,21,programmer,113,4,9848022330,Preethi@gmail.com,Pune,113)

(5,Trupthi,Mohanthy,23,programmer,113,5,9848022336,Trupthi@gmail.com,Bhuwaneshw ar,113)

(6,Archana,Mishra,23,programmer,113,6,9848022335,Archana@gmail.com,Chennai,113)

(7,Komal,Nayak,24,teamlead,112,7,9848022334,Komal@gmail.com,trivendram,112)

(8,Bharathi,Nambiayar,24,manager,111,8,9848022333,Bharathi@gmail.com,Chennai,111)

Apache Pig Cross运算符

CROSS 运算符计算两个或多个关系的向量积。本章将以示例说明如何在Pig Latin中使用cross运算符。

语法

下面给出了 CROSS 运算符的语法。

grunt> Relation3_name = CROSS Relation1_name, Relation2_name;

例

假设在HDFS的 /pig_data/ 目录中有两个文件，即 customers.txt 和 orders.txt ，如下所示。

customers.txt

1,Ramesh,32,Ahmedabad,2000.00

2,Khilan,25,Delhi,1500.00

3,kaushik,23,Kota,2000.00

4,Chaitali,25,Mumbai,6500.00

5,Hardik,27,Bhopal,8500.00

6,Komal,22,MP,4500.00

7,Muffy,24,Indore,10000.00

orders.txt

102,2009-10-08 00:00:00,3,3000

100,2009-10-08 00:00:00,3,1500

101,2009-11-20 00:00:00,2,1560

103,2008-05-20 00:00:00,4,2060

将这两个文件加载到Pig中，通过关系 customers 和 orders，如下所示。

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')

   as (id:int, name:chararray, age:int, address:chararray, salary:int);

grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')

   as (oid:int, date:chararray, customer_id:int, amount:int);

现在让我们使用 cross 运算符获得这两个关系的向量积，如下所示。

grunt> cross_data = CROSS customers, orders;

验证

使用 DUMP 运算符验证关系 cross_data ，如下所示。

grunt> Dump cross_data;

输出

它将产生以下输出，显示关系 cross_data 的内容。

(7,Muffy,24,Indore,10000,103,2008-05-20 00:00:00,4,2060)

(7,Muffy,24,Indore,10000,101,2009-11-20 00:00:00,2,1560)

(7,Muffy,24,Indore,10000,100,2009-10-08 00:00:00,3,1500)

(7,Muffy,24,Indore,10000,102,2009-10-08 00:00:00,3,3000)

(6,Komal,22,MP,4500,103,2008-05-20 00:00:00,4,2060)

(6,Komal,22,MP,4500,101,2009-11-20 00:00:00,2,1560)

(6,Komal,22,MP,4500,100,2009-10-08 00:00:00,3,1500)

(6,Komal,22,MP,4500,102,2009-10-08 00:00:00,3,3000)

(5,Hardik,27,Bhopal,8500,103,2008-05-20 00:00:00,4,2060)

(5,Hardik,27,Bhopal,8500,101,2009-11-20 00:00:00,2,1560)

(5,Hardik,27,Bhopal,8500,100,2009-10-08 00:00:00,3,1500)

(5,Hardik,27,Bhopal,8500,102,2009-10-08 00:00:00,3,3000)

(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

(4,Chaitali,25,Mumbai,6500,101,2009-20 00:00:00,4,2060)

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)

(2,Khilan,25,Delhi,1500,100,2009-10-08 00:00:00,3,1500)

(2,Khilan,25,Delhi,1500,102,2009-10-08 00:00:00,3,3000)

(1,Ramesh,32,Ahmedabad,2000,103,2008-05-20 00:00:00,4,2060)

(1,Ramesh,32,Ahmedabad,2000,101,2009-11-20 00:00:00,2,1560)

(1,Ramesh,32,Ahmedabad,2000,100,2009-10-08 00:00:00,3,1500)

(1,Ramesh,32,Ahmedabad,2000,102,2009-10-08 00:00:00,3,3000)-11-20 00:00:00,2,1560)

(4,Chaitali,25,Mumbai,6500,100,2009-10-08 00:00:00,3,1500)

(4,Chaitali,25,Mumbai,6500,102,2009-10-08 00:00:00,3,3000)

(3,kaushik,23,Kota,2000,103,2008-05-20 00:00:00,4,2060)

(3,kaushik,23,Kota,2000,101,2009-11-20 00:00:00,2,1560)

(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)

(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)

(2,Khilan,25,Delhi,1500,103,2008-05-20 00:00:00,4,2060)

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)

(2,Khilan,25,Delhi,1500,100,2009-10-08 00:00:00,3,1500)

(2,Khilan,25,Delhi,1500,102,2009-10-08 00:00:00,3,3000)

(1,Ramesh,32,Ahmedabad,2000,103,2008-05-20 00:00:00,4,2060)

(1,Ramesh,32,Ahmedabad,2000,101,2009-11-20 00:00:00,2,1560)

(1,Ramesh,32,Ahmedabad,2000,100,2009-10-08 00:00:00,3,1500)

(1,Ramesh,32,Ahmedabad,2000,102,2009-10-08 00:00:00,3,3000)

Apache Pig Union运算符

Pig Latin的 UNION 运算符用于合并两个关系的内容。要对两个关系执行UNION操作，它们的列和域必须相同。

语法

下面给出了 UNION 运算符的语法。

grunt> Relation_name3 = UNION Relation_name1, Relation_name2;

例

假设在HDFS的 /pig_data/ 目录中有两个文件，即 student_data1.txt 和 student_data2.txt ，如下所示。

Student_data1.txt

001,Rajiv,Reddy,9848022337,Hyderabad

002,siddarth,Battacharya,9848022338,Kolkata

003,Rajesh,Khanna,9848022339,Delhi

004,Preethi,Agarwal,9848022330,Pune

005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar

006,Archana,Mishra,9848022335,Chennai.

Student_data2.txt

7,Komal,Nayak,9848022334,trivendram.

8,Bharathi,Nambiayar,9848022333,Chennai.

将这两个文件加载到Pig中，通过关系 student1 和 student2 ，如下所示。

grunt> student1 = LOAD 'hdfs://localhost:9000/pig_data/student_data1.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);

grunt> student2 = LOAD 'hdfs://localhost:9000/pig_data/student_data2.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);

现在，让我们使用 UNION 运算符合并这两个关系的内容，如下所示。

grunt> student = UNION student1, student2;

验证

使用 DUMP 运算子验证关系student，如下所示。

grunt> Dump student;

输出

它将显示以下输出，显示关系student的内容。

(1,Rajiv,Reddy,9848022337,Hyderabad) (2,siddarth,Battacharya,9848022338,Kolkata)

(3,Rajesh,Khanna,9848022339,Delhi)

(4,Preethi,Agarwal,9848022330,Pune)

(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)

(6,Archana,Mishra,9848022335,Chennai)

(7,Komal,Nayak,9848022334,trivendram)

(8,Bharathi,Nambiayar,9848022333,Chennai)

Apache Pig Split运算符

SPLIT 运算符用于将关系拆分为两个或多个关系。

语法

下面给出了 SPLIT 运算符的语法。

grunt> SPLIT Relation1_name INTO Relation2_name IF (condition1), Relation2_name (condition2),

例

假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad

002,siddarth,Battacharya,22,9848022338,Kolkata

003,Rajesh,Khanna,22,9848022339,Delhi

004,Preethi,Agarwal,21,9848022330,Pune

005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar

006,Archana,Mishra,23,9848022335,Chennai

007,Komal,Nayak,24,9848022334,trivendram

008,Bharathi,Nambiayar,24,9848022333,Chennai

通过关系 student_details 将此文件加载到Pig中，如下所示。

student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

现在，让我们将关系分为两个，一个列出年龄小于23岁的员工，另一个列出年龄在22到25岁之间的员工。

SPLIT student_details into student_details1 if age<23, student_details2 if (22<age and age>25);

验证

使用 DUMP 操作符验证关系 student_details1 和 student_details2 ，如下所示。

grunt> Dump student_details1;

grunt> Dump student_details2;

输出

它将产生以下输出，分别显示关系 student_details1 和 student_details2 的内容。

grunt> Dump student_details1;

(1,Rajiv,Reddy,21,9848022337,Hyderabad)

(2,siddarth,Battacharya,22,9848022338,Kolkata)

(3,Rajesh,Khanna,22,9848022339,Delhi)

(4,Preethi,Agarwal,21,9848022330,Pune)

  grunt> Dump student_details2;

(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)

(6,Archana,Mishra,23,9848022335,Chennai)

(7,Komal,Nayak,24,9848022334,trivendram)

(8,Bharathi,Nambiayar,24,9848022333,Chennai)

Apache Pig Filter运算符

FILTER 运算符用于根据条件从关系中选择所需的元组。

语法

下面给出了 FILTER 运算符的语法。

grunt> Relation2_name = FILTER Relation1_name BY (condition);

例

假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad

002,siddarth,Battacharya,22,9848022338,Kolkata

003,Rajesh,Khanna,22,9848022339,Delhi

004,Preethi,Agarwal,21,9848022330,Pune

005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar

006,Archana,Mishra,23,9848022335,Chennai

007,Komal,Nayak,24,9848022334,trivendram

008,Bharathi,Nambiayar,24,9848022333,Chennai

将此文件通过关系 student_details 加载到的Pig中，如下所示。

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

现在使用Filter运算符来获取属于Chennai城市的学生的详细信息。

filter_data = FILTER student_details BY city == 'Chennai';

验证

使用 DUMP 运算符验证关系 filter_data ，如下所示。

grunt> Dump filter_data;

输出

它将产生以下输出，显示关系 filter_data 的内容如下。

(6,Archana,Mishra,23,9848022335,Chennai)

(8,Bharathi,Nambiayar,24,9848022333,Chennai)

Apache Pig Distinct运算符

DISTINCT 运算符用于从关系中删除冗余（重复）元组。

语法

下面给出了 DISTINCT 运算符的语法。

grunt> Relation_name2 = DISTINCT Relatin_name1;

例

假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。

student_details.txt

001,Rajiv,Reddy,9848022337,Hyderabad

002,siddarth,Battacharya,9848022338,Kolkata

002,siddarth,Battacharya,9848022338,Kolkata

003,Rajesh,Khanna,9848022339,Delhi

003,Rajesh,Khanna,9848022339,Delhi

004,Preethi,Agarwal,9848022330,Pune

005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar

006,Archana,Mishra,9848022335,Chennai

006,Archana,Mishra,9848022335,Chennai

通过关系 student_details 将此文件加载到Pig中，如下所示。

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);

现在，让我们使用 DISTINCT 运算符从 student_details 关系中删除冗余（重复）元组，并将其另存在一个名为 distinct_data 的关系如下所示。

grunt> distinct_data = DISTINCT student_details;

验证

使用 DUMP 运算符验证关系 distinct_data ，如下所示。

grunt> Dump distinct_data;

输出

它将产生以下输出，显示关系 distinct_data 的内容如下。

(1,Rajiv,Reddy,9848022337,Hyderabad)

(2,siddarth,Battacharya,9848022338,Kolkata)

(3,Rajesh,Khanna,9848022339,Delhi)

(4,Preethi,Agarwal,9848022330,Pune)

(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)

(6,Archana,Mishra,9848022335,Chennai)

Apache Pig Foreach运算符

FOREACH 运算符用于基于列数据生成指定的数据转换。

语法

下面给出了 FOREACH 运算符的语法。

grunt> Relation_name2 = FOREACH Relatin_name1 GENERATE (required data);

例

假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad

002,siddarth,Battacharya,22,9848022338,Kolkata

003,Rajesh,Khanna,22,9848022339,Delhi

004,Preethi,Agarwal,21,9848022330,Pune

005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar

006,Archana,Mishra,23,9848022335,Chennai

007,Komal,Nayak,24,9848022334,trivendram

008,Bharathi,Nambiayar,24,9848022333,Chennai

通过关系 student_details 将此文件加载到的Pig中，如下所示。

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);

现在让我们从关系 student_details 中获取每个学生的id，age和city值，并使用 foreach 运算符将它存储到另一个名为 foreach_data 关系，如下所示。

grunt> foreach_data = FOREACH student_details GENERATE id,age,city;

验证

使用 DUMP 运算符验证关系 foreach_data ，如下所示。

grunt> Dump foreach_data;

输出

它将产生以下输出，显示关系 foreach_data 的内容。

(1,21,Hyderabad)

(2,22,Kolkata)

(3,22,Delhi)

(4,21,Pune)

(5,23,Bhuwaneshwar)

(6,23,Chennai)

(7,24,trivendram)

(8,24,Chennai)

Apache Pig Order By运算符

ORDER BY 运算符用于以基于一个或多个字段的排序顺序显示关系的内容。

语法

下面给出了 ORDER BY 运算符的语法。

grunt> Relation_name2 = ORDER Relatin_name1 BY (ASC|DESC);

例

假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad

002,siddarth,Battacharya,22,9848022338,Kolkata

003,Rajesh,Khanna,22,9848022339,Delhi

004,Preethi,Agarwal,21,9848022330,Pune

005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar

006,Archana,Mishra,23,9848022335,Chennai

007,Komal,Nayak,24,9848022334,trivendram

008,Bharathi,Nambiayar,24,9848022333,Chennai

通过关系 student_details 将此文件加载到的Pig中，如下所示。

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);

现在让我们根据学生的年龄以降序排列关系，并使用 ORDER BY 运算符将它存储到另一个名为 order_by_data 的关系中，如下所示。

grunt> order_by_data = ORDER student_details BY age DESC;

验证

使用 DUMP 运算符验证关系 order_by_data ，如下所示。

grunt> Dump order_by_data;

输出

它将产生以下输出，显示关系 order_by_data 的内容。

(8,Bharathi,Nambiayar,24,9848022333,Chennai)

(7,Komal,Nayak,24,9848022334,trivendram)

(6,Archana,Mishra,23,9848022335,Chennai)

(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)

(3,Rajesh,Khanna,22,9848022339,Delhi)

(2,siddarth,Battacharya,22,9848022338,Kolkata)

(4,Preethi,Agarwal,21,9848022330,Pune)

(1,Rajiv,Reddy,21,9848022337,Hyderabad)

Apache Pig Limit运算符

LIMIT 运算符用于从关系中获取有限数量的元组。

语法

下面给出了 LIMIT 运算符的语法。

grunt> Result = LIMIT Relation_name required number of tuples;

例

假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad

002,siddarth,Battacharya,22,9848022338,Kolkata

003,Rajesh,Khanna,22,9848022339,Delhi

004,Preethi,Agarwal,21,9848022330,Pune

005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar

006,Archana,Mishra,23,9848022335,Chennai

007,Komal,Nayak,24,9848022334,trivendram

008,Bharathi,Nambiayar,24,9848022333,Chennai

通过关系 student_details 将此文件加载到的Pig中，如下所示。

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);

现在，让我们根据学生的年龄以降序对关系进行排序，并使用 ORDER BY 运算符将其存储到另一个名为 limit_data 的关系中，如下所示。

grunt> limit_data = LIMIT student_details 4;

验证

使用 DUMP 运算符验证关系 limit_data ，如下所示。

grunt> Dump limit_data;

输出

它将产生以下输出，显示关系 limit_data 的内容如下。

(1,Rajiv,Reddy,21,9848022337,Hyderabad)

(2,siddarth,Battacharya,22,9848022338,Kolkata)

(3,Rajesh,Khanna,22,9848022339,Delhi)

(4,Preethi,Agarwal,21,9848022330,Pune)

Apache Pig Eval函数

Apache Pig提供了各种内置函数，即 eval，load，store，math，string，bag 和 tuple 函数。

Eval函数

下面给出了Apache Pig提供的 eval 函数列表。

S.N.

函数＆描述

AVG()

计算包内数值的平均值。

BagToString()

将包的元素连接成字符串。在连接时，我们可以在这些值之间放置分隔符（可选）。

CONCAT()

连接两个或多个相同类型的表达式。

COUNT()

获取包中元素的数量，同时计算包中元组的数量。

COUNT_STAR()

它类似于 COUNT() 函数。它用于获取包中的元素数量。

DIFF()

比较元组中的两个包（字段）。

IsEmpty()

检查包或映射是否为空。

MAX()

计算单列包中的列（数值或字符）的最大值。

MIN()

要获取单列包中特定列的最小（最低）值（数字或字符）。

PluckTuple()

使用Pig Latin的 PluckTuple() 函数，可以定义字符串Prefix，并过滤以给定prefix开头的关系中的列。

SIZE()

基于任何Pig数据类型计算元素的数量。

SUBTRACT()

两个包相减，它需要两个包作为输入，并返回包含第一个包中不在第二个包中的元组的包。

SUM()

要获取单列包中某列的数值总和。

TOKENIZE()

要在单个元组中拆分字符串（其中包含一组字），并返回包含拆分操作的输出的包。

Apache Pig 加载和存储函数

Apache Pig中的加载和存储函数用于确定数据如何从Pig中弹出。这些函数与加载和存储运算符一起使用。下面给出了Pig中可用的加载和存储函数的列表。

S.N.

函数 & 描述

PigStorage()

加载和存储结构化文件。

TextLoader()

将非结构化数据加载到Pig中。

BinStorage()

使用机器可读格式将数据加载并存储到Pig中。

Handling Compression

在Pig Latin中，我们可以加载和存储压缩数据。

Apache Pig 包和元组函数

下面给出了Bag和Tuple函数的列表。

S.N.

函数＆描述

TOBAG()

将两个或多个表达式转换为包。

TOP()

获取关系的顶部 N 个元组。

TOTUPLE()

将一个或多个表达式转换为元组。

TOMAP()

将key-value对转换为Map。

Apache Pig 字符串函数

在Apache Pig中有以下String函数。

S.N.

函数＆描述

ENDSWITH(string, testAgainst)

验证给定字符串是否以特定子字符串结尾。

STARTSWITH(string, substring)

接受两个字符串参数，并验证第一个字符串是否以第二个字符串开头。

SUBSTRING(string, startIndex, stopIndex)

返回来自给定字符串的子字符串。

EqualsIgnoreCase(string1, string2)

比较两个字符串，忽略大小写。

INDEXOF(string,‘character’, startIndex)

返回字符串中第一个出现的字符，从开始索引向前搜索。

LAST_INDEX_OF(expression)

返回字符串中最后一次出现的字符的索引，从开始索引向后搜索。

LCFIRST(expression)

将字符串中的第一个字符转换为小写。

UCFIRST(expression)

返回一个字符串，其中第一个字符转换为大写。

UPPER(expression)

返回转换为大写的字符串。

LOWER(expression)

将字符串中的所有字符转换为小写。

REPLACE(string,‘oldChar’, ‘newChar’);

使用新字符替换字符串中的现有字符。

STRSPLIT(string, regex, limit)

围绕给定正则表达式的匹配拆分字符串。

STRSPLITTOBAG(string, regex, limit)

与 STRSPLIT() 函数类似，它通过给定的分隔符将字符串拆分，并将结果返回到包中。

TRIM(expression)

返回删除了前端和尾部空格的字符串的副本。

LTRIM(expression)

返回删除了前端空格的字符串的副本。

RTRIM(expression)

返回已删除尾部空格的字符串的副本。

Apache Pig 日期时间函数

Apache Pig提供以下日期和时间函数 -

S.N.

函数＆描述

ToDate(milliseconds)

此函数根据给定的参数返回日期时间对象。此函数的另一个替代方法是ToDate（iosstring），ToDate（userstring,format），ToDate（userstring,format,timezone）

CurrentTime()

返回当前时间的日期时间对象。

GetDay(datetime)

从日期时间对象返回一个月中的某一天。

GetHour(datetime)

从日期时间对象返回一天中的小时。

GetMilliSecond(datetime)

从日期时间对象返回秒中的毫秒。

GetMinute(datetime)

从日期时间对象返回一小时中的分钟。

GetMonth(datetime)

从日期时间对象返回一年中的月份。

GetSecond(datetime)

从日期时间对象返回一分钟的秒。

GetWeek(datetime)

从日期时间对象返回一年中的周。

GetWeekYear(datetime)

从日期时间对象返回周年。

GetYear(datetime)

从日期时间对象返回年份。

AddDuration(datetime, duration)

返回日期时间对象的结果以及持续时间对象。

SubtractDuration(datetime, duration)

从Date-Time对象中减去Duration对象并返回结果。

DaysBetween(datetime1, datetime2)

返回两个日期时间对象之间的天数。

HoursBetween(datetime1, datetime2)

返回两个日期时间对象之间的小时数。

MilliSecondsBetween(datetime1, datetime2)

返回两个日期时间对象之间的毫秒数。

MinutesBetween(datetime1, datetime2)

返回两个日期时间对象之间的分钟数。

MonthsBetween(datetime1, datetime2)

返回两个日期时间对象之间的月数。

SecondsBetween(datetime1, datetime2)

返回两个日期时间对象之间的秒数。

WeeksBetween(datetime1, datetime2)

返回两个日期时间对象之间的周数。

YearsBetween(datetime1, datetime2)

返回两个日期时间对象之间的年数。

Apache Pig 数学函数

我们在Apache Pig中有以下Math（数学）函数:

S.N.

函数＆描述

ABS(expression)

获取表达式的绝对值。

ACOS(expression)

获得表达式的反余弦值。

ASIN(expression)

获取表达式的反正弦值。

ATAN(expression)

此函数用于获取表达式的反正切值。

CBRT(expression)

此函数用于获取表达式的立方根。

CEIL(expression)

此函数用于获取向上舍入到最接近的整数的表达式的值（近1取整）。

COS(expression)

此函数用于获取表达式的三角余弦值。

COSH(expression)

此函数用于获取表达式的双曲余弦值。

EXP(expression)

此函数用于获得欧拉数e乘以x的幂，即指数。

FLOOR(expression)

要获得向下取整为最接近整数的表达式的值（四舍五入取整）。

LOG(expression)

获得表达式的自然对数（基于e）。

LOG10(expression)

得到表达式的基于10的对数。

RANDOM( )

获得大于或等于0.0且小于1.0的伪随机数（double类型）。

ROUND(expression)

要将表达式的值四舍五入为整数（如果结果类型为float）或四舍五入为长整型（如果结果类型为double）。

SIN(expression)

获得表达式的正弦值。

SINH(expression)

获得表达式的双曲正弦值。

SQRT(expression)

获得表达式的正平方根。

TAN(expression)

获得角度的三角正切。

TANH(expression)

获得表达式的双曲正切。

Apache Pig 用户定义函数（UDF）

除了内置函数之外，Apache Pig还为 User Defined Function（UDF：用户定义函数）提供广泛的支持。使用这些UDF，可以定义我们自己的函数并使用它们。UDF支持六种编程语言，即Java，Jython，Python，JavaScript，Ruby和Groovy。

对于编写UDF，在Java中提供全面的支持，并在所有其他语言中提供有限的支持。使用Java，你可以编写涉及处理的所有部分的UDF，如数据加载/存储，列转换和聚合。由于Apache Pig是用Java编写的，因此与其他语言相比，使用Java语言编写的UDF工作效率更高。

在Apache Pig中，我们还有一个用于UDF名为 Piggybank 的Java存储库。使用Piggybank，我们可以访问由其他用户编写的Java UDF，并贡献我们自己的UDF。

Java中的UDF的类型

在使用Java编写UDF时，我们可以创建和使用以下三种类型的函数

Filter函数 - Filter（过滤）函数用作过滤器语句中的条件。这些函数接受Pig值作为输入并返回布尔值。

Eval函数 - Eval函数在FOREACH-GENERATE语句中使用。这些函数接受Pig值作为输入并返回Pig结果。

Algebraic函数 - Algebraic（代数）函数对FOREACHGENERATE语句中的内包起作用。这些函数用于对内包执行完全MapReduce操作。

使用Java编写UDF

要使用Java编写UDF，我们必须集成jar文件 Pig-0.15.0.jar 。在本章节中，将讨论如何使用Eclipse编写示例UDF。在继续学习前，请确保你已在系统中安装了Eclipse和Maven。

按照下面给出的步骤写一个UDF函数：

打开Eclipse并创建一个新项目（例如 myproject ）。

将新创建的项目转换为Maven项目。

在pom.xml中复制以下内容。此文件包含Apache Pig和Hadoop-core jar文件的Maven依赖关系。

<project xmlns = "http://maven.apache.org/POM/4.0.0"

   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0http://maven.apache .org/xsd/maven-4.0.0.xsd">

   <modelVersion>4.0.0</modelVersion>

   <groupId>Pig_Udf</groupId>

   <artifactId>Pig_Udf</artifactId>

   <version>0.0.1-SNAPSHOT</version>

   <build>

      <sourceDirectory>src</sourceDirectory>

      <plugins>

         <plugin>

            <artifactId>maven-compiler-plugin</artifactId>

            <version>3.3</version>

            <configuration>

               <source>1.7</source>

               <target>1.7</target>

            </configuration>

         </plugin>

      </plugins>

   </build>

   <dependencies>

      <dependency>

         <groupId>org.apache.pig</groupId>

         <artifactId>pig</artifactId>

         <version>0.15.0</version>

      </dependency>

      <dependency>

         <groupId>org.apache.hadoop</groupId>

         <artifactId>hadoop-core</artifactId>

         <version>0.20.2</version>

      </dependency>

   </dependencies>

</project>

保存文件并刷新它。在 Maven依赖关系部分中，可以找到下载的jar文件。

创建名为 Sample_Eval 的新的类文件，并在其中复制以下内容。

import java.io.IOException;

import org.apache.pig.EvalFunc;

import org.apache.pig.data.Tuple;

import java.io.IOException;

import org.apache.pig.EvalFunc;

import org.apache.pig.data.Tuple;

public class Sample_Eval extends EvalFunc<String>{

   public String exec(Tuple input) throws IOException {

      if (input == null || input.size() == 0)

      return null;

      String str = (String)input.get(0);

      return str.toUpperCase();

在编写UDF时，必须继承EvalFunc类并向 exec() 函数提供实现。在此函数中，写入UDF所需的代码。在上面的例子中，我们返回了将给定列的内容转换为大写的代码。

编译完类并确认没有错误后，右键单击Sample_Eval.java文件。它将呈现一个菜单。选择“export”，如以下屏幕截图所示。

点击“export”，将看到以下窗口。点击“JAR file”。

点击“Next>”按钮继续操作。将获得另一个窗口，你需要在本地文件系统中输入路径，在其中存储jar文件。

最后，单击“Finish”按钮。在指定的文件夹中，创建一个Jar文件 sample_udf.jar 。此jar文件包含用Java编写的UDF。

使用UDF

在编写UDF和生成Jar文件后，请按照下面给出的步骤：

步骤1：注册Jar文件

在写入UDF（在Java中）后，我们必须使用Register运算符注册包含UDF的Jar文件。通过注册Jar文件，用户可以将UDF的位置绑定到Apache Pig。

语法

下面给出了Register运算符的语法。

REGISTER path;

例

让我们注册本章前面创建的sample_udf.jar。以本地模式启动Apache Pig并注册jar文件sample_udf.jar，如下所示。

$cd PIG_HOME/bin

$./pig –x local

REGISTER '/$PIG_HOME/sample_udf.jar'

注意：假设路径中的Jar文件：/$PIG_HOME/sample_udf.jar

步骤2：定义别名

注册UDF后，可以使用 Define 运算符为其定义一个别名。

语法

下面给出了Define运算符的语法。

DEFINE alias {function | [`command` [input] [output] [ship] [cache] [stderr] ] };

例

定义sample_eval的别名，如下所示。

DEFINE sample_eval sample_eval();

步骤3：使用UDF

定义别名后，可以使用与内置函数相同的UDF。假设在HDFS /Pig_Data/ 目录中有一个名为emp_data的文件，其中包含以下内容。

001,Robin,22,newyork

002,BOB,23,Kolkata

003,Maya,23,Tokyo

004,Sara,25,London

005,David,23,Bhuwaneshwar

006,Maggy,22,Chennai

007,Robert,22,newyork

008,Syam,23,Kolkata

009,Mary,25,Tokyo

010,Saran,25,London

011,Stacy,25,Bhuwaneshwar

012,Kelly,22,Chennai

并假设我们已将此文件加载到Pig中，如下所示。

grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp1.txt' USING PigStorage(',')

   as (id:int, name:chararray, age:int, city:chararray);

现在使用UDF sample_eval 将员工的姓名转换为大写。

grunt> Upper_case = FOREACH emp_data GENERATE sample_eval(name);

请验证关系 Upper_case 的内容，如下所示。

grunt> Dump Upper_case;

(ROBIN)

(BOB)

(MAYA)

(SARA)

(DAVID)

(MAGGY)

(ROBERT)

(SYAM)

(MARY)

(SARAN)

(STACY)

(KELLY)

Apache Pig 运行脚本

Pig脚本中的注释

在将脚本写入文件时，我们可以在其中包含注释，如下所示。

多行注释

我们将用'/*'开始多行注释，以'*/'结束。

/* These are the multi-line comments

  In the pig script */

单行注释

我们将用“--"开始单行注释。

--we can write single line comments like this.

在批处理模式下执行Pig脚本

在以批处理方式执行Apache Pig语句时，请按照以下步骤操作。

步骤1

将所有需要的Pig Latin语句写在单个文件中。我们可以将所有Pig Latin语句和命令写入单个文件，并将其另存为 .pig 文件。

步骤2

执行Apache Pig脚本。你可以从shell（Linux）执行Pig脚本，如下所示。

Local模式

MapReduce模式

$ pig -x local Sample_script.pig

$ pig -x mapreduce Sample_script.pig

你可以使用exec命令从Grunt shell执行它，如下所示。

grunt> exec /sample_script.pig

从HDFS执行Pig脚本

我们还可以执行驻留在HDFS中的Pig脚本。假设在名为 /pig_data/ 的HDFS目录中有名为 Sample_script.pig 的Pig脚本。我们可以执行它如下所示。

$ pig -x mapreduce hdfs://localhost:9000/pig_data/Sample_script.pig

例

假设在HDFS中有一个具有以下内容的文件 student_details.txt 。

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad

002,siddarth,Battacharya,22,9848022338,Kolkata

003,Rajesh,Khanna,22,9848022339,Delhi

004,Preethi,Agarwal,21,9848022330,Pune

005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar

006,Archana,Mishra,23,9848022335,Chennai

007,Komal,Nayak,24,9848022334,trivendram

008,Bharathi,Nambiayar,24,9848022333,Chennai

我们还在同一个HDFS目录中有一个名为 sample_script.pig 的示例脚本。此文件包含对student关系执行操作和转换的语句，如下所示。

student = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')

   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);

student_order = ORDER student BY age DESC;

student_limit = LIMIT student_order 4;

Dump student_limit;

脚本的第一个语句会将名为 student_details.txt 的文件中的数据加载为名为student的关系。

脚本的第二个语句将根据年龄以降序排列关系的元组，并将其存储为 student_order 。

脚本的第三个语句会将 student_order 的前4个元组存储为 student_limit 。

最后，第四个语句将转储关系 student_limit 的内容。

现在，执行 sample_script.pig ，如下所示。

$./pig -x mapreduce hdfs://localhost:9000/pig_data/sample_script.pig

Apache Pig被执行，并提供具有以下内容的输出。

(7,Komal,Nayak,24,9848022334,trivendram)

(8,Bharathi,Nambiayar,24,9848022333,Chennai)

(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)

(6,Archana,Mishra,23,9848022335,Chennai)

2015-10-19 10:31:27,446 [main] INFO  org.apache.pig.Main - Pig script completed in 12

minutes, 32 seconds and 751 milliseconds (752751 ms)

----------------------------------------------------------------------------------------------------------------------------------------------------------

Apache Pig AVG()函数
Pig-Latin AVG() 函数用于计算包内数值的平均值。在计算平均值时， AVG() 函数会忽略NULL值。
注意
·         
要获取全局平均值，我们需要执行Group All操作，并使用 AVG() 函数计算平均值。
·         
·         
要获取组的平均值，我们需要使用Group By运算符对其进行分组，然后继续使用average函数。
·         
语法
下面给出了 AVG() 函数的语法。
grunt> AVG(expression) 
例
假设我们在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad,89
002,siddarth,Battacharya,22,9848022338,Kolkata,78
003,Rajesh,Khanna,22,9848022339,Delhi,90 
004,Preethi,Agarwal,21,9848022330,Pune,93 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75 
006,Archana,Mishra,23,9848022335,Chennai,87 
007,Komal,Nayak,24,9848022334,trivendram,83 
008,Bharathi,Nambiayar,24,9848022333,Chennai,72 
通过关系 student_details 将此文件加载到的Pig中，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray, gpa:int);
计算平均GPA
我们可以使用内置函数 AVG() （区分大小写）来计算一组数值的平均值。让我们使用Group All运算符将关系 student_details 分组，并将结果存储在名为 student_group_all 的关系中，如下所示。
grunt> student_group_all = Group student_details All;
这将产生如下所示的关系。
grunt> Dump student_group_all;
   
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022 334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohan thy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3 ,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Ko lkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89)})
现在让我们使用 AVG() 函数计算所有学生的全球平均GPA，如下所示。
grunt> student_gpa_avg = foreach student_group_all  Generate
   (student_details.firstname, student_details.gpa), AVG(student_details.gpa); 
验证
使用 DUMP 运算子验证关系 student_gpa_avg ，如下所示。
grunt> Dump student_gpa_avg; 
输出
它将显示关系 student_gpa_avg 的内容，如下所示。
(({(Bharathi),(Komal),(Archana),(Trupthi),(Preethi),(Rajesh),(siddarth),(Rajiv) }, 
  {   (72)   ,  (83) ,   (87)  ,   (75)  ,   (93)  ,  (90)  ,   (78)   ,  (89)  }),83.375)
 
 
 
Apache PigBagToString()函数
Pig Latin的  BagToString() 函数用于将包的元素连接成字符串。在连接时，我们可以在这些值之间放置分隔符（可选）。通常，包是无序的，可以使用ORDER BY 运算符排序。
语法
下面给出了 BagToString() 函数的语法。
grunt> BagToString(vals:bag [, delimiter:chararray])
例
假设在HDFS目录 /pig_data/ 中有一个名为 date of birth.txt 的文件，如下所示。 此文件包含出生日期。
dateofbirth.txt
22,3,1990
23,11,1989
1,3,1998
2,6,1980
26,9,1989
通过关系 dob 将这个文件加载到Pig中，如下所示。
grunt> dob = LOAD 'hdfs://localhost:9000/pig_data/dateofbirth.txt' USING PigStorage(',')
   as (day:int, month:int, year:int);
将包转换为字符串
使用 bagtostring() 函数，我们可以将bag中的数据转换为字符串。让我们将 dob 关系分组，组操作将生成含有关系的所有元组的包。
使用Group All运算符将关系 dob 分组，并将结果存储在名为 group_dob 的关系中，如下所示。
grunt> group_dob = Group dob All;
它将产生如下所示的关系。
grunt> Dump group_dob; 
 
(all,{(26,9,1989),(2,6,1980),(1,3,1998),(23,11,1989),(22,3,1990)})
在这里，我们可以观察到一个有所有出生日期的包作为它的元组。现在，让我们使用函数 BagToString() 将包转换为字符串。
grunt> dob_string = foreach group_dob Generate BagToString(dob);
验证
使用 DUMP 运算符验证关系 dob_string ，如下所示。
grunt> Dump dob_string;
输出
它将产生以下输出，显示关系 dob_string 的内容。
(26_9_1989_2_6_1980_1_3_1998_23_11_1989_22_3_1990)
 
Apache Pig CONCAT()函数
Pig Latin的 CONCAT() 函数用于连接两个或多个相同类型的表达式。
语法
grunt> CONCAT (expression, expression, [...expression])
例
假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad,89
002,siddarth,Battacharya,22,9848022338,Kolkata,78 
003,Rajesh,Khanna,22,9848022339,Delhi,90 
004,Preethi,Agarwal,21,9848022330,Pune,93 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75 
006,Archana,Mishra,23,9848022335,Chennai,87 
007,Komal,Nayak,24,9848022334,trivendram,83 
008,Bharathi,Nambiayar,24,9848022333,Chennai,72
通过关系 student_details 将此文件加载到的Pig中，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray, gpa:int);
连接两个字符串
我们可以使用 CONCAT() 函数来连接两个或多个表达式。 首先，使用Dump运算符验证 student_details 关系的内容，如下所示。
grunt> Dump student_details;
 
( 1,Rajiv,Reddy,21,9848022337,Hyderabad,89 ) 
( 2,siddarth,Battacharya,22,9848022338,Kolkata,78 )
( 3,Rajesh,Khanna,22,9848022339,Delhi,90 ) 
( 4,Preethi,Agarwal,21,9848022330,Pune,93 )
( 5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75 )
( 6,Archana,Mishra,23,9848022335,Chennai,87 )
( 7,Komal,Nayak,24,9848022334,trivendram,83 )
( 8,Bharathi,Nambiayar,24,9848022333,Chennai,72 )
然后，使用 describe 运算符验证schema（模式），如下所示。
grunt> Describe student_details;
  
student_details: {id: int, firstname: chararray, lastname: chararray, age: int,
   phone: chararray, city: chararray, gpa: int}
在上面的模式中，可以观察到学生的名称使用两个字符值即 firstname 和 lastname 来表示。让我们使用 CONCAT() 函数来连接这两个值。
grunt> student_name_concat = foreach student_details Generate CONCAT (firstname, lastname);
验证
使用 DUMP 运算符验证关系 student_name_concat ，如下所示。
grunt> Dump student_name_concat;
输出
它将产生以下输出，显示关系 student_name_concat 的内容。
(RajivReddy) 
(siddarthBattacharya) 
(RajeshKhanna) 
(PreethiAgarwal) 
(TrupthiMohanthy) 
(ArchanaMishra) 
(KomalNayak) 
(BharathiNambiayar) 
我们还可以在两个表达式之间使用可选的分隔符，如下所示。
grunt> CONCAT(firstname, '_',lastname);
现在，让我们通过将 student_details 关系中的 '_' 连接学生记录的firstname和lastname，如下所示。
grunt> student_name_concat = foreach student_details GENERATE CONCAT(firstname, '_',lastname); 
验证
使用 DUMP 运算符验证关系 student_name_concat ，如下所示。
grunt> Dump student_name_concat;
输出
它将产生以下输出，显示关系 student_name_concat 的内容如下。
(Rajiv_Reddy) 
(siddarth_Battacharya) 
(Rajesh_Khanna) 
(Preethi_Agarwal) 
(Trupthi_Mohanthy) 
(Archana_Mishra) 
(Komal_Nayak) 
(Bharathi_Nambiayar)
Apache Pig COUNT()函数
Pig Latin的 COUNT() 函数用于获取包中的元素数量。而在计算包中元组数量时， COUNT() 函数忽略（不计算）在FIRST FIELD中具有NULL值的元组。
注意
·         
要获取全局计数值（包中的元组总数），我们需要执行Group All操作，并使用COUNT()函数计算计数值。
·         
·         
要获取组的计数值（组中的元组数），我们需要使用Group By运算符对其进行分组，然后继续count函数。
·         
语法
以下给出了 COUNT() 函数的语法。
grunt> COUNT(expression)
例
假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad,89
002,siddarth,Battacharya,22,9848022338,Kolkata,78 
003,Rajesh,Khanna,22,9848022339,Delhi,90 
004,Preethi,Agarwal,21,9848022330,Pune,93 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75 
006,Archana,Mishra,23,9848022335,Chennai,87 
007,Komal,Nayak,24,9848022334,trivendram,83 
008,Bharathi,Nambiayar,24,9848022333,Chennai,72
通过关系 student_details 将此文件加载到的Pig中，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray, gpa:int);
计算元组数
我们可以使用内置函数 COUNT() （区分大小写）来计算关系中的元组数。使用Group All运算符将关系 student_details 分组，并将结果存储在名为student_group_all 的关系中，如下所示。
grunt> student_group_all = Group student_details All;
它将产生如下所示的关系。
grunt> Dump student_group_all;
  
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022 334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohan thy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3 ,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Ko lkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89)})
现在让我们计算关系中的元组/记录的数量。
grunt> student_count = foreach student_group_all  Generate COUNT(student_details.gpa);
验证
使用 DUMP 运算符验证关系 student_count ，如下所示。
grunt> Dump student_count;
输出
它将产生以下输出，显示关系student_count的内容。
8
Apache PigCOUNT_STAR()函数
Pig Latin的 COUNT_STAR() 函数与 COUNT() 函数类似。它用于获取包中的元素数量。在计数元素时， COUNT_STAR() 函数包含NULL值。
注意
·         
要获取全局计数值（包中的元组总数），我们需要执行Group All操作，并使用COUNT_STAR()函数计算count_star值。
·         
·         
要获取组的计数值（组中的元组数），我们需要使用 Group By 运算符对其进行分组，然后继续使用count_star函数。
·         
语法
下面给出了 COUNT_STAR() 函数的语法。
grunt> COUNT_STAR(expression)
例
假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示，此文件包含空记录。
student_details.txt
, , , , , , , 
001,Rajiv,Reddy,21,9848022337,Hyderabad,89 
002,siddarth,Battacharya,22,9848022338,Kolkata,78 
003,Rajesh,Khanna,22,9848022339,Delhi,90 
004,Preethi,Agarwal,21,9848022330,Pune,93 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75 
006,Archana,Mishra,23,9848022335,Chennai,87 
007,Komal,Nayak,24,9848022334,trivendram,83 
008,Bharathi,Nambiayar,24,9848022333,Chennai,72
通过关系 student_details 将此文件加载到的Pig中，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray, gpa:int);
计算元组数
我们可以使用内置函数 COUNT_STAR() 来计算关系中的元组数。让我们使用Group All运算符将关系 student_details 分组，并将结果存储在名为student_group_all 的关系中，如下所示。
grunt> student_group_all = Group student_details All;
它将产生如下所示的关系。
grunt> Dump student_group_all;  
 
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022 334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohan thy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3 ,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Ko lkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89),
( , , , , , , )}) 
现在让我们计算关系中的元组/记录的数量。
grunt> student_count = foreach student_group_all  Generate COUNT_STAR(student_details.gpa);
验证
使用 DUMP 运算符验证关系 student_count ，如下所示。
grunt> Dump student_count;
输出
它将产生以下输出，显示关系 student_count 的内容。
9
因为我们使用了函数 COUNT_STAR() ，它包含了null元组并返回9。
 
Apache Pig DIFF()函数
Pig Latin的 DIFF() 函数用于比较元组中的两个包（字段）。它需要一个元组的两个字段作为输入并匹配它们。如果它们匹配，则返回一个空包。如果它们不匹配，它将找到存在于一个字段（包）中而在另一个字段中找不到的元素，并通过将它们打包进包中来返回这些元素。
语法
下面给出了 DIFF() 函数的语法。
grunt> DIFF (expression, expression)
例
通常， DIFF() 函数比较元组中的两个包。下面是它的例子，这里我们创建两个关系，将它们cogroup，并计算它们之间的差异。假设在HDFS目录/pig_data/ 中有两个文件，即 emp_sales.txt 和 emp_bonus.txt ，如下所示。 emp_sales.txt 包含销售部门员工的详细信息， emp_bonus.txt 包含获得奖金的员工详细信息。
emp_sales.txt
1,Robin,22,25000,sales 
2,BOB,23,30000,sales 
3,Maya,23,25000,sales 
4,Sara,25,40000,sales 
5,David,23,45000,sales 
6,Maggy,22,35000,sales
emp_bonus.txt
1,Robin,22,25000,sales 
2,Jaya,23,20000,admin 
3,Maya,23,25000,sales 
4,Alia,25,50000,admin 
5,David,23,45000,sales 
6,Omar,30,30000,admin
分别使用关系 emp_sales 和 emp_bonus 将这些文件加载到Pig中。
grunt> emp_sales = LOAD 'hdfs://localhost:9000/pig_data/emp_sales.txt' USING PigStorage(',')
   as (sno:int, name:chararray, age:int, salary:int, dept:chararray);
          
grunt> emp_bonus = LOAD 'hdfs://localhost:9000/pig_data/emp_bonus.txt' USING PigStorage(',')
   as (sno:int, name:chararray, age:int, salary:int, dept:chararray);  
使用COGROUP运算符和键 sno，将关系 emp_sales 和 emp_bonus 的记录/元组分组，如下所示。
grunt> cogroup_data = COGROUP emp_sales by sno, emp_bonus by sno;
使用 DUMP 运算符验证关系 cogroup_data ，如下所示。
grunt> Dump cogroup_data;
  
(1,{(1,Robin,22,25000,sales)},{(1,Robin,22,25000,sales)}) 
(2,{(2,BOB,23,30000,sales)},{(2,Jaya,23,20000,admin)}) 
(3,{(3,Maya,23,25000,sales)},{(3,Maya,23,25000,sales)}) 
(4,{(4,Sara,25,40000,sales)},{(4,Alia,25,50000,admin)}) 
(5,{(5,David,23,45000,sales)},{(5,David,23,45000,sales)}) 
(6,{(6,Maggy,22,35000,sales)},{(6,Omar,30,30000,admin)})
计算两个关系之间的差异
现在让我们使用 DIFF() 函数计算两个关系之间的差异，并将其存储在关系 diff_data 中，如下所示。
grunt> diff_data = FOREACH cogroup_data GENERATE DIFF(emp_sales,emp_bonus);
验证
使用DUMP运算符验证关系 diff_data ，如下所示。
grunt> Dump diff_data;
   
({}) 
({(2,BOB,23,30000,sales),(2,Jaya,23,20000,admin)}) 
({}) 
({(4,Sara,25,40000,sales),(4,Alia,25,50000,admin)}) 
({}) 
({(6,Maggy,22,35000,sales),(6,Omar,30,30000,admin)})
如果 emp_bonus 和 emp_sales 中的记录匹配，则 diff_data 关系将是空元组。在其他情况下，它将保存来自两个关系（不同的元组）的元组。
例如，如果将 sno 的记录视为 1 ，那么会发现它们在两个关系中都是相同的((1，Robin，22,25000，sales),(1，Robin，22,25000，sales))。因此，在 diff_data 关系中，将为 sno 1 得到一个空元组，它是 DIFF() 函数的结果。
 
Apache Pig IsEmpty()函数
Pig Latin的 IsEmpty() 函数用于检查包或映射是否为空。
语法
下面给出了 IsEmpty() 函数的语法。
grunt> IsEmpty(expression)
例
假设在HDFS目录 /pig_data/ 中有两个文件，即 emp_sales.txt 和 emp_bonus.txt ，如下所示。emp_sales.txt 包含销售部门员工的详细信息，emp_bonus.txt 包含获得奖金的员工详细信息。
emp_sales.txt
1,Robin,22,25000,sales 
2,BOB,23,30000,sales 
3,Maya,23,25000,sales 
4,Sara,25,40000,sales 
5,David,23,45000,sales 
6,Maggy,22,35000,sales
emp_bonus.txt
1,Robin,22,25000,sales 
2,Jaya,23,20000,admin 
3,Maya,23,25000,sales 
4,Alia,25,50000,admin 
5,David,23,45000,sales 
6,Omar,30,30000,admin
分别使用关系 emp_sales 和 emp_bonus ，将这些文件加载到Pig中，如下所示。
grunt> emp_sales = LOAD 'hdfs://localhost:9000/pig_data/emp_sales.txt' USING PigStorage(',')
   as (sno:int, name:chararray, age:int, salary:int, dept:chararray);
          
grunt> emp_bonus = LOAD 'hdfs://localhost:9000/pig_data/emp_bonus.txt' USING PigStorage(',')
   as (sno:int, name:chararray, age:int, salary:int, dept:chararray);
现在让我们使用 cogroup 来分组 emp_sales 和 emp_bonus 关系的记录/ 运算符，如下所示。
grunt> cogroup_data = COGROUP emp_sales by age, emp_bonus by age;
使用 DUMP 运算符验证关系 cogroup_data ，如下所示。
grunt> Dump cogroup_data;
  
(22,{(6,Maggy,22,35000,sales),(1,Robin,22,25000,sales)}, {(1,Robin,22,25000,sales)}) 
(23,{(5,David,23,45000,sales),(3,Maya,23,25000,sales),(2,BOB,23,30000,sales)}, 
   {(5,David,23,45000,sales),(3,Maya,23,25000,sales),(2,Jaya,23,20000,admin)})  
(25,{(4,Sara,25,40000,sales)},{(4,Alia,25,50000,admin)}) 
(30,{},{(6,Omar,30,30000,admin)})
COGROUP操作符根据年龄从每个关系中分组元组，每个组描述特定的年龄值。例如，如果我们考虑结果的第一个元组，则按照年龄22分组。包含两个包，第一个包包含所有来自第一个关系的元组（本例中为student_details），其年龄为22岁，第二个 bag包含来自具有年龄22的第二关系（在这种情况下是employee_details）的所有元组。如果关系不具有年龄值为22的元组，则它返回一个空包。
获得有空包的组
让我们使用 IsEmpty() 函数从组中的 emp_sales 关系中列出这些空包。
grunt> isempty_data = filter cogroup_data by IsEmpty(emp_sales);
验证
使用DUMP运算符验证关系 isempty_data ，如下所示。 emp_sales 关系保存了 emp_bonus 关系中不存在的元组。
grunt> Dump isempty_data; 
  
(30,{},{(6,Omar,30,30000,admin)})
Apache Pig MAX()函数
Pig Latin的  MAX() 函数用于计算单列包中的列（数值或字符）的最大值。 在计算最大值时， Max（）函数会忽略NULL值。
注意 -
·         
要获取全局最大值，我们需要执行Group All操作，并使用MAX()函数计算最大值。
·         
·         
要获取组的最大值，我们需要使用Group By运算符对其进行分组，然后继续执行Max()函数。
·         
语法
下面给出了 Max() 函数的语法。
grunt> Max(expression)
例
假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad,89 
002,siddarth,Battacharya,22,9848022338,Kolkata,78 
003,Rajesh,Khanna,22,9848022339,Delhi,90 
004,Preethi,Agarwal,21,9848022330,Pune,93 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75 
006,Archana,Mishra,23,9848022335,Chennai,87 
007,Komal,Nayak,24,9848022334,trivendram,83 
008,Bharathi,Nambiayar,24,9848022333,Chennai,72 
通过关系 student_details 将此文件加载到的Pig中，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray, gpa:int);
计算最大值GPA
我们可以使用内置函数 MAX() （区分大小写）从一组给定的数值计算最大值。让我们使用Group All运算符将关系 student_details 分组，并将结果存储在名为 student_group_all 的关系中，如下所示。
grunt> student_group_all = Group student_details All;
这将产生如下所示的关系。
grunt> Dump student_group_all;
  
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022 334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohan thy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Ko lkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89)})
现在使用 MAX() 函数计算GPA的全局最大值，即所有学生的GPA值中的最大值，如下所示。
grunt> student_gpa_max = foreach student_group_all  Generate
   (student_details.firstname, student_details.gpa), MAX(student_details.gpa);
验证
使用 DUMP 运算子验证关系 student_gpa_max ，如下所示。
grunt> Dump student_gpa_max;
输出
它将产生以下输出，显示关系 student_gpa_max 的内容。
(({(Bharathi),(Komal),(Archana),(Trupthi),(Preethi),(Rajesh),(siddarth),(Rajiv) } , 
    {    (72)    ,   (83)  ,     (87)   ,    (75)   ,   (93)   ,   (90)   ,     (78)   ,  (89)    }) ,93)
 
Apache Pig MIN()函数
Pig Latin的 MIN() 函数用于获取单列包中某列的最小值（最低值）（数字或字符）。在计算最小值时， MIN() 函数会忽略NULL值。
注意
·         
要获得全局最小值，我们需要执行Group All操作，并使用MIN()函数计算最小值。
·         
·         
要获取组的最小值，我们需要使用 Group By 运算符对其进行分组，然后继续执行Min()函数。
·         
语法
下面给出了 MIN() 函数的语法。
grunt> MIN(expression)
例
假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad,89 
002,siddarth,Battacharya,22,9848022338,Kolkata,78 
003,Rajesh,Khanna,22,9848022339,Delhi,90 
004,Preethi,Agarwal,21,9848022330,Pune,93 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75 
006,Archana,Mishra,23,9848022335,Chennai,87 
007,Komal,Nayak,24,9848022334,trivendram,83 
008,Bharathi,Nambiayar,24,9848022333,Chennai,72
通过关系 student_details 将此文件加载到的Pig中，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray, gpa:int);
计算最小值GPA
我们可以使用内置函数 MIN() （区分大小写）从一组给定的数值计算最小值。让我们使用Group All运算符将关系 student_details 分组，并将结果存储在名为 student_group_all 的关系中，如下所示
grunt> student_group_all = Group student_details All;
它将产生如下所示的关系。
grunt> Dump student_group_all;
  
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022 334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohan thy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3 ,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Ko lkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89)})
现在让我们使用 MIN() 函数计算GPA的全局最小值，即所有学生的GPA值中的最小值，如下所示。
grunt> student_gpa_min = foreach student_group_all  Generate
   (student_details.firstname, student_details.gpa), MIN(student_details.gpa);
验证
使用 DUMP 运算子验证关系 student_gpa_min ，如下所示。
grunt> Dump student_gpa_min;
输出
它将产生以下输出，显示关系 student_gpa_min 的内容。
(({(Bharathi),(Komal),(Archana),(Trupthi),(Preethi),(Rajesh),(siddarth),(Rajiv) } , 
   {    (72)    ,   (83)  ,     (87)   ,    (75)   ,   (93)   ,   (90)   ,     (78)   ,  (89)    }) ,72)
 
Apache Pig SIZE()函数
Pig Latin的 SIZE() 函数用于基于任何Pig数据类型计算元素的数量。
语法
下面给出了 SIZE() 函数的语法。
grunt> SIZE(expression)
返回值根据Apache Pig中的数据类型而有所不同。
数据类型
值
int，long，float，double
对于所有这些类型，size()函数返回1。
Char array
对于char数组，size()函数返回数组中的字符数。
Byte array
对于bytearray，size()函数返回数组中的字节数。
Tuple
对于元组，size()函数返回元组中的字段数。
Bag
对于包，size()函数返回包中的元组数。
Map
对于映射，size()函数返回映射中键/值对的数量。
例
假设在HDFS目录 /pig_data/ 中有一个名为 employee.txt 的文件，如下所示。
employee.txt
1,John,2007-01-24,250
2,Ram,2007-05-27,220  
3,Jack,2007-05-06,170  
3,Jack,2007-04-06,100  
4,Jill,2007-04-06,220  
5,Zara,2007-06-06,300  
5,Zara,2007-02-06,350 
通过关系 employee_data 将此文件加载到Pig中，如下所示。
grunt> employee_data = LOAD 'hdfs://localhost:9000/pig_data/ employee.txt' USING PigStorage(',')
   as (id:int, name:chararray, workdate:chararray, daily_typing_pages:int);
计算类型的大小
要计算特定列的类型大小，可以使用 SIZE() 函数。让我们计算name类型的大小，如下所示。
grunt> size = FOREACH employee_data GENERATE SIZE(name);
验证
使用 DUMP 运算符验证关系 size ，如下所示。
grunt> Dump size;
输出
它将产生以下输出，显示关系 size 的内容如下。在示例中，我们计算了 name 列的大小。由于它是varchar类型，因此 SIZE() 函数给出每个员工姓名中的字符数。
(4) 
(3) 
(4) 
(4) 
(4) 
(4) 
(4) 
 
Apache PigPluckTuple()函数
 
在执行join之类的操作以区分两个模式的列之后，我们使用函数 PluckTuple() 。要使用此函数，首先，我们必须定义一个字符串Prefix，并且我们必须对以该prefix开头的关系中的列进行过滤。
语法
下面给出了 PluckTuple() 函数的语法。
DEFINE pluck PluckTuple(expression1) 
DEFINE pluck PluckTuple(expression1,expression3) 
pluck(expression2)
例
假设在HDFS目录 /pig_data/ 中有两个文件，分别是 emp_sales.txt 和 emp_bonus.txt 。 emp_sales.txt 包含销售部门员工的详细信息，emp_bonus.txt 包含获得奖金的员工详细信息。
emp_sales.txt
1,Robin,22,25000,sales 
2,BOB,23,30000,sales 
3,Maya,23,25000,sales 
4,Sara,25,40000,sales 
5,David,23,45000,sales 
6,Maggy,22,35000,sales
emp_bonus.txt
1,Robin,22,25000,sales 
2,Jaya,23,20000,admin 
3,Maya,23,25000,sales 
4,Alia,25,50000,admin 
5,David,23,45000,sales
6,Omar,30,30000,admin
分别使用关系 emp_sales 和 emp_bonus ，将这些文件加载到Pig中。
grunt> emp_sales = LOAD 'hdfs://localhost:9000/pig_data/emp_sales.txt' USING PigStorage(',')
   as (sno:int, name:chararray, age:int, salary:int, dept:chararray);
          
grunt> emp_bonus = LOAD 'hdfs://localhost:9000/pig_data/emp_bonus.txt' USING PigStorage(',')
   as (sno:int, name:chararray, age:int, salary:int, dept:chararray);
使用 join 运算符连接这两个关系，如下所示。
grunt> join_data = join emp_sales by sno, emp_bonus by sno;
使用 Dump 运算符验证关系 join_data 。
grunt> Dump join_data;
 
(1,Robin,22,25000,sales,1,Robin,22,25000,sales)
(2,BOB,23,30000,sales,2,Jaya,23,20000,admin)
(3,Maya,23,25000,sales,3,Maya,23,25000,sales)
(4,Sara,25,40000,sales,4,Alia,25,50000,admin) 
(5,David,23,45000,sales,5,David,23,45000,sales) 
(6,Maggy,22,35000,sales,6,Omar,30,30000,admin)
使用PluckTuple() 函数
现在，使用 PluckTupe() 函数定义要用来区分列的必需表达式。
grunt> DEFINE pluck PluckTuple('a::');
过滤 join_data 关系中的列，如下所示。
grunt> data = foreach join_data generate FLATTEN(pluck(*));
描述名为 data 的关系，如下所示。
grunt> Describe data;
 
data: {emp_sales::sno: int, emp_sales::name: chararray, emp_sales::age: int,
   emp_sales::salary: int, emp_sales::dept: chararray, emp_bonus::sno: int,
   emp_bonus::name: chararray, emp_bonus::age: int, emp_bonus::salary: int,
   emp_bonus::dept: chararray}
由于我们已将表达式定义为“a ::"，因此 emp_sales 模式的列将被作为 emp_sales :: column name ，emp_bonus 模式的列将被作为emp_bonus :: column name

 
Apache PigSUBTRACT()函数
Pig Latin的 SUBTRACT() 函数用于两个包相减，它需要两个包作为输入，并返回包含第一个包中不在第二个包中的元组的包。
语法
下面给出了 SUBTRACT() 函数的语法。
grunt> SUBTRACT(expression, expression)
例
假设在HDFS目录 /pig_data/ 中有两个文件，即 emp_sales.txt 和 emp_bonus.txt ，如下所示。 emp_sales.txt 包含销售部门员工的详细信息， emp_bonus.txt 包含获得奖金的员工详细信息。
emp_sales.txt
1,Robin,22,25000,sales 
2,BOB,23,30000,sales 
3,Maya,23,25000,sales 
4,Sara,25,40000,sales 
5,David,23,45000,sales 
6,Maggy,22,35000,sales
emp_bonus.txt
1,Robin,22,25000,sales 
2,Jaya,23,20000,admin 
3,Maya,23,25000,sales 
4,Alia,25,50000,admin 
5,David,23,45000,sales 
6,Omar,30,30000,admin
分别使用关系 emp_sales 和 emp_bonus ，将这些文件加载到Pig中，如下所示。
grunt> emp_sales = LOAD 'hdfs://localhost:9000/pig_data/emp_sales.txt' USING PigStorage(',')
   as (sno:int, name:chararray, age:int, salary:int, dept:chararray);
          
grunt> emp_bonus = LOAD 'hdfs://localhost:9000/pig_data/emp_bonus.txt' USING PigStorage(',')
   as (sno:int, name:chararray, age:int, salary:int, dept:chararray);  
现在，让我们使用COGROUP运算符将关系 emp_sales 和 emp_bonus 的记录/元组与键 sno 分组，如下所示。
grunt> cogroup_data = COGROUP emp_sales by sno, emp_bonus by sno;
使用 DUMP 运算符验证关系 cogroup_data ，如下所示。
grunt> Dump cogroup_data; 
 
(1,{(1,Robin,22,25000,sales)},{(1,Robin,22,25000,sales)}) 
(2,{(2,BOB,23,30000,sales)},{(2,Jaya,23,30000,admin)}) 
(3,{(3,Maya,23,25000,sales)},{(3,Maya,23,25000,sales)}) 
(4,{(4,Sara,25,40000,sales)},{(4,Alia,25,50000,admin)}) 
(5,{(5,David,23,45000,sales)},{(5,David,23,45000,sales)}) 
(6,{(6,Maggy,22,35000,sales)},{(6,Omar,30,30000,admin)})
从一个关系中减去另一个关系
现在让我们从 emp_sales 关系中减去 emp_bonus 关系的元组。生成的关系保存 emp_sales 中不在 emp_bonus 中的元组。
grunt> sub_data = FOREACH cogroup_data GENERATE SUBTRACT(emp_sales, emp_bonus);
验证
使用DUMP运算符验证关系 sub_data ，如下所示。 emp_sales 关系保存了 emp_bonus 关系中不存在的元组。
grunt> Dump sub_data;
   
({})
({(2,BOB,23,30000,sales)})
({})
({(4,Sara,25,40000,sales)})
({})
({(6,Maggy,22,35000,sales)})
以同样的方式，让我们从 emp_bonus 关系中减去 emp_sales 关系，如下所示。
grunt> sub_data = FOREACH cogroup_data GENERATE SUBTRACT(emp_bonus, emp_sales);
使用Dump运算符验证 sub_data 关系的内容，如下所示。
grunt> Dump sub_data;
 
({}) 
({(2,Jaya,23,20000,admin)})
({})
({(4,Alia,25,50000,admin)})
({})
({(6,Omar,30,30000,admin)})
 
 
Apache Pig SUM()函数
可以使用Pig Latin的 SUM() 函数获取单列包中列的总数值。在计算总和时， SUM() 函数会忽略NULL值。
注意
·         
要获得全局总和，我们需要执行Group All操作，并使用SUM()函数计算总和值。
·         
·         
要获取组的总和，我们需要使用 Group By 运算符对其进行分组，然后继续SUM()函数。
·         
语法
下面给出了 SUM() 函数的语法。
grunt> SUM(expression)
例
假设在HDFS目录 /pig_data/ 中有一个名为 employee.txt 的文件，如下所示。
employee.txt
1,John,2007-01-24,250  
2,Ram,2007-05-27,220  
3,Jack,2007-05-06,170  
3,Jack,2007-04-06,100 
4,Jill,2007-04-06,220 
5,Zara,2007-06-06,300
5,Zara,2007-02-06,350
通过关系 employee_data 的将此文件加载到Pig中，如下所示。
grunt> employee_data = LOAD 'hdfs://localhost:9000/pig_data/ employee.txt' USING PigStorage(',')
   as (id:int, name:chararray, workdate:chararray, daily_typing_pages:int);
计算所有GPA的总和
让我们尝试计算每天输入的所有员工的总页数来演示 SUM() 函数。可以使用Apache Pig的内置函数 SUM() （区分大小写）来计算数值的总和。让我们使用 Group All 运算符将关系employee_data分组，并将结果存储在名为employee_group的关系中，如下所示。
grunt> employee_group = Group employee_data all;
它将产生如下所示的关系。
grunt> Dump employee_group;
  
(all,{(5,Zara,2007-02-06,350),
(5,Zara,2007-06-06,300),
(4,Jill,2007-0406,220),
(3,Jack,2007-04-06,100),
(3,Jack,2007-05-06,170),
(2,Ram,2007-0527,220),
(1,John,2007-01-24,250)})
现在让我们计算每天输入的页面的总和。
grunt> student_workpages_sum = foreach employee_group Generate 
   (employee_data.name,employee_data.daily_typing_pages),SUM(employee_data.daily_typing_pages);
验证
使用 DUMP 运算符验证关系 student_workpages_sum ，如下所示。
grunt> Dump student_workpages_sum;
输出
它将产生以下输出，显示关系 student_workpages_sum 的内容如下。
(({ (Zara), (Zara), (Jill) ,(Jack) , (Jack) , (Ram) , (John) }, 
{ (350) , (300) , (220) ,(100) , (170)  ,  (220)  , (250)  }),1610)
 
Apache PigTOKENIZE()函数
Pig Latin的 TOKENIZE() 函数用于在单个元组中分割字符串（其中包含一组字），并返回包含拆分操作输出的包。
语法
下面给出了 TOKENIZE() 函数的语法。
grunt> TOKENIZE(expression [, 'field_delimiter']) 
作为 TOKENIZE() 函数的分隔符，我们可以传递空格[]，双引号[“"]，逗号 [,]，括号[()]，星号[*]。
例
假设在HDFS目录 /pig_data/ 中有一个名为 student_details.txt 的文件，如下所示。此文件包含学生的详细信息，如id，姓名，年龄和城市。如果我们仔细观察，学生的姓名包括用空格[]分隔的名字和姓氏。
student_details.txt
001,Rajiv Reddy,21,Hyderabad
002,siddarth Battacharya,22,Kolkata 
003,Rajesh Khanna,22,Delhi 
004,Preethi Agarwal,21,Pune 
005,Trupthi Mohanthy,23,Bhuwaneshwar 
006,Archana Mishra,23 ,Chennai 
007,Komal Nayak,24,trivendram 
008,Bharathi Nambiayar,24,Chennai 
通过关系 student_details 将此文件加载到的Pig中，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int,  city:chararray);
拆分字符串
我们可以使用 TOKENIZE() 函数拆分字符串。作为示例，让我们使用此函数分割名称，如下所示。
grunt> student_name_tokenize = foreach student_details  Generate TOKENIZE(name);
验证
使用 DUMP 运算符验证关系 student_name_tokenize ，如下所示。
grunt> Dump student_name_tokenize;
输出
它将产生以下输出，显示关系 student_name_tokenize 的内容如下。
({(Rajaiv),(Reddy)})
({(siddarth),(Battacharya)})
({(Rajesh),(Khanna)})
({(Preethi),(Agarwal)})
({(Trupthi),(Mohanthy)})
({(Archana),(Mishra)})
({(Komal),(Nayak)})
({(Bharathi),(Nambiayar)})
其他分隔符
以同样的方式，TOKENIZE（）函数接受空格[]，双引号[“"]，逗号[,]，括号[()]，星号[*]作为分隔符。
例
假设有一个名为 details.txt 的文件，其中包含学生的详细信息，如id，name，age和city。在名称列下，此文件包含由各种分隔符分隔的学生的名字和姓氏，如下所示。
details.txt
001,"siddarth""Battacharya",22,Kolkata 
002,Rajesh*Khanna,22,Delhi 
003,(Preethi)(Agarwal),21,Pune 
使用关系 details 将此文件加载到Pig中，如下所示。
grunt> details = LOAD 'hdfs://localhost:9000/pig_data/details.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int,  city:chararray);
现在，尝试使用TOKENIZE()分隔学生的名字和姓氏如下。
grunt> tokenize_data = foreach details Generate TOKENIZE(name);
在使用dump运算符验证 tokenize_data 关系时，将获得以下结果。
grunt> Dump tokenize_data;
 
({(siddarth),(Battacharya)})
({(Rajesh),(Khanna)})
({(Preethi),(Agarwal)})
 
 
Apache Pig PigStorage()函数
PigStorage() 函数将数据加载并存储为结构化文本文件。它采用分隔符，使用它来将元组的每个实体分隔为一个参数。默认情况下，以'\t'作为参数。
语法
下面给出了 PigStorage() 函数的语法。
grunt> PigStorage(field_delimiter)
例
假设在名为 /data/ 的HDFS目录中有一个名为 student_data.txt 的文件，其中包含以下内容。
001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata 
003,Rajesh,Khanna,9848022339,Delhi  
004,Preethi,Agarwal,9848022330,Pune 
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.
我们可以使用PigStorage函数加载数据，如下所示。
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );
在上面的例子中，我们已经看到过使用逗号（','）分隔符。因此，我们使用（,）分隔了记录的值。
同样，我们可以使用 PigStorage() 函数将数据存储到HDFS目录中，如下所示。
grunt> STORE student INTO ' hdfs://localhost:9000/pig_Output/ ' USING PigStorage (',');
这将把数据存储到给定的目录中。可以按如下所示验证数据。
验证
你可以如下所示验证存储的数据。首先，使用 ls 命令列出名为 pig_output 的目录中的文件，如下所示。
$ hdfs dfs -ls 'hdfs://localhost:9000/pig_Output/'
 
Found 2 items 
rw-r--r- 1 Hadoop supergroup 0 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/_SUCCESS
 
rw-r--r- 1 Hadoop supergroup 224 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/part-m-00000
 
可以观察到在执行 Store 语句后创建了两个文件。
然后，使用 cat 命令，列出名为 part-m-00000 的文件的内容，如下所示。
$ hdfs dfs -cat 'hdfs://localhost:9000/pig_Output/part-m-00000'
  
1,Rajiv,Reddy,9848022337,Hyderabad  
2,siddarth,Battacharya,9848022338,Kolkata  
3,Rajesh,Khanna,9848022339,Delhi  
4,Preethi,Agarwal,9848022330,Pune  
5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 
6,Archana,Mishra,9848022335,Chennai
 

 
Apache PigTextLoader()函数
Pig Latin函数 TextLoader() 是一个Load函数，用于以UTF-8格式加载非结构化数据。
语法
下面给出了 TextLoader() 函数的语法。
grunt> TextLoader()
例
假设在名为 /data/ 的HDFS目录中有一个名为 stu_data.txt 的文件，如下所示。
001,Rajiv_Reddy,21,Hyderabad 
002,siddarth_Battacharya,22,Kolkata 
003,Rajesh_Khanna,22,Delhi 
004,Preethi_Agarwal,21,Pune 
005,Trupthi_Mohanthy,23,Bhuwaneshwar 
006,Archana_Mishra,23,Chennai 
007,Komal_Nayak,24,trivendram 
008,Bharathi_Nambiayar,24,Chennai
现在让我们使用 TextLoader() 函数加载上述文件。
grunt> details = LOAD 'hdfs://localhost:9000/pig_data/stu_data.txt' USING TextLoader();
你可以使用Dump运算符验证加载的数据。
grunt> dump details;
   
(001,Rajiv_Reddy,21,Hyderabad) 
(002,siddarth_Battacharya,22,Kolkata) 
(003,Rajesh_Khanna,22,Delhi) 
(004,Preethi_Agarwal,21,Pune) 
(005,Trupthi_Mohanthy,23,Bhuwaneshwar) 
(006,Archana_Mishra,23,Chennai) 
(007,Komal_Nayak,24,trivendram) 
(008,Bharathi_Nambiayar,24,Chennai)
 
Apache PigBinStorage()函数
BinStorage() 函数使用机器可读格式将数据加载并存储到Pig中。Pig中的 BinStorge() 通常用于存储MapReduce作业之间生成的临时数据，它支持多个位置作为输入。
语法
下面给出了 BinStorage() 函数的语法。
grunt> BinStorage();
例
假设在HDFS目录 /pig_data/ 中有一个名为 stu_data.txt 的文件，如下所示。
Stu_data.txt
001,Rajiv_Reddy,21,Hyderabad 
002,siddarth_Battacharya,22,Kolkata 
003,Rajesh_Khanna,22,Delhi 
004,Preethi_Agarwal,21,Pune 
005,Trupthi_Mohanthy,23,Bhuwaneshwar 
006,Archana_Mishra,23,Chennai 
007,Komal_Nayak,24,trivendram 
008,Bharathi_Nambiayar,24,Chennai 
让我们将这些数据加载到一个关系中，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/stu_data.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, age:int, city:chararray);
现在，我们可以使用 BinStorage() 函数将此关系存储到名为 /pig_data/ 的HDFS目录中。
grunt> STORE student_details INTO 'hdfs://localhost:9000/pig_Output/mydata' USING BinStorage();
执行上述语句后，关系存储在给定的HDFS目录中。你可以使用HDFS ls命令查看它，如下所示。
$ hdfs dfs -ls hdfs://localhost:9000/pig_Output/mydata/
  
Found 2 items 
-rw-r--r--   1 Hadoop supergroup       0 2015-10-26 16:58
hdfs://localhost:9000/pig_Output/mydata/_SUCCESS
 
-rw-r--r--   1 Hadoop supergroup        372 2015-10-26 16:58
hdfs://localhost:9000/pig_Output/mydata/part-m-00000
 
现在，从文件 part-m-00000 加载数据。
grunt> result = LOAD 'hdfs://localhost:9000/pig_Output/b/part-m-00000' USING BinStorage();
验证关系的内容如下所示
grunt> Dump result; 
 
(1,Rajiv_Reddy,21,Hyderabad) 
(2,siddarth_Battacharya,22,Kolkata) 
(3,Rajesh_Khanna,22,Delhi) 
(4,Preethi_Agarwal,21,Pune) 
(5,Trupthi_Mohanthy,23,Bhuwaneshwar) 
(6,Archana_Mishra,23,Chennai) 
(7,Komal_Nayak,24,trivendram) 
(8,Bharathi_Nambiayar,24,Chennai)
 
Apache Pig 压缩数据处理
我们可以使用函数 BinStorage() 和 TextLoader() 在Apache Pig中加载和存储压缩数据。
例
假设在HDFS目录 /pigdata/ 中有一个名为 employee.txt.zip 的文件。然后，我们可以将压缩文件加载到pig，如下所示。
Using PigStorage: 
 
grunt> data = LOAD 'hdfs://localhost:9000/pig_data/employee.txt.zip' USING PigStorage(','); 
 
Using TextLoader:
  
grunt> data = LOAD 'hdfs://localhost:9000/pig_data/employee.txt.zip' USING TextLoader;
同样，我们可以将压缩文件存储在pig中，如下所示。
Using PigStorage:
  
grunt> store data INTO 'hdfs://localhost:9000/pig_Output/data.bz' USING PigStorage(',');
 
 
Apache Pig TOBAG()函数
Pig Latin的 TOBAG() 函数将一个或多个表达式转换为单个元组，这些元组被放在一个包里。
语法
下面给出了 TOBAG() 函数的语法。
TOBAG(expression [, expression ...])
例
假设在HDFS目录 /pig_data/ 中有一个名为 employee_details.txt 的文件，其中包含以下内容。
employee_details.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo 
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
通过使用关系 emp_data 将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/employee_details.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
现在让我们将每个员工（记录）的id，姓名，年龄和城市转换为一个元组，如下所示。
tobag = FOREACH emp_data GENERATE TOBAG (id,name,age,city);
验证
可以使用 Dump 运算符验证 tobag 关系的内容，如下所示。
grunt> DUMP tobag;
  
({(1),(Robin),(22),(newyork)}) 
({(2),(BOB),(23),(Kolkata)}) 
({(3),(Maya),(23),(Tokyo)}) 
({(4),(Sara),(25),(London)}) 
({(5),(David),(23),(Bhuwaneshwar)}) 
({(6),(Maggy),(22),(Chennai)})
 
Apache Pig TOP()函数
Pig Latin的 TOP() 函数用于获取包的顶部 N 个元组。对于这个函数，作为输入，我们必须传递一个关系，我们想要的元组的数量，以及其值被比较的列名。此函数将返回包含所需列的包。
语法
下面给出了函数 TOP() 的语法。
grunt> TOP(topN,column,relation)
例
假设在HDFS目录 /pig_data/ 中有一个名为 employee_details.txt 的文件，其中包含以下内容。
employee_details.txt
001,Robin,22,newyork 
002,BOB,23,Kolkata 
003,Maya,23,Tokyo 
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai 
007,Robert,22,newyork 
008,Syam,23,Kolkata 
009,Mary,25,Tokyo 
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai
通过使用关系 emp_data 将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/ employee_details.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
按年龄对关系 emp_data 进行分组，并将其存储在关系 emp_group 中。
grunt> emp_group = Group emp_data BY age;
使用 Dump 运算符验证关系 emp_group ，如下所示。
grunt> Dump emp_group;
  
(22,{(12,Kelly,22,Chennai),(7,Robert,22,newyork),(6,Maggy,22,Chennai),(1,Robin, 22,newyork)}) 
(23,{(8,Syam,23,Kolkata),(5,David,23,Bhuwaneshwar),(3,Maya,23,Tokyo),(2,BOB,23, Kolkata)}) 
(25,{(11,Stacy,25,Bhuwaneshwar),(10,Saran,25,London),(9,Mary,25,Tokyo),(4,Sara, 25,London)})
现在，你可以按升序（基于id ）排列每个组的前两个记录，如下所示。
grunt> data_top = FOREACH emp_group { 
   top = TOP(2, 0, emp_data); 
   GENERATE top; 
}
在这个例子中，我们正在检索具有较大id的组的前2个元组。由于我们基于 id 检索前2个元组，我们将列名id的索引作为TOP()函数的第二个参数传递。
验证
使用 Dump 运算符验证 data_top 关系的内容，如下所示。
grunt> Dump data_top;
  
({(7,Robert,22,newyork),(12,Kelly,22,Chennai)}) 
({(5,David,23,Bhuwaneshwar),(8,Syam,23,Kolkata)}) 
({(10,Saran,25,London),(11,Stacy,25,Bhuwaneshwar)})
 

 
Apache Pig TOTUPLE()函数
TOTUPLE() 函数用于将一个或多个表达式转换为数据类型 tuple 。
语法
下面给出了 TOTUPLE() 函数的语法。
grunt> TOTUPLE(expression [, expression ...])
例
假设在HDFS目录 /pig_data/ 中有一个名为 employee_details.txt 的文件，其中包含以下内容。
employee_details.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo 
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
通过使用关系名称 emp_data 将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/employee_details.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
现在让我们将每个学生的id，名字和年龄（记录）转换成一个元组。
grunt> totuple = FOREACH emp_data GENERATE TOTUPLE (id,name,age);
验证
你可以使用 Dump 运算符验证 totuple 模式的内容，如下所示。
grunt> DUMP totuple;
  
((1,Robin,22)) 
((2,BOB,23)) 
((3,Maya,23)) 
((4,Sara,25)) 
((5,David,23)) 
((6,Maggy,22)) 
 
Apache Pig TOMAP()函数
Pig Latin的 TOMAP() 函数用于将key-value对转换为Map。
语法
下面给出了 TOMAP() 函数的语法。
grunt> TOMAP(key-expression, value-expression [, key-expression, valueexpression ...])
例
假设在HDFS目录 /pig_data/ 中有一个名为 employee_details.txt 的文件，其中包含以下内容。
employee_details.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
通过使用关系 emp_data 将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/employee_details.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
现在让我们将每个记录的名称和年龄作为key-value对，并将它们转换为map，如下所示。
grunt> tomap = FOREACH emp_data GENERATE TOMAP(name, age);
验证
您可以使用 Dump 运算符验证 tomap 关系的内容，如下所示。
grunt> DUMP tomap;
  
([Robin#22])
([BOB#23])
([Maya#23])
([Sara#25]) 
([David#23])
([Maggy#22])
 
Apache PigENDSWITH()函数
此函数接受两个String参数，它用于验证第一个字符串是否以第二个字符串结尾。
语法
grunt> ENDSWITH(string1, string2)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，例如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork 
008,Syam,23,Kolkata
009,Mary,25,Tokyo
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
以下是 ENDSWITH() 函数的示例，在本示例中，我们在验证每个员工的姓名是否以字符 n 结束。
grunt> emp_endswith = FOREACH emp_data GENERATE (id,name),ENDSWITH ( name, 'n' );
上述语句验证员工姓名是否以字母n结束。由于 Saran 和 Robin 的这两个元组的以字母n结束，所以 ENDSWITH() 函数返回布尔值'true'，对于剩余的元组的值为'false'。
语句的结果将存储在名为 emp_endswith 的关系中。使用Dump运算符验证关系 emp_endswith 的内容，如下所示。
grunt> Dump emp_endswith;
 
((1,Robin),true)
((2,BOB),false)
((3,Maya),false)
((4,Sara),false)
((5,David),false)
((6,Maggy),false)
((7,Robert),false)
((8,Syam),false)
((9,Mary),false)((10,Saran),true)
((11,Stacy),false)
((12,Kelly),false)
 
Apache PigSTARTSWITH()函数
此函数接受两个字符串参数。它验证第一个字符串是否以第二个开头。
语法
下面给出了 STARTSWITH() 函数的语法。
grunt> STARTSWITH(string, substring)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork 
008,Syam,23,Kolkata
009,Mary,25,Tokyo 
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai 
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt > emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
例
以下是 STARTSWITH() 函数的示例。在此示例中，我们验证所有员工的姓名是否以子字符串“Ro"开头。
grunt> startswith_data = FOREACH emp_data GENERATE (id,name), STARTSWITH (name,’Ro’);
如果任何这些名称以字符串'Ro'开头，上述语句将解析所有员工的名称。因为员工姓名'Robin'和'Robert'这两个元组以子串'Ro'开头，所以 STARTSWITH() 函数返回布尔值'true'，剩余的元组的值将为'false'。
语句的结果将存储在名为 startswith_data 的关系中。使用Dump运算符验证关系 startswith_data 的内容，如下所示。
grunt> Dump startswith_data;
  
((1,Robin),true)
((2,BOB),false)
((3,Maya),false) 
((4,Sara),false)
((5,David),false) 
((6,maggy),false)((7,Robert),true) 
((8,Syam),false)
((9,Mary),false) 
((10,Saran),false)
((11,Stacy),false) 
((12,Kelly),false)
 
Apache PigSUBSTRING()函数
此函数从给定字符串返回一个子字符串。
语法
下面给出了 SUBSTRING() 函数的语法。这个函数接受三个参数，一个是我们想要的字符串的列名，另外两个是所需子串的开始和停止索引。
grunt> SUBSTRING(string, startIndex, stopIndex) 
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，例如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,Stacy,25,Bhuwaneshwar 
003,Kelly,22,Chennai
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')as (id:int, name:chararray, age:int, city:chararray);
以下是 SUBSTRING() 函数的示例。此示例获取以0^th字母开头并以2^nd 字母结尾的员工姓名。
grunt> substring_data = FOREACH emp_data GENERATE (id,name), SUBSTRING (name, 0, 2);
上述语句从员工的姓名中提取所需的子字符串。语句的结果将存储在名为 substring_data 的关系中。
使用Dump运算符验证关系 substring_data 的内容，如下所示。
grunt> Dump substring_data;
 
((1,Robin),Rob)
((2,Stacy),Sta)
((3,Kelly),Kel) 
 
Apache PigEqualsIgnoreCase()函数
EqualsIgnoreCase() 函数用于比较两个字符串并验证它们是否相等。如果两者相等，则此函数返回布尔值 true ，否则返回值 false 。
语法
下面给出了函数 EqualsIgnoreCase() 的语法
grunt> EqualsIgnoreCase(string1, string2)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，例如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork
008,Syam,23,Kolkata
009,Mary,25,Tokyo
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
下面给出了 EqualsIgnoreCase() 函数的示例。在本示例中，我们将每个员工的姓名与字符串值'Robin'进行比较。
grunt> equals_data = FOREACH emp_data GENERATE (id,name), EqualsIgnoreCase(name, 'Robin');
上面的语句将字符串“Robin"（不区分大小写）与员工的姓名进行比较，如果值匹配则返回 true 否则返回 false 。 简而言之，此语句搜索名为'Robin'的员工记录。
语句的结果将存储在名为 equals_data 的关系中。使用Dump运算符验证关系 equals_data 的内容，如下所示。
grunt>  Dump equals_data;
  
((1,Robin),true)
((2,BOB),false)
((3,Maya),false)
((4,Sara),false)
((5,David),false)
((6,Maggy),false)
((7,Robert),false)
((8,Syam),false)
((9,Mary),false)
((10,Saran),false)
((11,Stacy),false)
((12,Kelly),false) 
 
Apache Pig INDEXOF()函数
INDEXOF() 函数接受字符串值，字符和索引（整数）。它返回字符串中第一个出现的给定的字符，从开始索引向前搜索。
语法
下面给出了 INDEXOF() 函数的语法。
grunt> INDEXOF(string, 'character', startIndex)
例
假设在HDFS目录/pig_data/中有一个名为emp.txt的文件，如下所示。此文件包含员工详细信息，如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo 
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork 
008,Syam,23,Kolkata
009,Mary,25,Tokyo 
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
下面给出了 INDEXOF() 函数的示例。在此示例中，我们使用此函数查找每个员工姓名中出现的字母'r'。
grunt> indexof_data = FOREACH emp_data GENERATE (id,name), INDEXOF(name, 'r',0);
上述语句解析每个员工的姓名，并返回第一个字母为'r'的索引值。如果名称不包含字母'r'，则返回值-1。
语句的结果将存储在名为indexof_data的关系中。 使用Dump运算符验证关系indexof_data的内容，如下所示。
grunt> Dump indexof_data;
  
((1,Robin),-1)
((2,BOB),-1)
((3,Maya),-1)
((4,Sara),2)
((5,David),-1)
((6,Maggy),-1)
((7,Robert),4)
((8,Syam),-1)
((9,Mary),2)
((10,Saran),2)
((11,Stacy),-1)
((12,Kelly),-1) 
 
Apache PigLAST_INDEX_OF()函数
LAST_INDEX_OF() 函数接受字符串值和字符。它返回字符串中给定字符最后一次出现的值，从字符串的结尾向后搜索。
语法
下面给出了 LAST_INDEX_OF() 函数的语法
grunt> LAST_INDEX_OF(string, 'character')
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo 
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork 
008,Syam,23,Kolkata
009,Mary,25,Tokyo 
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
下面给出了 LAST_INDEX_OF() 函数的示例。在这个例子中，我们将从每个员工的名字中找到字母'g'的出现。
grunt> last_index_data = FOREACH emp_data GENERATE (id,name), LAST_INDEX_OF(name, 'g');
上述语句从结尾解析每个员工的姓名，并返回第一次发现字母'g'的索引值。如果名称不包含字母'g'，则返回值 -1 。
语句的结果将存储在名为 last_index_data 的关系中。使用Dump运算符验证关系 last_index_data 的内容，如下所示。
grunt> Dump last_index_data;
  
((1,Robin),-1)
((2,BOB),-1)
((3,Maya),-1)
((4,Sara),-1) 
((5,David),-1)((6,Maggy),3)
((7,Robert),-1)
((8,Syam),-1)
((9,Mary),-1) 
((10,Saran),-1)
((11,Stacy),-1)
((12,Kelly),-1)
 
Apache Pig LCFIRST()函数
此函数用于将给定字符串的第一个字符转换为小写。
语法
以下是 LCFIRST() 函数的语法。
grunt> LCFIRST(expression) 
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork
008,Syam,23,Kolkata
009,Mary,25,Tokyo
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
下面给出了 LCFIRST() 函数的示例。在此示例中，我们将所有员工姓名的第一个字母转换为小写。
grunt> Lcfirst_data = FOREACH emp_data GENERATE (id,name), LCFIRST(name);
语句的结果将存储在名为 Lcfirst_data 的关系中。使用Dump运算符验证关系 Lcfirst_data 的内容，如下所示。
grunt> Dump Lcfirst_data;
  
((1,Robin),robin)
((2,BOB),bob)
((3,Maya),maya)
((4,Sara),sara)
((5,David),david)
((6,Maggy),maggy)
((7,Robert),robert)
((8,Syam),syam)
((9,Mary),mary)
((10,Saran),saran)
((11,Stacy),stacy)
((12,Kelly),kelly)
 
Apache Pig UPPER()函数
此函数用于将字符串中的所有字符转换为大写。
语法
UPPER() 函数的语法如下
grunt> UPPER(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件。此文件包含员工详细信息，如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork
008,Syam,23,Kolkata
009,Mary,25,Tokyo
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai 
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
下面给出了 UPPER() 函数的示例。在此示例中，我们已将所有员工的姓名转换为大写。
grunt> upper_data = FOREACH emp_data GENERATE (id,name), UPPER(name);
上述语句将所有员工的名称转换为大写并返回结果。语句的结果将存储在名为 upper_data 的关系中。使用Dump运算符验证关系 upper_data 的内容，如下所示。
grunt> Dump upper_data;
  
((1,Robin),ROBIN)
((2,BOB),BOB)
((3,Maya),MAYA)
((4,Sara),SARA)
((5,David),DAVID)
((6,Maggy),MAGGY)
((7,Robert),ROBERT)
((8,Syam),SYAM)
((9,Mary),MARY)
((10,Saran),SARAN)
((11,Stacy),STACY)
((12,Kelly),KELLY) 
 
Apache Pig LOWER()函数
此函数用于将字符串中的所有字符转换为小写。
语法
以下是 LOWER() 函数的语法。
grunt> LOWER(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork
008,Syam,23,Kolkata
009,Mary,25,Tokyo
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
下面给出了 LOWER() 函数的示例。在此示例中，我们将所有员工的姓名转换为小写。
grunt> lower_data = FOREACH emp_data GENERATE (id,name), LOWER(name);
上述语句将所有员工的姓名转换为小写并返回结果。
语句的结果将存储在名为 lower_data 的关系中。使用Dump运算符验证关系 lower_data 的内容。
grunt> Dump lower_data; 
 
((1,Robin),robin)
((2,BOB),bob)
((3,Maya),maya)
((4,Sara),sara)
((5,David),david) 
((6,Maggy),maggy)
((7,Robert),robert)
((8,Syam),syam)
((9,Mary),mary)
((10,Saran),saran)
((11,Stacy),stacy)
((12,Kelly),kelly)
 
Apache Pig REPLACE()函数
此函数用于将给定字符串中的所有字符替换为新字符。
语法
下面给出了 REPLACE() 函数的语法。该函数接受三个参数，即：
·         
string - 要替换的字符串。如果我们想替换关系中的字符串，我们必须传递字符串所属的列名。
·         
·         
regEXP - 这里我们必须传递要替换的字符串/正则表达式。
·         
·         
newChar - 这里我们必须传递字符串的新值。
·         
grunt> REPLACE(string, 'regExp', 'newChar');
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，如id，姓名，年龄和城市。
emp.txt
001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork 
008,Syam,23,Kolkata
009,Mary,25,Tokyo 
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp1.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
以下是 REPLACE() 函数的示例。在此示例中，我们使用缩写形式 Bhuw 替换了城市 Bhuwaneshwar 的名称。
grunt> replace_data = FOREACH emp_data GENERATE (id,city),REPLACE(city,'Bhuwaneshwar','Bhuw');
上述语句在 emp_data 关系中使用'Bhuw'字符串替换 city 中的'Bhuwaneshwar' 并返回结果。此结果存储在名为 replace_data 的关系中。使用Dump运算符验证关系 replace_data 的内容，如下所示。
grunt> Dump replace_data;
 
((1,newyork),newyork)
((2,Kolkata),Kolkata)
((3,Tokyo),Tokyo)
((4,London),London) ((5,Bhuwaneshwar),Bhuw)
((6,Chennai),Chennai)
((7,newyork),newyork) 
((8,Kolkata),Kolkata)
((9,Tokyo),Tokyo) 
((10,London),London) ((11,Bhuwaneshwar),Bhuw) 
((12,Chennai),Chennai) 
 
Apache Pig STRSPLIT()函数
此函数用于通过给定的分隔符拆分给定的字符串。
语法
STRSPLIT() 的语法如下。此函数接受需要拆分的字符串，正则表达式和指定限制的整数值（字符串应该拆分的子字符串数）。当遇到给定的正则表达式时，此函数解析字符串，它会将字符串拆分为 n 个子字符串，其中 n 将传递给 limit 。
grunt> STRSPLIT(string, regex, limit)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，如id，姓名，年龄和城市。
emp.txt
001,Robin_Smith,22,newyork 
002,BOB_Wilson,23,Kolkata 
003,Maya_Reddy,23,Tokyo 
004,Sara_Jain,25,London 
005,David_Miller,23,Bhuwaneshwar 
006,Maggy_Moore,22,Chennai 
007,Robert_Scott,22,newyork 
008,Syam_Ketavarapu,23,Kolkata 
009,Mary_Carter,25,Tokyo 
010,Saran_Naidu,25,London 
011,Stacy_Green,25,Bhuwaneshwar 
012,Kelly_Moore,22,Chennai 
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
以下是 STRSPLIT() 函数的示例。如果你观察emp.txt文件，可以发现在 name 列中，我们有由分隔符'_'分隔的员工的姓名和姓氏。
在此示例中，我们尝试使用 STRSPLIT() 函数拆分员工的姓名和姓氏。
grunt> strsplit_data = FOREACH emp_data GENERATE (id,name), STRSPLIT (name,'_',2);
语句的结果将存储在名为strsplit_data的关系中。使用Dump运算符验证关系 strsplit_data 的内容，如下所示。
grunt> Dump strsplit_data;
  
((1,Robin_Smith),(Robin,Smith))
((2,BOB_Wilson),(BOB,Wilson))
((3,Maya_Reddy),(Maya,Reddy))
((4,Sara_Jain),(Sara,Jain))
((5,David_Miller),(David,Miller))
((6,Maggy_Moore),(Maggy,Moore))
((7,Robert_Scott),(Robert,Scott))
((8,Syam_Ketavarapu),(Syam,Ketavarapu))
((9,Mary_Carter),(Mary,Carter))
((10,Saran_Naidu),(Saran,Naidu))
((11,Stacy_Green),(Stacy,Green))
((12,Kelly_Moore),(Kelly,Moore))
 
Apache PigSTRSPLITTOBAG()函数
此函数类似于 STRSPLIT() 函数。它使用给定的分隔符分隔字符串，并将结果返回到包中。
语法
STRSPLITTOBAG() 的语法如下。此函数接受需要拆分的字符串，正则表达式和指定限制的整数值（字符串应该拆分的子字符串数）。当遇到给定的正则表达式时，此函数解析字符串，它将该字符串拆分为 n 个子字符串，其中 n 将传递给limit。
grunt> STRSPLITTOBAG(string, regex, limit)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 emp.txt 的文件，如下所示。此文件包含员工详细信息，如id，姓名，年龄和城市。
emp.txt
001,Robin_Smith,22,newyork 
002,BOB_Wilson,23,Kolkata 
003,Maya_Reddy,23,Tokyo 
004,Sara_Jain,25,London 
005,David_Miller,23,Bhuwaneshwar 
006,Maggy_Moore,22,Chennai 
007,Robert_Scott,22,newyork 
008,Syam_Ketavarapu,23,Kolkata 
009,Mary_Carter,25,Tokyo 
010,Saran_Naidu,25,London 
011,Stacy_Green,25,Bhuwaneshwar 
012,Kelly_Moore,22,Chennai
通过使用 emp_data 关系将此文件加载到Pig中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);
以下是 STRSPLITTOBAG() 函数的示例。如果你观察emp.txt文件，可以发现在 name 列中，我们有由分隔符"_"分隔的员工的姓名和姓氏。
在此示例中，我们尝试拆分员工的姓名和姓氏，并使用 STRSPLITTOBAG() 函数在包中获取结果。
grunt> strsplittobag_data = FOREACH emp_data GENERATE (id,name), STRSPLITTOBAG (name,'_',2);
语句的结果将存储在名为 strsplittobag_data 的关系中。使用Dump运算符验证关系 strsplittobag_data 的内容，如下所示。
grunt> Dump strsplittobag_data;
  
((1,Robin_Smith),{(Robin),(Smith)}) 
((2,BOB_Wilson),{(BOB),(Wilson)}) 
((3,Maya_Reddy),{(Maya),(Reddy)}) 
((4,Sara_Jain),{(Sara),(Jain)}) 
((5,David_Miller),{(David),(Miller)}) 
((6,Maggy_Moore),{(Maggy),(Moore)}) 
((7,Robert_Scott),{(Robert),(Scott)}) 
((8,Syam_Ketavarapu),{(Syam),(Ketavarapu)}) 
((9,Mary_Carter),{(Mary),(Carter)})
((10,Saran_Naidu),{(Saran),(Naidu)}) 
((11,Stacy_Green),{(Stacy),(Green)}) 
((12,Kelly_Moore),{(Kelly),(Moore)}) 
 
Apache Pig TRIM()函数
TRIM() 函数接受字符串，并在删除它前端和尾部的空格后返回其副本。
语法
这是 TRIM() 函数的语法。
grunt> TRIM(expression)
例
假设我们在 emp_data 关系的记录中的员工姓名的前端和尾部有一些不必要的空格。
grunt> Dump emp_data; 
 
(1, Robin ,22,newyork)
(2,BOB,23,Kolkata) 
(3, Maya ,23,Tokyo)
(4,Sara,25,London)
(5, David ,23,Bhuwaneshwar) 
(6,maggy,22,Chennai)
(7,Robert,22,newyork) 
(8, Syam ,23,Kolkata)
(9,Mary,25,Tokyo) 
(10, Saran ,25,London)
(11, Stacy,25,Bhuwaneshwar)
(12, Kelly ,22,Chennai)
使用 TRIM() 函数，我们可以从姓名中删除在其前端和尾部空格，如下所示。
grunt> trim_data = FOREACH emp_data GENERATE (id,name), TRIM(name);
上述语句通过从员工姓名中删除前端和尾部空格来返回姓名的副本。结果存储在名为 trim_data 的关系中。使用Dump运算符验证关系 trim_data 的结果，如下所示。
grunt> Dump trim_data;
  
((1, Robin ),Robin)
((2,BOB),BOB)((3, Maya ),Maya)
((4,Sara),Sara)((5, David ),David)
((6,maggy),maggy) 
((7,Robert),Robert)((8, Syam ),Syam) 
((9,Mary),Mary)((10, Saran ),Saran)
((11, Stacy),Stacy)
((12, Kelly ),Kelly)
 
Apache Pig LTRIM()函数
函数 LTRIM() 与函数 TRIM() 相同。它从给定字符串（标题空格）的左侧删除不需要的空格。
语法
这里是LTRIM()函数的语法。
grunt> LTRIM(expression)
例
假设在 emp_data 关系的记录中的员工姓名之前和之后有一些不必要的空格。
grunt> Dump emp_data;
  
(1, Robin ,22,newyork)
(2, BOB,23,Kolkata)
(3, Maya ,23,Tokyo)
(4, Sara,25,London)
(5, David ,23,Bhuwaneshwar)
(6, maggy,22,Chennai)
(7, Robert,22,newyork)
(8, Syam ,23,Kolkata)
(9, Mary,25,Tokyo)
(10, Saran ,25,London)
(11, Stacy,25,Bhuwaneshwar)
(12, Kelly ,22,Chennai)
使用 LTRIM() 函数，我们可以从姓名中删除前端空格，如下所示。
grunt> ltrim_data = FOREACH emp_data GENERATE (id,name), LTRIM(name);
上述语句通过从员工的姓名中删除前端空格来返回姓名的副本。结果存储在名为 ltrim_data 的关联中。使用Dump运算符验证关系 ltrim_data 的结果，如下所示。
grunt> Dump ltrim_data;
  
((1, Robin ),Robin ) 
((2,BOB),BOB) ((3, Maya ),Maya ) 
((4,Sara),Sara) ((5, David ),David ) 
((6,maggy),maggy) 
((7,Robert),Robert) ((8, Syam ),Syam ) 
((9,Mary),Mary) ((10, Saran),Saran) 
((11, Stacy),Stacy) 
((12, Kelly ),Kelly )
 
Apache Pig RTRIM()函数
函数 RTRIM() 与函数 TRIM() 相同。它从给定字符串（尾部空格）的右侧删除不需要的空格。
语法
RTRIM() 函数的语法如下
grunt> RTRIM(expression)
例
假设在 emp_data 关系的记录中的员工姓名的之前和之后有一些不必要的空格，如下所示。
grunt> Dump emp_data;
  
(1, Robin ,22,newyork)
(2, BOB,23,Kolkata)
(3, Maya ,23,Tokyo)
(4, Sara,25,London)
(5, David ,23,Bhuwaneshwar)
(6, maggy,22,Chennai)
(7, Robert,22,newyork)
(8, Syam ,23,Kolkata)
(9, Mary,25,Tokyo)
(10, Saran ,25,London)
(11, Stacy,25,Bhuwaneshwar)
(12, Kelly ,22,Chennai)
使用 RTRIM() 函数，我们可以从姓名中删除尾部空格，如下所示
grunt> rtrim_data = FOREACH emp_data GENERATE (id,name), RTRIM(name);
上述语句通过从员工姓名中删除尾部空格来返回姓名副本。结果存储在名为 rtrim_data 的关系中。使用Dump运算符验证关系 rtrim_data 的结果，如下所示。
grunt> Dump rtrim_data;
  
((1, Robin ), Robin)
((2,BOB),BOB)((3, Maya ), Maya)
((4,Sara),Sara)((5, David ), David)
((6,maggy),maggy)
((7,Robert),Robert)((8, Syam ), Syam)
((9,Mary),Mary)((10, Saran ), Saran)
((11, Stacy), Stacy)
((12, Kelly ), Kelly)
 

 
Apache Pig ToDate()函数
此函数用于根据给定的参数生成 DateTime 对象。
语法
ToDate() 函数的语法可以是以下任何一种:
grunt> ToDate(milliseconds)
  
grunt> ToDate(iosstring) 
  
grunt> ToDate(userstring, format)
  
grunt> ToDate(userstring, format, timezone)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44 
通过使用 date_data 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
以下是 ToDate() 函数的示例。这里我们转换对应于每个员工的出生日期的DateTime对象。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime >);
语句的结果（每个员工的 DateTime 对象）将存储在名为 todate_data 的关系中。使用Dump运算符验证此关系的内容，如下所示。
grunt> Dump todate_data;
  
(1989-09-26T09:00:00.000+05:30)
(1980-06-20T10:22:00.000+05:30)
(1990-12-19T03:11:44.000+05:30)
 
Apache PigCurrentTime()函数
此函数用于生成当前时间的 DateTime 对象。
语法
这是 CurrentTime() 函数的语法。
grunt> CurrentTime() 
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44 
通过使用 date 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
以下是 CurrentTime() 函数的示例。这里我们生成当前时间。
grunt> currenttime_data = foreach todate_data generate CurrentTime();
语句的结果将存储在名为 currenttime_data 的关系中。使用Dump操作符验证此关系的内容。
grunt> Dump currenttime_data;
  
(2015-11-06T11:31:02.013+05:30)
(2015-11-06T11:31:02.013+05:30) 
(2015-11-06T11:31:02.013+05:30) 
 
Apache Pig GetDay()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前日期。
语法
这是 GetDay() 函数的语法。
grunt> GetDay(datetime)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44
通过使用 date_data 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
以下是 GetDay() 函数的示例。GetDay()函数将从给定的Date-Time对象中检索日期。因此，首先，让我们使用 todate() 函数生成所有员工的日期时间对象，如下所示。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime );
  grunt> Dump todate_data;
(1989-09-26T09:00:00.000+05:30)
(1980-06-20T10:22:00.000+05:30)
(1990-12-19T03:11:44.000+05:30)
现在，让我们开始使用 GetDay() 函数从出生日期中获取日期，并将它存储在名为 getday_data 的关系中。
grunt> getday_data = foreach todate_data generate(date_time), GetDay(date_time);
使用Dump运算符验证getday_data关系的内容。
grunt> Dump getday_data;
   
(1989-09-26T09:00:00.000+05:30,26) 
(1980-06-20T10:22:00.000+05:30,20) 
(1990-12-19T03:11:44.000+05:30,19)
 
Apache Pig GetHour()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前日期的当前小时。
语法
这是 GetHour() 函数的语法。
grunt> GetHour(datetime)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44
通过使用 date_data 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
下面是 GetHour() 函数的示例。 GetHour() 函数将从给定的Date-Time对象中检索一天中的小时。因此，首先，让我们使用 todate() 函数生成所有员工的Date-Time对象。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime );
  grunt> Dump todate_data;  
(1989-09-26T09:00:00.000+05:30)
(1980-06-20T10:22:00.000+05:30) 
(1990-12-19T03:11:44.000+05:30)
现在让我们使用 GetDay() 函数从每个员工的出生时间开始计算小时，并将其存储在名为 gethour_data 的关系中。
grunt> gethour_data = foreach todate_data generate (date_time), GetHour(date_time);
现在使用Dump运算符验证 getday_data 关系的内容，如下所示。
grunt> Dump gethour_data;  
 
(1989-09-26T09:00:00.000+05:30,9) 
(1980-06-20T10:22:00.000+05:30,10) 
(1990-12-19T03:11:44.000+05:30,3)
 
Apache PigGetMilliSecond()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前秒的毫秒数。
语法
这是 GetMilliSecond（）函数的语法。
grunt> GetMilliSecond(datetime)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44 
通过使用 date_data 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
下面是 GetMilliSecond() 函数的示例。GetMilliSecond()函数将从给定的日期时间对象中检索当前秒的毫秒数。因此，首先，我们使用 todate() 函数生成所有员工的日期时间对象，如下所示。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime );
  grunt> Dump todate_data;
(1989-09-26T09:00:00.000+05:30) 
(1980-06-20T10:22:00.000+05:30) 
(1990-12-19T03:11:44.000+05:30)
现在，让我们使用 GetMilliSecond() 函数从每个员工的出生时间开始计算毫秒数，并将其存储在名为 getmillisecond_data 的关系中，如下所示。
grunt> getmillisecond_data = foreach todate_data generate (date_time), GetMilliSecond(date_time);
现在使用Dump运算符验证 getmillisecond_data 关系的内容，如下所示。
grunt> Dump getmillisecond_data;
  
(1989-09-26T09:00:00.000+05:30,0)
(1980-06-20T10:22:00.000+05:30,0)
(1990-12-19T03:11:44.000+05:30,0) 
 
Apache PigGetMinute()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前小时的分钟。
语法
这是 GetMinute() 函数的语法。
grunt> GetMinute(datetime)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44 
通过使用 date_data 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
以下是 GetMinute() 函数的示例。 GetMinute() 函数将从给定的日期时间对象中检索小时的分钟。因此，首先，让我们使用 todate() 函数生成所有员工的日期时间对象。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime );
grunt> Dump todate_data;
(1989-09-26T09:00:00.000+05:30) 
(1980-06-20T10:22:00.000+05:30) 
(1990-12-19T03:11:44.000+05:30)
现在，让我们使用 GetMinute() 获得每个员工出生时间的分钟，并将其存储在名为 getminute_data 的关系中，如下所示。
grunt> getminute_data = foreach todate_data generate (date_time), GetMinute(date_time);
现在使用Dump运算符验证getminute_data关系的内容，如下所示。
grunt> Dump getminute_data;
  
(1989-09-26T09:00:00.000+05:30,0) 
(1980-06-20T10:22:00.000+05:30,22) 
(1990-12-19T03:11:44.000+05:30,11) 
 
 
Apache PigGetMonth()函数
此函数接受日期时间对象作为参数，并从给定的日期时间对象返回当前年份的当前月份。
语法
这是 GetMonth() 函数的语法。
grunt> GetMonth(datetime)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44 
通过使用 date_data 关系将此文件加载到Pig中。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
下面是 GetMonth() 函数的示例。它将从给定的日期时间对象中检索当前月份。因此，首先，我们使用 todate() 函数生成所有员工的日期时间对象，如下所示。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime );
  grunt> Dump todate_data;
(1989-09-26T09:00:00.000+05:30) 
(1980-06-20T10:22:00.000+05:30) 
(1990-12-19T03:11:44.000+05:30) 
现在让我们使用 GetMonth() 函数从每个员工的出生日期开始计算月份，并将其存储在名为 getmonth_data 的关系中。
grunt> getmonth_data = foreach todate_data generate (date_time), GetMonth(date_time);
现在使用Dump运算符验证 getmonth_data 关系的内容，如下所示。
grunt> Dump getmonth_data;
  
(1989-09-26T09:00:00.000+05:30,9) 
(1980-06-20T10:22:00.000+05:30,6) 
(1990-12-19T03:11:44.000+05:30,12)
 
Apache PigGetSecond()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前分钟的秒数。
语法
这是 GetSecond() 函数的语法。
grunt> GetSecond(datetime)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44
通过使用 date_data 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
下面是 GetSecond() 函数的示例。它从给定的日期时间对象中检索一分钟的秒数。因此，让我们使用 todate() 函数生成所有员工的日期时间对象，如下所示。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime );
  grunt> Dump todate_data;
(1989-09-26T09:00:00.000+05:30) 
(1980-06-20T10:22:00.000+05:30) 
(1990-12-19T03:11:44.000+05:30) 
现在让我们使用 GetSecond() 函数从每个员工的出生时间开始计算秒数，并将其存储在名为 getsecond_data 的关系中，如下所示。
grunt> getsecond_data = foreach todate_data generate (date_time), GetSecond(date_time);
使用Dump运算符验证 getsecond_data 关系的内容，如下所示。
grunt> Dump getsecond_data;
  
(1989-09-26T09:00:00.000+05:30,0)
(1980-06-20T10:22:00.000+05:30,0)
(1990-12-19T03:11:44.000+05:30,44)
 

 
Apache Pig GetWeek()函数
此函数接受日期时间对象作为参数，并从给定的日期时间对象返回当前月份的当前周。
语法
这是 GetWeek() 函数的语法。
grunt> GetWeek(datetime)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44
通过使用 date_data 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
下面是 GetWeek() 函数的示例。它将从给定的日期时间对象中检索当前周。因此，让我们使用 todate() 函数生成所有员工的日期时间对象，如下所示。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime );
  grunt> Dump todate_data;
(1989-09-26T09:00:00.000+05:30)
(1980-06-20T10:22:00.000+05:30)
(1990-12-19T03:11:44.000+05:30) 
现在，让我们使用 GetWeek() 从每个员工的出生日期开始计算月份，并将其存储在名为 getweek_data 的关系中。
grunt> getweek_data = foreach todate_data generate (date_time), GetWeek(date_time);
使用Dump运算符验证 getweek_data 关系的内容。
grunt> Dump getWeek_data;
  
(1989-09-26T09:00:00.000+05:30,39) 
(1980-06-20T10:22:00.000+05:30,25) 
(1990-12-19T03:11:44.000+05:30,51)
 
Apache PigGetWeekYear()函数
此函数接受日期时间对象作为参数，并从给定的日期时间对象返回当前的周年。
语法
这是 GetWeekYear() 函数的语法。
grunt> GetWeekYear(datetime)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44 
通过使用 date_data 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
以下是 GetWeekYear() 函数的示例。它将从给定的日期时间对象中检索当前的周年。因此，让我们使用 todate() 函数生成所有员工的日期时间对象，如下所示。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime );
  grunt> Dump todate_data;
(1989-09-26T09:00:00.000+05:30)
(1980-06-20T10:22:00.000+05:30)
(1990-12-19T03:11:44.000+05:30) 
使用 GetWeekYear() 函数从每个员工的出生日期开始计算周年，并将其存储在名为 getweekyear_data 的关系中，如下所示。
grunt> getweekyear_data = foreach todate_data generate (date_time), GetWeekYear(date_time);
使用Dump运算符验证 getweekyear_data 关系的内容。
grunt> Dump getweekyear_data;
  
(1989-09-26T09:00:00.000+05:30,1989) 
(1980-06-20T10:22:00.000+05:30,1980) 
(1990-12-19T03:11:44.000+05:30,1990) 
 
Apache Pig GetYear()函数
此函数接受日期时间对象作为参数，并从给定的日期时间对象返回当前的年份。
语法
这是 GetYear() 函数的语法。
grunt> GetYear(datetime)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。
date.txt
001,1989/09/26 09:00:00
002,1980/06/20 10:22:00
003,1990/12/19 03:11:44
通过使用 date_data 关系将此文件加载到Pig中，如下所示。
grunt> date_data = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int,date:chararray);
以下是 GetYear() 函数的示例。它将从给定的日期时间对象中检索当前年份。因此，首先，我们使用 todate() 函数生成所有员工的日期时间对象，如下所示。
grunt> todate_data = foreach date_data generate ToDate(date,'yyyy/MM/dd HH:mm:ss')
   as (date_time:DateTime );
  grunt> Dump todate_data;
(1989-09-26T09:00:00.000+05:30) 
(1980-06-20T10:22:00.000+05:30) 
(1990-12-19T03:11:44.000+05:30) 
现在，使用 GetYear() 函数从每个员工的出生日期开始计算年份，并将其存储在名为 getyear_data 的关系中。
grunt> getyear_data = foreach todate_data generate (date_time), GetYear(date_time);
使用Dump运算符验证getyear_data关系的内容，如下所示。
grunt> Dump getyear_data;
  
(1989-09-26T09:00:00.000+05:30,1989) 
(1980-06-20T10:22:00.000+05:30,1980) 
(1990-12-19T03:11:44.000+05:30,1990) 

 
Apache PigAddDuration()函数
此函数接受日期时间对象和持续时间对象，并将给定的持续时间添加到日期时间对象，并返回具有添加的持续时间的新的日期时间对象。
语法
这里是 AddDuration() 函数的语法。
grunt> AddDuration(datetime, duration)
注意：持续时间以ISO 8601标准表示。根据ISO 8601标准P被放置在开始处，同时表示持续时间，并且其被称为持续时间指示符。同样地，
·         
Y 是年份指示符。我们在声明年后使用这个。
·         
示例 - P1Y表示1年。
·         
·         
M 是月份指示符。我们在声明月份后使用这个。
·         
示例 - P1M表示1个月。
·         
·         
W 是星期指示符。我们在声明星期后使用。
·         
示例 - P1W表示1周。
·         
·         
D 是日期指示符。我们在声明天数后使用这个。
·         
示例 - P1D表示1天。
·         
·         
T 是时间指示符。我们在声明时间之前使用它。
·         
示例 - PT5H表示5小时。
·         
·         
H 是小时指示符。我们在声明小时后使用它。
·         
示例 - PT1H表示1小时。
·         
·         
M 是分钟指示符。我们在声明分钟后使用这个。
·         
示例 - PT1M表示1分钟。
·         
·         
S 是秒数指示符。我们在声明秒数后使用它。
·         
示例 - PT1S表示1秒。
·         
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件。此文件包含特定人员的出生日期的详细信息：id，日期和时间以及根据ISO 8601标准的一段时间。
date.txt
001,1989/09/26 09:00:00,PT1M
002,1980/06/20 10:22:00,P1Y
003,1990/12/19 03:11:44,P3M 
通过使用 date_duration 关系将此文件加载到Pig中，如下所示。
grunt> date_duration = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int, date:chararray, duration:chararray)
以下是 AddDuration() 函数的示例。你可以使用此方法将某个持续时间添加到给定的日期时间对象，如下所示。
grunt> Add_duration_data = foreach date_duration generate(date,duration), 
   AddDuration(ToDate(date,'yyyy/MM/dd HH:mm:ss'), duration);
语句的结果将存储在名为 add_duration_data 的关系中。使用Dump运算符验证此关系的内容，如下所示。
grunt> Dump add_duration_data;
  
((1989/09/26 09:00:00,PT1M),1989-09-26 T09:01:00.000+05:30)
((1980/06/20 10:22:00,P1Y),1981-06-20 T10:22:00.000+05:30)
((1990/12/19 03:11:44,P3M),1991-03-19 T03:11:44.000+05:30)
 
Apache PigSubtractDuration()函数
此函数接受日期时间对象和持续时间对象，并从日期时间对象中减去给定的持续时间，返回新的日期时间对象。
语法
这是 SubtractDuration() 函数的语法。
grunt> SubtractDuration(datetime, duration)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 date.txt 的文件。此文件包含特定人员的出生日期的详细信息：id，日期和时间以及根据ISO 8601标准的一些持续时间。
date.txt
001,1989/09/26 09:00:00,PT1M
002,1980/06/20 10:22:00,P1Y
003,1990/12/19 03:11:44,P3M 
通过使用 date_duration 关系将此文件加载到Pig中，如下所示。
grunt> date_duration = LOAD 'hdfs://localhost:9000/pig_data/date.txt' USING PigStorage(',')
   as (id:int, date:chararray, duration:chararray)
以下是 SubtractDuration() 函数的示例。你可以使用此方法从给定的日期时间对象中减去某个持续时间，如下所示。
subtractduration_data = foreach date_duration generate(date,duration), 
   SubtractDuration(ToDate(date,'yyyy/MM/dd HH:mm:ss'), duration);
语句的结果将存储在名为 subtractduration_data 的关系中。使用Dump运算符验证此关系的内容，如下所示。
grunt> Dump subtractduration_data;
  
((1989/09/26 09:00:00,PT1M),1989-09-26 T08:59:00.000+05:30)
((1980/06/20 10:22:00,P1Y),1979-06-20 T10:22:00.000+05:30)
((1990/12/19 03:11:44,P3M),1990-09-19 T03:11:44.000+05:30)
 
Apache PigDaysBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的天数。
语法
这是 DaysBetween() 函数的语法。
grunt> DaysBetween(datetime1, datetime2)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 doj_dob.txt 的文件。此文件包含特定人员的出生日期和入职日期的详细信息：ID，出生日期和入职日期。
doj_dob.txt
001,26/09/1989 09:00:00,16/01/2015 09:00:00
002,20/06/1980 10:22:00,10/08/2011 09:00:00
003,19/12/1990 03:11:44,25/10/2012 09:00:00 
通过使用 doj_dob_data 关系将此文件加载到Pig中，如下所示。
doj_dob_data = LOAD 'hdfs://localhost:9000/pig_data/doj_dob.txt' USING PigStorage(',')
   as (id:int, dob:chararray, doj:chararray);
现在使用 DaysBetween() 函数计算员工的出生日期和入职日期之间的天数。
grunt> daysbetween_data = foreach doj_dob_data generate DaysBetween(ToDate(doj,'dd/MM/yyyy HH:mm:ss'),
   ToDate(dob,'dd/MM/yyyy HH:mm:ss'));
上述语句结果存储在名为 daysbetween_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump daysbetween_data;
  
(9243)
(11372)
(7981) 
 
Apache PigHoursBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的小时数。
语法
这是 HoursBetween() 函数的语法。
grunt> HoursBetween(datetime1, datetime2)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 doj_dob.txt 的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。
doj_dob.txt
001,26/09/1989 09:00:00,16/01/2015 09:00:00
002,20/06/1980 10:22:00,10/08/2011 09:00:00
003,19/12/1990 03:11:44,25/10/2012 09:00:00 
通过使用 doj_dob_data 关系将此文件加载到Pig中，如下所示。
doj_dob_data = LOAD 'hdfs://localhost:9000/pig_data/doj_dob.txt' USING PigStorage(',')
   as (id:int, dob:chararray, doj:chararray);
现在使用 HoursBetween() 函数计算员工出生日期和入职日期之间的小时数，如下所示。
hoursbetween_data = foreach doj_dob_data generate HoursBetween(ToDate(doj,
   'dd/MM/yyyy HH:mm:ss'),ToDate(dob,'dd/MM/yyyy HH:mm:ss'));
上述语句的结果存储在名为 hoursbetween_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump HoursBetween;
  
(221832)
(272950)
(191549)
 
Apache PigMilliSecondsBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的毫秒数。
语法
这是 MilliSecondsBetween() 函数的语法。
grunt> MilliSecondsBetween(datetime1, datetime2)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 doj_dob.txt 的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。
doj_dob.txt
001,26/09/1989 09:00:00,16/01/2015 09:00:00
002,20/06/1980 10:22:00,10/08/2011 09:00:00
003,19/12/1990 03:11:44,25/10/2012 09:00:00 
通过使用 doj_dob_data 关系将此文件加载到Pig中，如下所示。
doj_doba_data = LOAD 'hdfs://localhost:9000/pig_data/doj_dob.txt' USING PigStorage(',')
   as (id:int, dob:chararray, doj:chararray);
现在使用 MilliSecondsBetween() 函数计算员工出生日期和入职日期之间的毫秒数，如下所示。
grunt> millisecondsbetween_data = foreach doj_dob_data generate 
   MilliSecondsBetween(ToDate(doj,'dd/MM/yyyy HH:mm:ss'), ToDate(dob,'dd/MM/yyyy HH:mm:ss'));
上述语句结果将存储在名为 millisecondsbetween_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump millisecondsbetween_data;  
 
(798595200000)
(982622280000)
(689579296000)
 
Apache PigMinutesBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的分钟数。
语法
这是 MinutesBetween() 函数的语法。
grunt> MinutesBetween(datetime1, datetime2)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 doj_dob.txt 的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。
doj_dob.txt
001,26/09/1989 09:00:00,16/01/2015 09:00:00
002,20/06/1980 10:22:00,10/08/2011 09:00:00
003,19/12/1990 03:11:44,25/10/2012 09:00:00 
通过使用 doj_dob_data 关系将此文件加载到Pig中，如下所示。
doj_dob_data = LOAD 'hdfs://localhost:9000/pig_data/doj_dob.txt' USING PigStorage(',')
   as (id:int, dob:chararray, doj:chararray);
现在，使用 MinutesBetween() 函数计算员工出生日期和入职日期之间的分钟数，如下所示。
grunt> minutesbetween_data = foreach doj_dob_data generate
   MinutesBetween(ToDate(doj,'dd/MM/yyyy HH:mm:ss'),ToDate(dob,'dd/MM/yyyy HH:mm:ss'));
上述语句结果将存储在名为 minutesbetween_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump minutesbetween_data;
 
(13309920)
(16377038)
(11492988) 
 
Apache PigMonthsBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的月数。
语法
这是 MonthsBetween() 函数的语法。
grunt> MonthsBetween(datetime1, datetime2) 
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 doj_dob.txt 的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。
doj_dob.txt
001,26/09/1989 09:00:00,16/01/2015 09:00:00
002,20/06/1980 10:22:00,10/08/2011 09:00:00 
003,19/12/1990 03:11:44,25/10/2012 09:00:00 
通过使用 doj_dob_data 关系将此文件加载到Pig中，如下所示。
doj_dob_data = LOAD 'hdfs://localhost:9000/pig_data/doj_dob.txt' USING PigStorage(',')
   as (id:int, dob:chararray, doj:chararray);
现在使用 MonthsBetween() 函数计算员工出生日期和入职日期之间的分钟数，如下所示。
grunt> monthsbetween_data = foreach doj_dob_data generate
   MinutesBetween(ToDate(doj,'dd/MM/yyyy HH:mm:ss'),ToDate(dob,'dd/MM/yyyy HH:mm:ss'));
上述语句结果将存储在名为 monthsbetween_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump monthsbetween;
  
(300)
(374)
(262) 

 
Apache PigSecondsBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的秒数。
语法
这是 SecondsBetween() 函数的语法。
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 doj_dob.txt 的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。
doj_dob.txt
001,26/09/1989 09:00:00,16/01/2015 09:00:00
002,20/06/1980 10:22:00,10/08/2011 09:00:00
003,19/12/1990 03:11:44,25/10/2012 09:00:00 
通过使用 doj_dob_data 关系将此文件加载到Pig中，如下所示。
doj_dob_data = LOAD 'hdfs://localhost:9000/pig_data/doj_dob.txt' USING PigStorage(',')
   as (id:int, dob:chararray, doj:chararray);
现在使用 SecondsBetween() 函数计算员工出生日期和入职日期之间的秒数，如下所示。
secondsbetween_data = foreach doj_dob_data generate SecondsBetween(ToDate(doj,
   'dd/MM/yyyy HH:mm:ss'),ToDate(dob,'dd/MM/yyyy HH:mm:ss'));
上述语句结果将存储在名为 secondsbetween_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump secondsbetween_data;
  
(798595200)
(982622280)
(689579296)

 
Apache PigWeeksBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的周数。
语法
这是 WeeksBetween() 函数的语法。
grunt> WeeksBetween(datetime1, datetime2)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 doj_dob.txt 的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。
doj_dob.txt
001,26/09/1989 09:00:00,16/01/2015 09:00:00
002,20/06/1980 10:22:00,10/08/2011 09:00:00
003,19/12/1990 03:11:44,25/10/2012 09:00:00 
通过使用 doj_dob_data 关系将此文件加载到Pig中，如下所示。
grunt> doj_dob_data = LOAD 'hdfs://localhost:9000/pig_data/doj_dob.txt' USING PigStorage(',')
   as (id:int, dob:chararray, doj:chararray);
现在使用 WeeksBetween() 函数计算员工的出生日期和入职日期之间的周数，如下所示。
grunt> weeksbetween_data = foreach doj_dob_data generate WeeksBetween(ToDate(doj,
   'dd/MM/yyyy HH:mm:ss'),ToDate(dob,'dd/MM/yyyy HH:mm:ss'));
上述语句结果将存储在名为 weeksbetween_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump weeksbetween_data;
  
(1320)
(1624)
(1140) 
 
Apache PigYearsBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的年数。
语法
这是 YearsBetween() 函数的语法。
grunt> YearsBetween(datetime1, datetime2) 
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 doj_dob.txt 的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和加入日期。
doj_dob.txt
001,26/09/1989 09:00:00,16/01/2015 09:00:00
002,20/06/1980 10:22:00,10/08/2011 09:00:00
003,19/12/1990 03:11:44,25/10/2012 09:00:00 
通过使用 doj_dob_data 关系将此文件加载到Pig中，如下所示。
doj_dob_data = LOAD 'hdfs://localhost:9000/pig_data/doj_dob.txt' USING PigStorage(',')
   as (id:int, dob:chararray, doj:chararray);
现在使用 YearsBetween() 函数计算员工出生日期和入职日期之间的年数，如下所示。
grunt> yearsbetween_data = foreach doj_dob_data generate YearsBetween(ToDate(doj,
   'dd/MM/yyyy HH:mm:ss'),ToDate(dob,'dd/MM/yyyy HH:mm:ss'));
上述语句结果将存储在名为 yearsbetween_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump yearsbetween_data;
  
(25)
(31)
(21)
 
Apache Pig ABS()函数
Pig Latin的 ABS() 函数用于计算给定表达式的绝对值。
语法
这是 ABS() 函数的语法。
grunt> ABS(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
使用 ABS() 函数计算math.txt文件内容的绝对值，如下所示。
grunt> abs_data = foreach math_data generate (data), ABS(data);
上述语句结果将存储在名为 abs_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump abs_data; 
 
(5.0,5.0) 
(16.0,16.0) 
(9.0,9.0) 
(2.5,2.5) 
(5.9,5.9) 
(3.1,3.1)
 
Apache Pig ACOS()函数
Pig Latin的 ACOS() 函数用于计算给定表达式的反余弦值。
语法
这是 ACOS() 函数的语法。
grunt> ACOS(expression) 
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float); 
现在使用 ACOS() 函数计算math.txt文件内容的反余弦值，如下所示。
grunt> acos_data = foreach math_data generate (data), ACOS(data);
上述语句结果将存储在名为 abs_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump acos_data;
  
(5.0,NaN) 
(16.0,NaN) 
(9.0,NaN) 
(2.5,NaN) 
(5.9,NaN) 
(3.1,NaN) 
 

 
Apache Pig ASIN()函数
ASIN()函数用于计算给定表达式的反正弦值。
语法
这里是 ASIN() 函数的语法。
grunt> ASIN(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 ASIN() 函数计算math.txt文件内容的反正弦值，如下所示。
grunt> asin_data = foreach math_data generate (data), ASIN(data);
上面的语句结果将存储在名为 asin_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump asin_data;
  
(5.0,NaN) 
(16.0,NaN) 
(9.0,NaN) 
(2.5,NaN) 
(5.9,NaN)  
(3.1,NaN)

 
Apache Pig ATAN()函数
Pig Latin的 ATAN() 函数用于计算给定表达式的反正切值。
语法
这是 ATAN() 函数的语法。
grunt> ATAN(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 ATAN() 函数计算math.txt文件内容的反正切值，如下所示。
grunt> atan_data = foreach math_data generate (data), ATAN(data);
上面的语句结果将存储在名为 asin_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump atan_data;
  
(5.0,1.373400766945016) 
(16.0,1.5083775167989393) 
(9.0,1.460139105621001) 
(2.5,1.1902899496825317) 
(5.9,1.4029004062076729) 
(3.1,1.2587541962439153)
 
Apache Pig CBRT()函数
Pig Latin的 CBRT() 函数用于计算给定表达式的立方根。
语法
这是 CBRT() 函数的语法。
grunt> CBRT(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 CBRT() 函数计算math.txt文件内容的立方根值，如下所示。
grunt> cbrt_data = foreach math_data generate (data), CBRT(data);
上面的语句结果将存储在名为 cbrt_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump cbrt_data;
 
(5.0,1.709975946676697) 
(16.0,2.5198420997897464) 
(9.0,2.080083823051904) 
(2.5,1.3572088082974532) 
(5.9,1.8069688790571206) 
(3.1,1.4580997208745365) 
 
Apache Pig CEIL()函数
CECIL() 函数用于计算向上取整为最接近整数的给定表达式的值（近1取整）。
语法
这是 CECIL() 函数的语法。
grunt> CEIL(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 CEIL() 函数计算math.txt文件内容的ceil值，如下所示。
grunt> ceil_data = foreach math_data generate (data), CEIL(data);
上述语句结果将存储在名为 ceil_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump ceil_data;
  
(5.0,5.0) 
(16.0,16.0) 
(9.0,9.0) 
(2.5,3.0) 
(5.9,6.0) 
(3.1,4.0)
 
Apache Pig COS()函数
Pig Latin的 COS() 函数用于计算给定表达式的余弦值。
语法
这是 COS() 函数的语法。
grunt> COS(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float)
现在，使用 COS() 函数计算math.txt文件内容的余弦值，如下所示。
grunt> cos_data = foreach math_data generate (data), COS(data);
上述语句结果将存储在名为 cos_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump cos_data;
 
(5.0,0.28366218546322625) 
(16.0,-0.9576594803233847) 
(9.0,-0.9111302618846769) 
(2.5,-0.8011436155469337) 
(5.9,0.9274784663996888) 
(3.1,-0.999135146307834) 

 
Apache Pig COSH()函数
Pig Latin的 COSH() 函数用于计算给定表达式的双曲余弦值。
语法
这是 COSH() 函数的语法。
grunt> COSH(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 COSH() 函数计算math.txt文件内容的双曲余弦值，如下所示。
grunt> cosh_data = foreach math_data generate (data), COSH(data);
上述语句结果将存储在名为 cosh_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump cosh_data; 
 
(5.0,74.20994852478785) 
(16.0,4443055.260253992) 
(9.0,4051.5420254925943) 
(2.5,6.132289479663686) 
(5.9,182.52012106128686) 
(3.1,11.121499185584959)
 
 
 
Apache Pig EXP()函数
Pig Latin的 EXP() 函数用于将欧拉数 e 提升到 x （给定表达式）的大小，即指数。
语法
这是 EXP() 函数的语法。
grunt> EXP(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 EXP() 函数计算math.txt文件内容的指数值，如下所示。
grunt> exp_data = foreach math_data generate (data), EXP(data);
上面的语句结果将存储在名为exp_data的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump exp_data;
  
(5.0,148.4131591025766) 
(16.0,8886110.520507872) 
(9.0,8103.083927575384) 
(2.5,12.182493960703473) 
(5.9,365.0375026780162) 
(3.1,22.197949164480132) 
 
Apache Pig FLOOR()函数
FLOOR() 函数用于计算向下舍入到最接近的整数的表达式的值（四舍五入取整），下面是FLOOR() 函数的语法。
grunt> FLOOR(expression)
例
假设在HDFS目录 /pig_data/ 中有一个名为math.txt的文件。此文件包含整数和浮点值，如下所示。
math.tx
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在，使用 FLOOR() 计算math.txt文件内容的四舍五入值，如下所示。
grunt> floor_data = foreach math_data generate (data), FLOOR(data); 
上述语句结果将存储在名为 floor_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump floor_data;
  
(5.0,5.0) 
(16.0,16.0) 
(9.0,9.0) 
(2.5,2.0) 
(5.9,5.0) 
(3.1,3.0) 
 
Apache Pig LOG()函数
Pig Latin的 LOG() 函数用于计算给定表达式的自然对数（基于e）值。
grunt> LOG(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 LOG() 函数计算math.txt文件内容的对数值，如下所示。
grunt> log_data = foreach math_data generate (data),LOG(data);
上述语句结果将存储在名为 log_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump log_data;
  
(5.0,1.6094379124341003) 
(16.0,2.772588722239781) 
(9.0,2.1972245773362196) 
(2.5,0.9162907318741551) 
(5.9,1.774952367075645) 
(3.1,1.1314020807274126)
 
Apache Pig LOG10()函数
Pig Latin的 LOG10() 函数用于计算给定表达式的基于10的自然对数值。
grunt> LOG10(expression)
例
假设在HDFS目录/pig_data/中有一个名为math.txt的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用math_data关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 LOG10() 函数计算math.txt文件内容的log10值，如下所示。
grunt> log_data = foreach math_data generate (data),LOG10(data);
上述语句结果将存储在名为 log_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump log10_data;
  
(5.0,0.6989700043360189) 
(16.0,1.2041199826559248) 
(9.0,0.9542425094393249) 
(2.5,0.3979400086720376) 
(5.9,0.7708520186620678) 
(3.1,0.4913616804737727) 
 
Apache Pig RANDOM()函数
RANDOM() 函数用于获取大于或等于0.0且小于1.0的伪随机数（double类型）。
grunt> RANDOM()
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 RANDOM() 函数生成math.txt文件内容的随机值，如下所示。
grunt> random_data = foreach math_data generate (data), RANDOM();
上述语句结果将存储在名为 random_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump random_data;
  
(5.0,0.6842057767279982) 
(16.0,0.9725172591786139) 
(9.0,0.4159326414649489) 
(2.5,0.30962777780713147) 
(5.9,0.705213727551145) 
(3.1,0.24247708413861724)
 
Apache Pig ROUND()函数
ROUND() 函数用于获取四舍五入为整数（如果结果类型为float）或四舍五入为长整型（如果结果类型为double）的表达式的值。
grunt> ROUND()
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 ROUND() 函数生成math.txt文件内容的舍入值，如下所示。
grunt> round_data = foreach math_data generate (data), ROUND(data);
上述语句结果将存储在名为 round_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump round_data;
 
(5.0,5) 
(16.0,16) 
(9.0,9) 
(2.5,3) 
(5.9,6) 
(3.1,3) 
 
Apache Pig SIN()函数
Pig Latin的 SIN() 函数用于计算给定表达式的正弦值。
语法
这是 SIN() 函数的语法。
grunt> SIN(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在，使用 SIN() 函数计算math.txt文件内容的正弦值，如下所示。
grunt> sin_data = foreach math_data generate (data), SIN(data);
上述语句结果将存储在名为 sin_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump sin_data;
  
(5.0,-0.9589242746631385) 
(16.0,-0.2879033166650653) 
(9.0,0.4121184852417566) 
(2.5,0.5984721441039564) 
(5.9,-0.3738765763789988) 
(3.1,0.04158075771824354)
 
Apache Pig SINH()函数
SINH() 函数用于计算给定表达式的双曲正弦值。
语法
这里是 SINH() 函数的语法。
grunt> SINH(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 SINH() 函数计算math.txt文件内容的双曲正弦值，如下所示。
grunt> sinh_data = foreach math_data generate (data), SINH(data);
上述语句结果将存储在名为 sinh_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump sinh_data;
  
(5.0,74.20321057778875) 
(16.0,4443055.26025388) 
(9.0,4051.54190208279) 
(2.5,6.0502044810397875) 
(5.9,182.51738161672935) 
(3.1,11.076449978895173)
 
Apache Pig SQRT()函数
SQRT() 函数用于计算给定表达式的平方根。
语法
以下是 SQRT() 函数的语法。
grunt> SQRT(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 SQRT() 函数计算math.txt文件内容的平方根值，如下所示。
grunt> sqrt_data = foreach math_data generate (data), SQRT(data);
上面的语句结果将存储在名为 sqrt_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump sqrt_data;
  
(5.0,2.23606797749979) 
(16.0,4.0) 
(9.0,3.0) 
(2.5,1.5811388300841898) 
(5.9,2.4289915799292987) 
(3.1,1.76068165908337) 
 
Apache Pig TAN()函数
TAN() 函数用于计算给定表达式（角度）的三角正切。
语法
这是 TAN() 函数的语法。
grunt> TAN(expression)
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 TAN() 函数计算math.txt文件内容的正切值，如下所示。
grunt> tan_data = foreach math_data generate (data), TAN(data);
上述语句结果将存储在名为 tan_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump tan_data;
 
(5.0,-3.380515006246586) 
(16.0,0.3006322420239034) 
(9.0,-0.45231565944180985) 
(2.5,-0.7470222972386603) 
(5.9,-0.4031107890087444) 
(3.1,-0.041616750118239246)
 
Apache Pig TANH()函数
TANH() 函数用于计算给定表达式（角度）的双曲三角正切。
语法
这是 TANH() 函数的语法。
grunt> TANH(expression) 
例
假设在 HDFS 目录 /pig_data/ 中有一个名为 math.txt 的文件。此文件包含整数和浮点值，如下所示。
math.txt
5 
16 
9 
2.5 
5.9 
3.1 
通过使用 math_data 关系将此文件加载到Pig中，如下所示。
grunt> math_data = LOAD 'hdfs://localhost:9000/pig_data/math.txt' USING PigStorage(',')
   as (data:float);
现在使用 TANH() 函数计算math.txt文件内容的双曲正切值，如下所示。
grunt> tanh_data = foreach math_data generate (data), TANH(data);
上述语句结果将存储在名为 tanh_data 的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt> Dump tanh_data;
  
(5.0,0.9999092042625951) 
(16.0,0.9999999999999747) 
(9.0,0.999999969540041) 
(2.5,0.9866142981514303) 
(5.9,0.9999849909996685) 
(3.1,0.9959493584508665)

阅读全文

1 0

pig课件 框架组件 安装配置 使用 运算符 运行脚本 常用函数

Apache Pig组件

Parser（解析器）

Optimizer（优化器）

Compiler（编译器）

Execution engine（执行引擎）

Pig Latin数据模型

Atom（原子）

Tuple（元组）

Bag（包）

Map（映射）

Relation（关系）

Apache Pig 安装

先决条件

下载ApachePig

安装ApachePig

步骤1

第2步

步骤3

配置ApachePig

.bashrc文件

pig.properties文件

验证安装

Apache Pig 执行

Apache Pig执行模式

Local模式

MapReduce模式

Apache Pig执行机制

调用GruntShell

在批处理模式下执行Apache Pig

Sample_script.pig

Apache Pig Grunt Shell

Shell 命令

sh 命令

fs命令

实用程序命令

clear命令

help命令

history命令

set命令

quit命令

exec命令

kill命令

run命令

Pig Latin - 数据模型

Pig Latin - 语句

例子

Pig Latin - 数据类型

Null值

Pig Latin - 算术运算符

Pig Latin - 比较运算符

Pig Latin - 类型结构运算符

Pig Latin - 关系运算符

Apache Pig 加载数据

准备HDFS

步骤1:验证Hadoop

步骤2:启动HDFS

步骤3:在HDFS中创建目录

步骤4:将数据放在HDFS中

验证文件

Load运算符

语法

启动PigGrunt Shell

执行Load语句

Apache Pig 存储数据

语法

例

输出

验证

步骤1

步骤2

Apache Pig Diagnostic运算符

Dump运算符

语法

例

Apache Pig Describe运算符

语法

例

输出

Apache Pig Explain运算符

pig课件框架组件安装配置使用运算符运行脚本常用函数