您的位置：首页 > 其它

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

2017-12-08 11:27 417 查看
ApachePig架构用于使用Pig分析Hadoop中的数据的语言称为[b]PigLatin[/b]，是一种高级数据处理语言，它提供了一组丰富的数据类型和操作符来对数据执行各种操作。要执行特定任务时，程序员使用Pig，需要用PigLatin语言编写Pig脚本，并使用任何执行机制（GruntShell，UDFs，Embedded）执行它们。执行后，这些脚本将通过应用Pig框架的一系列转换来生成所需的输出。在内部，ApachePig将这些脚本转换为一系列MapReduce作业，因此，它使程序员的工作变得容易。ApachePig的架构如下所示。

ApachePig组件

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

Parser（解析器）

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

Optimizer（优化器）

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

Compiler（编译器）

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

Executionengine（执行引擎）

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

PigLatin数据模型

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

Atom（原子）

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

Tuple（元组）

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

Bag（包）

一个包是一组无序的元组。换句话说，元组（非唯一）的集合被称为包。每个元组可以有任意数量的字段（灵活模式）。包由“{}"表示。它类似于RDBMS中的表，但是与RDBMS中的表不同，不需要每个元组包含相同数量的字段，或者相同位置（列）中的字段具有相同类型。例:{（Raja，30），（Mohammad，45）}包可以是关系中的字段；在这种情况下，它被称为内包（innerbag）。例:{Raja，30，[b]{9848022338，raja@gmail.com，}[/b]}

Map（映射）

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

Relation（关系）

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

ApachePig安装

先决条件

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

下载ApachePig

首先，从以下网站下载最新版本的ApachePig:https://pig.apache.org/pig-0.16.0.tar.gz

安装ApachePig

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

步骤1

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

第2步

提取下载的tar文件，如下所示。
$cdDownloads/
$tarzxvfpig-0.15.0-src.tar.gz
$tarzxvfpig-0.15.0.tar.gz

步骤3

将[b]pig-0.16.0-src.tar.gz[/b]文件的内容移动到之前创建的[b]Pig[/b]目录，如下所示。
$mvpig-0.16.0-src.tar.gz/*/home/Hadoop/Pig/

配置ApachePig

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

.bashrc文件

在[b].bashrc[/b]文件中，设置以下变量·lPIG_HOME文件夹复制到ApachePig的安装文件夹lPATH环境变量复制到bin文件夹lPIG_CLASSPATH环境变量复制到安装Hadoop的etc（配置）文件夹（包含core-site.xml，hdfs-site.xml和mapred-site.xml文件的目录）。·
exportPIG_HOME=/home/Hadoop/Pig
exportPATH=PATH:/home/Hadoop/pig/bin
exportPIG_CLASSPATH=$HADOOP_HOME/conf

pig.properties文件

在Pig的[b]conf[/b]文件夹中，我们有一个名为[b]pig.properties[/b]的文件。在pig.properties文件中，可以设置如下所示的各种参数。
pig-hproperties
支持以下属性:
Logging:verbose=true|false;defaultisfalse.Thispropertyisthesameas-v
&n
4000
bsp;switchbrief=true|false;defaultisfalse.Thispropertyisthesame
as-bswitchdebug=OFF|ERROR|WARN|INFO|DEBUG;defaultisINFO.
Thispropertyisthesameas-dswitchaggregate.warning=true|false;defaultistrue.
Iftrue,printscountofwarningsofeachtyperatherthanloggingeachwarning.
Performancetuning:pig.cachedbag.memusage=<memfraction>;defaultis0.2(20%ofallmemory).
Notethatthismemoryissharedacrossalllargebagsusedbytheapplication.
pig.skewedjoin.reduce.memusagea=<memfraction>;defaultis0.3(30%ofallmemory).
Specifiesthefractionofheapavailableforthereducertoperformthejoin.
pig.exec.nocombiner=true|false;defaultisfalse.
Onlydisablecombinerasatemporaryworkaroundforproblems.
opt.multiquery=true|false;multiqueryisonbydefault.
Onlydisablemultiqueryasatemporaryworkaroundforproblems.
opt.fetch=true|false;fetchisonbydefault.
ScriptscontainingFilter,Foreach,Limit,Stream,andUnioncanbedumpedwithoutMRjobs.
pig.tmpfilecompression=true|false;compressionisoffbydefault.
Determineswhetheroutputofintermediatejobsiscompressed.
pig.tmpfilecompression.codec=lzo|gzip;defaultisgzip.
Usedinconjunctionwithpig.tmpfilecompression.Definescompressiontype.
pig.noSplitCombination=true|false.Splitcombinationisonbydefault.
Determinesifmultiplesmallfilesarecombinedintoasinglemap.
pig.exec.mapPartAgg=true|false.Defaultisfalse.
Determinesifpartialaggregationisdonewithinmapphase,beforerecordsaresenttocombiner.
pig.exec.mapPartAgg.minReduction=<minaggregationfactor>.Defaultis10.
Ifthein-mappartialaggregationdoesnotreducetheoutputnumrecordsbythisfactor,itgetsdisabled.
Miscellaneous:exectype=mapreduce|tez|local;defaultismapreduce.Thispropertyisthesameas-xswitch
pig.additional.jars.uris=<commaseperatedlistofjars>.Usedinplaceofregistercommand.
udf.import.list=<commaseperatedlistofimports>.UsedtoavoidpackagenamesinUDF.
stop.on.failure=true|false;defaultisfalse.Settotruetoterminateonthefirsterror.
pig.datetime.default.tz=<UTCtimeoffset>.e.g.+08:00.Defaultisthedefaulttimezoneofthehost.
DeterminesthetimezoneusedtohandledatetimedatatypeandUDFs.
Additionally,anyHadooppropertycanbespecified.
验证安装
通过键入version命令验证ApachePig的安装。如果安装成功，你将获得ApachePig的正式版本，如下所示。
$pig–version
ApachePigversion0.16.0(r1682971)
compiledJun012015,11:44:35
ApachePig执行
ApachePig执行模式
你可以以两种模式运行ApachePig，即Local（本地）模式和HDFS模式。
Local模式
在此模式下，所有文件都从本地主机和本地文件系统安装和运行，不需要Hadoop或HDFS。此模式通常用于测试目的。
MapReduce模式
MapReduce模式是我们使用ApachePig加载或处理Hadoop文件系统（HDFS）中存在的数据的地方。在这种模式下，每当我们执行PigLatin语句来处理数据时，会在后端调用一个MapReduce作业，以对HDFS中存在的数据执行特定的操作。
ApachePig执行机制
ApachePig脚本可以通过三种方式执行，即交互模式，批处理模式和嵌入式模式。交互模式（Gruntshell）-你可以使用Gruntshell以交互模式运行ApachePig。在此shell中，你可以输入PigLatin语句并获取输出（使用Dump运算符）。批处理模式（脚本）-你可以通过将PigLatin脚本写入具有[b].pig[/b]扩展名的单个文件中，以批处理模式运行ApachePig。嵌入式模式（UDF）-ApachePig允许在Java等编程语言中定义我们自己的函数（UDF用户定义函数），并在我们的脚本中使用它们。·
调用GruntShell
你可以使用“-x"选项以所需的模式（local/MapReduce）调用Gruntshell，如下所示。
Local模式MapReduce模式
Command（命令）-$./pig-xlocalCommand（命令）-$./pig-xmapreduce
Output（输出）-Output（输出）-
这两个命令都给出了Gruntshell提示符，如下所示。
grunt>
你可以使用“ctrl+d"退出Gruntshell。在调用Gruntshell之后，可以通过直接输入Pig中的PigLatin语句来执行Pig脚本。
grunt>customers=LOAD'customers.txt'USINGPigStorage(',');
在批处理模式下执行ApachePig
你可以在文件中编写整个PigLatin脚本，并使用[b]-xcommand[/b]执行它。我们假设在一个名为[b]sample_script.pig[/b]的文件中有一个Pig脚本，如下所示。
Sample_script.pig
student=LOAD'hdfs://localhost:9000/pig_data/student.txt'USING
PigStorage(',')as(id:int,name:chararray,city:chararray);
Dumpstudent;
现在，你可以在上面的文件中执行脚本，如下所示。
Local模式MapReduce模式
$pig-xlocalSample_script.pig$pig-xmapreduceSample_script.pig
注意:我们将详细讨论如何在批处理模式和嵌入模式中运行Pig脚本。
ApachePigGruntShell
调用Gruntshell后，可以在shell中运行Pig脚本。除此之外，还有由Gruntshell提供的一些有用的shell和实用程序命令。本章讲解的是Gruntshell提供的shell和实用程序命令。注意:在本章的某些部分中，使用了Load和Store等命令。请参阅相应章节以获取有关它们的详细信息。
Shell命令
ApachePig的Gruntshell主要用于编写PigLatin脚本。在此之前，我们可以使用[b]sh[/b]和[b]fs[/b]来调用任何shell命令。
sh命令
使用[b]sh[/b]命令，我们可以从Gruntshell调用任何shell命令，但无法执行作为shell环境（[b]ex[/b]-cd）一部分的命令。语法下面给出了[b]sh[/b]命令的语法。
grunt>shshellcommandparameters
示例我们可以使用[b]sh[/b]选项从Gruntshell中调用Linuxshell的[b]ls[/b]命令，如下所示。在此示例中，它列出了[b]/pig/bin/[/b]目录中的文件。
grunt>shls
pig
pig_1444799121955.log
pig.cmd
pig.py
fs命令
使用[b]fs[/b]命令，我们可以从Gruntshell调用任何FsShell命令。语法下面给出了[b]fs[/b]命令的语法。
grunt>shFileSystemcommandparameters
示例我们可以使用fs命令从Gruntshell调用HDFS的ls命令。在以下示例中，它列出了HDFS根目录中的文件。
grunt>fs–ls
Found3items
drwxrwxrwx-Hadoopsupergroup02015-09-0814:13Hbase
drwxr-xr-x-Hadoopsupergroup02015-09-0914:52seqgen_data
drwxr-xr-x-Hadoopsupergroup02015-09-0811:30twitter_data
以同样的方式，我们可以使用[b]fs[/b]命令从Gruntshell中调用所有其他文件系统的shell命令。
实用程序命令
Gruntshell提供了一组实用程序命令。这些包括诸如clear，help，history，quit和set等实用程序命令；以及Gruntshell中诸如[b]exec，kill[/b]和run等命令来控制Pig。下面给出了Gruntshell提供的实用命令的描述。
clear命令
clear命令用于清除Gruntshell的屏幕。语法你可以使用[b]clear[/b]命令清除gruntshell的屏幕，如下所示。
grunt>clear
help命令
help命令提供了Pig命令或Pig属性的列表。使用你可以使用[b]help[/b]命令获取Pig命令列表，如下所示。
grunt>help
Commands:<piglatinstatement>;-SeethePigLatinmanualfordetails:
http://hadoop.apache.org/pig
Filesystemcommands:fs<fsarguments>-EquivalenttoHadoopdfscommand:
http://hadoop.apache.org/common/docs/current/hdfs_shell.html
DiagnosticCommands:describe<alias>[::<alias]-Showtheschemaforthealias.
InneraliasescanbedescribedasA::B.
explain[-script<pigscript>][-out<path>][-brief][-dot|-xml]
[-param<param_name>=<pCram_value>1c13f;]
[-param_file<file_name>][<alias>]-
Showtheexecutionplantocomputethealiasorforentirescript.
-script-Explaintheentirescript.
-out-Storetheoutputintodirectoryratherthanprinttostdout.
-brief-Don'texpandnestedplans(presentingasmallergraphforoverview).
-dot-Generatetheoutputin.dotformat.Defaultistextformat.
-xml-Generatetheoutputin.xmlformat.Defaultistextformat.
-param<param_name-Seeparametersubstitutionfordetails.
-param_file<file_name>-Seeparametersubstitutionfordetails.
alias-Aliastoexplain.
dump<alias>-Computethealiasandwritestheresultstostdout.
UtilityCommands:exec[-param<param_name>=param_value][-param_file<file_name>]<script>-
Executethescriptwithaccesstogruntenvironmentincludingaliases.
-param<param_name-Seeparametersubstitutionfordetails.
-param_file<file_name>-Seeparametersubstitutionfordetails.
script-Scripttobeexecuted.
run[-param<param_name>=param_value][-param_file<file_name>]<script>-
Executethescriptwithaccesstogruntenvironment.
-param<param_name-Seeparametersubstitutionfordetails.
-param_file<file_name>-Seeparametersubstitutionfordetails.
script-Scripttobeexecuted.
sh<shellcommand>-Invokeashellcommand.
kill<job_id>-Killthehadoopjobspecifiedbythehadoopjobid.
set<key><value>-ProvideexecutionparameterstoPig.Keysandvaluesarecasesensitive.
Thefollowingkeysaresupported:
default_parallel-Script-levelreduceparallelism.Basicinputsizeheuristicsused
bydefault.
debug-Setdebugonoroff.Defaultisoff.
job.name-Single-quotednameforjobs.DefaultisPigLatin:<scriptname>
job.priority-Priorityforjobs.Values:very_low,low,normal,high,very_high.
Defaultisnormalstream.skippath-Stringthatcontainsthepath.
Thisisusedbystreaminganyhadoopproperty.
help-Displaythismessage.
history[-n]-Displaytheliststatementsincache.
-nHidelinenumbers.
quit-Quitthegruntshell.
history命令
此命令显示自Gruntshell被调用以来执行/使用的语句的列表。使用假设我们自打开Gruntshell之后执行了三个语句。
grunt>customers=LOAD'hdfs://localhost:9000/pig_data/customers.txt'USINGPigStorage(',');
grunt>orders=LOAD'hdfs://localhost:9000/pig_data/orders.txt'USINGPigStorage(',');
grunt>student=LOAD'hdfs://localhost:9000/pig_data/student.txt'USINGPigStorage(',');
然后，使用[b]history[/b]命令将产生以下输出。
grunt>history
customers=LOAD'hdfs://localhost:9000/pig_data/customers.txt'USINGPigStorage(',');
orders=LOAD'hdfs://localhost:9000/pig_data/orders.txt'USINGPigStorage(',');
student=LOAD'hdfs://localhost:9000/pig_data/student.txt'USINGPigStorage(',');
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命令
你可以使用此命令从Gruntshell退出。使用从Gruntshell中退出，如下所示。
grunt>quit
现在让我们看看从Gruntshell控制ApachePig的命令。
exec命令
使用[b]exec[/b]命令，我们可以从Gruntshell执行Pig脚本。语法下面给出了实用程序命令[b]exec[/b]的语法。
grunt>exec[–paramparam_name=param_value][–param_filefile_name][script]
示例我们假设在HDFS的[b]/pig_data/[/b]目录中有一个名为[b]student.txt[/b]的文件，其中包含以下内容。Student.txt
001,Rajiv,Hyderabad
002,siddarth,Kolkata
003,Rajesh,Delhi
并且，假设我们在HDFS的[b]/pig_data/[/b]目录中有一个名为[b]sample_script.pig[/b]的脚本文件，并具有以下内容。Sample_script.pig
student=LOAD'hdfs://localhost:9000/pig_data/student.txt'USINGPigStorage(',')
as(id:int,name:chararray,city:chararray);
Dumpstudent;
现在，让我们使用[b]exec[/b]命令从Gruntshell中执行上面的脚本，如下所示。
grunt>exec/sample_script.pig
输出exec命令执行[b]sample_script.pig[/b]中的脚本。按照脚本中的指示，它会将[b]student.txt[/b]文件加载到Pig中，并显示Dump操作符的结果，显示以下内容。
(1,Rajiv,Hyderabad)
(2,siddarth,Kolkata)
(3,Rajesh,Delhi)
kill命令
你可以使用此命令从Gruntshell中终止一个作业。语法下面给出了[b]kill[/b]命令的语法。
grunt>killJobId
示例假设有一个具有idId_0055的正在运行的Pig作业，使用[b]kill[/b]命令从Gruntshell中终止它，如下所示。
grunt>killId_0055
run命令
你可以使用run命令从Gruntshell运行Pig脚本语法下面给出了[b]run[/b]命令的语法。
grunt>run[–paramparam_name=param_value][–param_filefile_name]script
示例假设在HDFS的[b]/pig_data/[/b]目录中有一个名为[b]student.txt[/b]的文件，其中包含以下内容。Student.txt
001,Rajiv,Hyderabad
002,siddarth,Kolkata
003,Rajesh,Delhi
并且，假设我们在本地文件系统中有一个名为[b]sample_script.pig[/b]的脚本文件，并具有以下内容。Sample_script.pig
student=LOAD'hdfs://localhost:9000/pig_data/student.txt'USING
PigStorage(',')as(id:int,name:chararray,city:chararray);
现在，让我们使用run命令从Gruntshell运行上面的脚本，如下所示。
grunt>run/sample_script.pig
你可以使用Dump操作符查看脚本的输出，如下所示。
grunt>Dump;
(1,Rajiv,Hyderabad)
(2,siddarth,Kolkata)
(3,Rajesh,Delhi)
注意:exec和[b]run[/b]命令之间的区别是，如果使用run，则脚本中的语句在history命令中可用。PigLatin基础PigLatin是用于使用ApachePig分析Hadoop中数据的语言。在本章中，我们将讨论PigLatin的基础知识，如PigLatin语句，数据类型，通用运算符，关系运算符和PigLatinUDF。
PigLatin-数据模型
如前面章节所讨论的，Pig的数据模型是完全嵌套的。Relation是PigLatin数据模型的最外层结构。它是一个包其中:·包是元组的集合。·元组是有序的字段集。·字段是一段数据。
PigLatin-语句
在使用PigLatin处理数据时，语句是基本结构。这些语句使用关系（relation），它们包括表达式（expression）和模式（schema）。每个语句以分号（;）结尾。我们将使用PigLatin提供的运算符通过语句执行各种操作。除了LOAD和STORE，在执行所有其他操作时，PigLatin语句采用关系作为输入，并产生另一个关系作为输出。只要在Gruntshell中输入[b]Load[/b]语句，就会执行语义检查。要查看模式的内容，需要使用[b]Dump[/b]运算符。只有在执行[b]dump[/b]操作后，才会执行将数据加载到文件系统的MapReduce作业。
例子
下面给出一个PigLatin语句，它将数据加载到ApachePig中。
grunt>Student_data=LOAD'student_data.txt'USINGPigStorage(',')as
(id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray);
PigLatin-数据类型
下面给出的表描述了PigLatin数据类型。
序号数据类型说明＆示例
1int表示有符号的32位整数。示例:8
2long表示有符号的64位整数。示例:5L
3float表示有符号的32位浮点。示例:5.5F
4double表示64位浮点。示例:10.5
5chararray表示UnicodeUTF-8格式的字符数组（字符串）。示例:‘w3cschool’
6Bytearray表示字节数组（blob）。
7Boolean表示布尔值。示例:true/false。
8Datetime表示日期时间。示例:1970-01-01T00:00:00.000+00:00
9Biginteger表示JavaBigInteger。示例:60708090709
10Bigdecimal表示JavaBigDecimal示例:185.98376256272893883
复杂类型
11Tuple元组是有序的字段集。示例:（raja,30）
12Bag包是元组的集合。示例:{（raju,30）,（Mohhammad,45）}
13Map地图是一组键值对。示例:['name'＃'Raju','age'＃30]
Null值
所有上述数据类型的值可以为NULL。ApachePig以与SQL类似的方式处理空值。null可以是未知值或不存在值，它用作可选值的占位符。这些空值可以自然出现或者可以是操作的结果。
PigLatin-算术运算符
下表描述了PigLatin的算术运算符。假设a=10和b=20。
运算符描述示例
+加-运算符的两侧的值相加a+b将得出30
−减-从运算符左边的数中减去右边的数a-b将得出-10
*乘-运算符两侧的值相乘a*b将得出200
/除-用运算符左边的数除右边的数b/a将得出2
%系数-用运算符右边的数除左边的数并返回余数b％a将得出0
？:Bincond-评估布尔运算符。它有三个操作数，如下所示。变量[b]x[/b]=（expression）？value1（如果为true）:[b]value2[/b]（如果为false）。b=（a==1）？20:30;如果a=1，则b的值为20。如果a！=1，则b的值为30。
CASEWHENTHENELSEENDCase-case运算符等效于嵌套的bincond运算符。CASEf2％2WHEN0THEN'even'WHEN1THEN'odd'END
PigLatin-比较运算符
下表描述了PigLatin的比较运算符。
运算符描述示例
==等于-检查两个数的值是否相等；如果是，则条件变为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模式匹配-检查左侧的字符串是否与右侧的常量匹配。f1matches'.*tutorial.*'
PigLatin-类型结构运算符
下表描述了PigLatin的类型结构运算符。
运算符描述示例
()元组构造函数运算符-此运算符用于构建元组。（Raju,30）
{}包构造函数运算符-此运算符用于构造包。{（Raju,30）,（Mohammad,45）}
[]映射构造函数运算符-此运算符用于构造一个映射。[name＃Raja,age＃30]
PigLatin-关系运算符
下表描述了PigLatin的关系运算符。
运算符描述
加载和存储
LOAD将数据从文件系统（local/HDFS）加载到关系中。
STORE将数据从文件系统（local/HDFS）存储到关系中。
过滤
FILTER从关系中删除不需要的行。
DISTINCT从关系中删除重复行。
FOREACH，GENERATE基于数据列生成数据转换。
STREAM使用外部程序转换关系。
分组和连接
JOIN连接两个或多个关系。
COGROUP将数据分组为两个或多个关系。
GROUP在单个关系中对数据进行分组。
CROSS创建两个或多个关系的向量积。
排序
ORDER基于一个或多个字段（升序或降序）按排序排列关系。
LIMIT从关系中获取有限数量的元组。
合并和拆分
UNION将两个或多个关系合并为单个关系。
SPLIT将单个关系拆分为两个或多个关系。
诊断运算符
DUMP在控制台上打印关系的内容。
DESCRIBE描述关系的模式。
EXPLAIN查看逻辑，物理或MapReduce执行计划以计算关系。
ILLUSTRATE查看一系列语句的分步执行。
ApachePig加载数据
一般来说，ApachePig在Hadoop之上工作。它是一种分析工具，用于分析[b]H[/b]adoopFile[b]S[/b]ystem中存在的大型数据集。要使用ApachePig分析数据，我们必须首先将数据加载到ApachePig中。本章介绍如何从HDFS将数据加载到ApachePig。
准备HDFS
在MapReduce模式下，Pig从HDFS读取（加载）数据并将结果存回HDFS。因此，让我们先从HDFS开始，在HDFS中创建以下示例数据。
学生ID名字姓氏电话号码城市
001RajivReddy9848022337Hyderabad
002siddarthBattacharya9848022338Kolkata
003RajeshKhanna9848022339Delhi
004PreethiAgarwal9848022330Pune
005TrupthiMohanthy9848022336Bhuwaneshwar
006ArchanaMishra9848022335Chennai
上述数据集包含六个学生的个人详细信息，如id，名字，姓氏，电话号码和城市。
步骤1:验证Hadoop
首先，使用Hadoopversion命令验证安装，如下所示。
$hadoopversion
如果你的系统里有Hadoop，并且已设置PATH变量，那么你将获得以下输出-
Hadoop2.6.0
Subversionhttps://git-wip-us.apache.org/repos/asf/hadoop.git-r
e3496499ecb8d220fba99dc5ed4c99c8f9e33bb1
Compiledbyjenkinson2014-11-13T21:10Z
Compiledwithprotoc2.5.0
Fromsourcewithchecksum18e43357c8f927c0695f1e9522859d6a
Thiscommandwasrunusing/home/Hadoop/hadoop/share/hadoop/common/hadoop
common-2.6.0.jar
步骤2:启动HDFS
步骤3:在HDFS中创建目录
在HadoopDFS中，可以使用mkdir命令创建目录。在HDFS所需路径中创建一个名为[b]Pig_Data[/b]的新目录，如下所示。
$cd/$Hadoop_Home/bin/
$hdfsdfs-mkdirhdfs://localhost:9000/Pig_Data
步骤4:将数据放在HDFS中
Pig的输入文件包含单个行中的每个元组/记录。记录的实体由分隔符分隔（在我们的示例中，我们使用“，”）。在本地文件系统中，创建一个包含数据的输入文件[b]student_data.txt[/b]，如下所示。
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.
现在，使用[b]put[/b]命令将文件从本地文件系统移动到HDFS，如下所示。（你也可以使用[b]copyFromLocal[/b]命令。）
$cd$HADOOP_HOME/bin
$hdfsdfs-put/home/Hadoop/Pig/Pig_Data/student_data.txtdfs://localhost:9000/pig_data/
验证文件
使用[b]cat[/b]命令验证文件是否已移入HDFS，如下所示。
$cd$HADOOP_HOME/bin
$hdfsdfs-cathdfs://localhost:9000/pig_data/student_data.txt
35,Chennai
Load运算符
你可以使用[b]PigLatin[/b]的[b]LOAD[/b]运算符，从文件系统（HDFS/Local）将数据加载到ApachePig中。
语法
load语句由两部分组成，用“=”运算符分隔。在左侧，需要提到我们想要存储数据的关系的名称；而在右侧，我们需要定义如何存储数据。下面给出了[b]Load[/b]运算符的语法。
Relation_name=LOAD'Inputfilepath'USINGfunctionasschema;
说明:relation_name-我们必须提到要存储数据的关系。Inputfilepath-我们必须提到存储文件的HDFS目录。（在MapReduce模式下）function-我们必须从ApachePig提供的一组加载函数中选择一个函数（BinStorage，JsonLoader，PigStorage，TextLoader）。Schema-我们必须定义数据的模式，可以定义所需的模式如下-
(column1:datatype,column2:datatype,column3:datatype);
注意:我们加载数据而不指定模式。在这种情况下，列将被寻址为$01，$02，等...（检查）。例如，我们使用[b]LOAD[/b]命令，在名为学生的模式下在Pig中的[b]student_data.txt[/b]加载数据。
启动PigGruntShell
首先，打开Linux终端。在MapReduce模式下启动PigGruntshell，如下所示。
$Pig–xmapreduce
grunt>
执行Load语句
现在，通过在Gruntshell中执行以下PigLatin语句，将文件[b]student_data.txt[/b]中的数据加载到Pig中。
grunt>student=LOAD'hdfs://localhost:9000/pig_data/student_data.txt'
USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,
city:chararray);
以下是对上述说明的描述。
Relationname我们已将数据存储在学生（student）模式中。
Inputfilepath我们从HDFS的/pig_data/目录中的[b]student_data.txt[/b]文件读取数据。
Storagefunction我们使用了[b]PigStorage()[/b]函数，将数据加载并存储为结构化文本文件。它采用分隔符，使用元组的每个实体作为参数分隔。默认情况下，它以“\t"作为参数。
schema我们已经使用以下模式存储了数据。
columnid名字姓氏电话号码城市
datatypeintchararraychararraychararraychararray
注意:Load语句会简单地将数据加载到Pig的指定的关系中。要验证Load语句的执行情况，必须使用Diagnostic运算符，这将在后续的章节中讨论。
ApachePig存储数据
语法
下面给出了Store语句的语法。
STORERelation_nameINTO'required_directory_path'[USINGfunction];
例
假设我们在HDFS中有一个包含以下内容的文件[b]student_data.txt[/b]。
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运算符将它读入关系[b]student[/b]，如下所示。
grunt>student=LOAD'hdfs://localhost:9000/pig_data/student_data.txt'
USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,
city:chararray);
现在，让我们将关系存储在HDFS目录“/pig_Output/"中，如下所示。
grunt>STOREstudentINTO'hdfs://localhost:9000/pig_Output/'USINGPigStorage(',');
输出
执行[b]store[/b]语句后，将获得以下输出。使用指定的名称创建目录，并将数据存储在其中。
验证
你可以如下所示验证存储的数据。
步骤1
首先，使用[b]ls[/b]命令列出名为[b]pig_output[/b]的目录中的文件，如下所示。
hdfsdfs-ls'hdfs://localhost:9000/pig_Output/'
Found2items
rw-r--r-1Hadoopsupergroup02015-10-0513:03hdfs://localhost:9000/pig_Output/_SUCCESS
rw-r--r-1Hadoopsupergroup2242015-10-0513:03hdfs://localhost:9000/pig_Output/part-m-00000
可以观察到在执行[b]store[/b]语句后创建了两个文件。
步骤2
使用[b]cat[/b]命令，列出名为[b]part-m-00000[/b]的文件的内容，如下所示。
$hdfsdfs-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
ApachePigDiagnostic运算符
Load语句会简单地将数据加载到ApachePig中的指定关系中。要验证Load语句的执行，必须使用Diagnostic运算符。PigLatin提供四种不同类型的诊断运算符:·Dump运算符·Describe运算符·Explanation运算符·Illustration运算符在本章中，我们将讨论PigLatin的Dump运算符。
Dump运算符
Dump运算符用于运行PigLatin语句，并在屏幕上显示结果，它通常用于调试目的。
语法
下面给出了[b]Dump[/b]运算符的语法。
grunt>DumpRelation_Name
例
假设在HDFS中有一个包含以下内容的文件[b]student_data.txt[/b]。
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运算符将它读入关系[b]student[/b]，如下所示。
grunt>student=LOAD'hdfs://localhost:9000/pig_data/student_data.txt'
USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,
city:chararray);
现在，使用Dump运算符打印关系的内容，如下所示。
grunt>Dumpstudent
一旦执行上述[b]PigLatin[/b]语句，将启动一个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)
ApachePigDescribe运算符
describe运算符用于查看关系的模式。
语法
describe运算符的语法如下
grunt>DescribeRelation_name
例
假设在HDFS中有一个包含以下内容的文件[b]student_data.txt[/b]。
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运算符将它读入关系[b]student[/b]，如下所示。
grunt>student=LOAD'hdfs://localhost:9000/pig_data/student_data.txt'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray);
现在，让我们描述名为student的关系，并验证模式如下所示。
grunt>describestudent;
输出
执行上述[b]PigLatin[/b]语句后，将生成以下输出。
grunt>student:{id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray}
ApachePigExplain运算符
explain运算符用于显示关系的逻辑，物理和MapReduce执行计划。
语法
下面给出了[b]explain[/b]运算符的语法。
grunt>explainRelation_name;
例
假设在HDFS中有一个包含以下内容的文件[b]student_data.txt[/b]。
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运算符将它读入关系[b]student[/b]，如下所示。
grunt>student=LOAD'hdfs://localhost:9000/pig_data/student_data.txt'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray);
现在，让我们使用[b]explain[/b]运算符解释名为student的关系，如下所示。
grunt>explainstudent;
输出
它将产生以下输出。
$explainstudent;
ApachePigillustrate运算符
illustrate运算符为你提供了一系列语句的逐步执行。
语法
下面给出了illustrate运算符的语法。
grunt>illustrateRelation_name;
例
假设在HDFS中有一个包含以下内容的文件[b]student_data.txt[/b]。
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运算符将它读入关系[b]student[/b]，如下所示。
grunt>student=LOAD'hdfs://localhost:9000/pig_data/student_data.txt'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray);
现在，让我们说明如下所示的名为student的关系。
grunt>illustratestudent;
输出
在执行上面的语句时，将获得以下输出。
grunt>illustratestudent;
ApachePigGroup运算符
GROUP运算符用于在一个或多个关系中对数据进行分组，它收集具有相同key的数据。
语法
下面给出了[b]group[/b]运算符的语法。
grunt>Group_data=GROUPRelation_nameBYage;
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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
将这个文件加载到ApachePig中，关系名称为student_details，如下所示。
grunt>student_details=LOAD'hdfs://localhost:9000/pig_data/student_details.txt'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray);
现在，让我们按照年龄关系中的记录/元组进行分组，如下所示。
grunt>group_data=GROUPstudent_detailsbyage;
验证
使用[b]DUMP[/b]运算符验证关系[b]group_data[/b]，如下所示。
grunt>Dumpgroup_data;
输出
将获得显示名为group_data关系的内容的输出，如下所示。在这里你可以观察到结果模式有两列:一个是age，通过它我们将关系分组。另一个是bag，其中包含一组元组，有各自年龄的学生记录。·
(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)})
(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)})
在使用[b]describe[/b]命令分组数据后，可以看到表的模式，如下所示。
grunt>Describegroup_data;
group_data:{group:int,student_details:{(id:int,firstname:chararray,
lastname:chararray,age:int,phone:chararray,city:chararray)}}
以同样的方式，可以使用illustrate命令获取模式的示例说明，如下所示。
$Illustrategroup_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=GROUPstudent_detailsby(age,city);
可以使用Dump运算符验证名为[b]group_multiple[/b]的关系的内容，如下所示。
grunt>Dumpgroup_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)})
GroupAll
你可以按所有的列对关系进行分组，如下所示。
grunt>group_all=GROUPstudent_detailsAll;
现在，请验证关系[b]group_all[/b]的内容，如下所示。
grunt>Dumpgroup_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,Bhuwaneshwar),
(4,Preethi,Agarwal,21,9848022330,Pune),(3,Rajesh,Khanna,22,9848022339,Delhi),
(2,siddarth,Battacharya,22,9848022338,Kolkata),(1,Rajiv,Reddy,21,9848022337,Hyderabad)})
ApachePigCogroup运算符
COGROUP运算符的运作方式与 GROUP运算符相同。两个运算符之间的唯一区别是[b]group[/b]运算符通常用于一个关系，而[b]cogroup[/b]运算符用于涉及两个或多个关系的语句。
使用Cogroup分组两个关系
假设在HDFS目录[b]/pig_data/[/b]中有两个文件，即[b]student_details.txt[/b]和[b]employee_details.txt[/b]，如下所示。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中，关系名称分别为[b]student_details[/b]和[b]employee_details[/b]，如下所示。
grunt>student_details=LOAD'hdfs://localhost:9000/pig_data/student_details.txt'USINGPigStorage(',')
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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
现在，将student_details和[b]employee_details[/b]关系的记录/元组按关键字age进行分组，如下所示。
grunt>cogroup_data=COGROUPstudent_detailsbyage,employee_detailsbyage;
验证
使用[b]DUMP[/b]运算符验证关系[b]cogroup_data[/b]，如下所示。
grunt>Dumpcogroup_data;
输出
它将产生以下输出，显示名为[b]cogroup_data[/b]的关系的内容，如下所示。
(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岁的第一关系（在这种情况是[b]student_details[/b]）的所有元组；第二个包具有第二关系（在这种情况下为[b]employee_details[/b]）的所有元组，其年龄为21岁。如果关系不具有年龄值为21的元组，则返回一个空包。
ApachePigJoin运算符
JOIN运算符用于组合来自两个或多个关系的记录。在执行连接操作时，我们从每个关系中声明一个（或一组）元组作为key。当这些key匹配时，两个特定的元组匹配，否则记录将被丢弃。连接可以是以下类型：·Self-join·Inner-join·Outer-join−leftjoin,rightjoin,andfulljoin本章介绍了如何在PigLatin中使用join运算符的示例。假设在HDFS的[b]/pig_data/[/b]目录中有两个文件，即[b]customers.txt[/b]和[b]orders.txt[/b]，如下所示。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-0800:00:00,3,3000
100,2009-10-0800:00:00,3,1500
101,2009-11-2000:00:00,2,1560
103,2008-05-2000:00:00,4,2060
我们将这两个文件与customers和orders关系一起加载到Pig中，如下所示。
grunt>customers=LOAD'hdfs://localhost:9000/pig_data/customers.txt'USINGPigStorage(',')
as(id:int,name:chararray,age:int,address:chararray,salary:int);
grunt>orders=LOAD'hdfs://localhost:9000/pig_data/orders.txt'USINGPigStorage(',')
as(oid:int,date:chararray,customer_id:int,amount:int);
现在让我们对这两个关系执行各种连接操作。
Self-join（自连接）
Self-join用于将表与其自身连接，就像表是两个关系一样，临时重命名至少一个关系。通常，在ApachePig中，为了执行self-join，我们将在不同的别名（名称）下多次加载相同的数据。那么，将文件[b]customers.txt[/b]的内容加载为两个表，如下所示。
grunt>customers1=LOAD'hdfs://localhost:9000/pig_data/customers.txt'USINGPigStorage(',')
as(id:int,name:chararray,age:int,address:chararray,salary:int);
grunt>customers2=LOAD'hdfs://localhost:9000/pig_data/customers.txt'USINGPigStorage(',')
as(id:int,name:chararray,age:int,address:chararray,salary:int);
语法
下面给出使用[b]JOIN[/b]运算符执行self-join操作的语法。
grunt>Relation3_name=JOINRelation1_nameBYkey,Relation2_nameBYkey;
例
通过如图所示加入两个关系[b]customers1[/b]和[b]customers2[/b]，对关系[b]customers[/b]执行self-join操作。
grunt>customers3=JOINcustomers1BYid,customers2BYid;
验证
使用[b]DUMP[/b]运算符验证关系[b]customers3[/b]，如下所示。
grunt>Dumpcustomers3;
输出
将产生以下输出，显示关系[b]customers[/b]的内容。
(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)
InnerJoin（内部连接）
InnerJoin使用较为频繁；它也被称为等值连接。当两个表中都存在匹配时，内部连接将返回行。基于连接谓词（join-predicate），通过组合两个关系（例如A和B）的列值来创建新关系。查询将A的每一行与B的每一行进行比较，以查找满足连接谓词的所有行对。当连接谓词被满足时，A和B的每个匹配的行对的列值被组合成结果行。
语法
以下是使用[b]JOIN[/b]运算符执行innerjoin操作的语法。
grunt>result=JOINrelation1BYcolumnname,relation2BYcolumnname;
例
让我们对customers和orders执行innerjoin操作，如下所示。
grunt>coustomer_orders=JOINcustomersBYid,ordersBYcustomer_id;
验证
使用[b]DUMP[/b]运算符验证coustomer_orders关系，如下所示。
grunt>Dumpcoustomer_orders;
输出
将获得以下输出，是名为[b]coustomer_orders[/b]的关系的内容。
(2,Khilan,25,Delhi,1500,101,2009-11-2000:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-0800:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-0800:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-2000:00:00,4,2060)
注意：OuterJoin：与innerjoin不同，outerjoin返回至少一个关系中的所有行。outerjoin操作以三种方式执行：·Leftouterjoin·Rightouterjoin·Fullouterjoin
LeftOuterJoin（左外连接）
leftouterjoin操作返回左表中的所有行，即使右边的关系中没有匹配项。
语法
下面给出使用[b]JOIN[/b]运算符执行leftouterjoin操作的语法。
grunt>Relation3_name=JOINRelation1_nameBYidLEFTOUTER,Relation2_nameBYcustomer_id;
例
让我们对customers和orders的两个关系执行leftouterjoin操作，如下所示。
grunt>outer_left=JOINcustomersBYidLEFTOUTER,ordersBYcustomer_id;
验证
使用[b]DUMP[/b]运算符验证关系[b]outer_left[/b]，如下所示。
grunt>Dumpouter_left;
输出
它将产生以下输出，显示关系[b]outer_left[/b]的内容。
(1,Ramesh,32,Ahmedabad,2000,,,,)
(2,Khilan,25,Delhi,1500,101,2009-11-2000:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-0800:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-0800:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-2000:00:00,4,2060)
(5,Hardik,27,Bhopal,8500,,,,)
(6,Komal,22,MP,4500,,,,)
(7,Muffy,24,Indore,10000,,,,)
RightOuterJoin（右外连接）
rightouterjoin操作将返回右表中的所有行，即使左表中没有匹配项。
语法
下面给出使用[b]JOIN[/b]运算符执行rightouterjoin操作的语法。
grunt>outer_right=JOINcustomersBYidRIGHT,ordersBYcustomer_id;
例
让我们对customers和orders执行rightouterjoin操作，如下所示。
grunt>outer_right=JOINcustomersBYidRIGHT,ordersBYcustomer_id;
验证
使用[b]DUMP[/b]运算符验证关系[b]outer_right[/b]，如下所示。
grunt>Dumpouter_right
输出
它将产生以下输出，显示关系[b]outer_right[/b]的内容。
(2,Khilan,25,Delhi,1500,101,2009-11-2000:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-0800:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-0800:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-2000:00:00,4,2060)
FullOuterJoin（全外连接）
当一个关系中存在匹配时，fullouterjoin操作将返回行。
语法
下面给出使用[b]JOIN[/b]运算符执行fullouterjoin的语法。
grunt>outer_full=JOINcustomersBYidFULLOUTER,ordersBYcustomer_id;
例
让我们对customers和orders执行fullouterjoin操作，如下所示。
grunt>outer_full=JOINcustomersBYidFULLOUTER,ordersBYcustomer_id;
验证
使用[b]DUMP[/b]运算符验证关系[b]outer_full[/b]，如下所示。
grun>Dumpouter_full;
输出
它将产生以下输出，显示关系[b]outer_full[/b]的内容。
(1,Ramesh,32,Ahmedabad,2000,,,,)
(2,Khilan,25,Delhi,1500,101,2009-11-2000:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-0800:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-0800:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-2000: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=JOINRelation2_nameBY(key1,key2),Relation3_nameBY(key1,key2);
假设在HDFS的[b]/pig_data/[/b]目录中有两个文件，即[b]employee.txt[/b]和[b]employee_contact.txt[/b]，如下所示。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和[b]employee_contact[/b]，如下所示。
grunt>employee=LOAD'hdfs://localhost:9000/pig_data/employee.txt'USINGPigStorage(',')
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'USINGPigStorage(',')
as(id:int,phone:chararray,email:chararray,city:chararray,jobid:int);
现在，让我们使用[b]JOIN[/b]运算符连接这两个关系的内容，如下所示。
grunt>emp=JOINemployeeBY(id,jobid),employee_contactBY(id,jobid);
验证
使用[b]DUMP[/b]运算符验证关系[b]emp[/b]，如下所示。
grunt>Dumpemp;
输出
它将产生以下输出，显示名为[b]emp[/b]的关系的内容，如下所示。
(1,Rajiv,Reddy,21,programmer,113,1,9848022337,Rajiv@gmail.com,Hyderabad,113)
(2,siddarth,Battacharya,22,programmer,113,2,9848022338,siddarth@gmail.com,Kolkata,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,Bhuwaneshwar,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)
ApachePigCross运算符
CROSS运算符计算两个或多个关系的向量积。本章将以示例说明如何在PigLatin中使用cross运算符。
语法
下面给出了[b]CROSS[/b]运算符的语法。
grunt>Relation3_name=CROSSRelation1_name,Relation2_name;
例
假设在HDFS的[b]/pig_data/[/b]目录中有两个文件，即[b]customers.txt[/b]和[b]orders.txt[/b]，如下所示。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-0800:00:00,3,3000
100,2009-10-0800:00:00,3,1500
101,2009-11-2000:00:00,2,1560
103,2008-05-2000:00:00,4,2060
将这两个文件加载到Pig中，通过关系customers和orders，如下所示。
grunt>customers=LOAD'hdfs://localhost:9000/pig_data/customers.txt'USINGPigStorage(',')
as(id:int,name:chararray,age:int,address:chararray,salary:int);
grunt>orders=LOAD'hdfs://localhost:9000/pig_data/orders.txt'USINGPigStorage(',')
as(oid:int,date:chararray,customer_id:int,amount:int);
现在让我们使用[b]cross[/b]运算符获得这两个关系的向量积，如下所示。
grunt>cross_data=CROSScustomers,orders;
验证
使用[b]DUMP[/b]运算符验证关系[b]cross_data[/b]，如下所示。
grunt>Dumpcross_data;
输出
它将产生以下输出，显示关系[b]cross_data[/b]的内容。
(7,Muffy,24,Indore,10000,103,2008-05-2000:00:00,4,2060)
(7,Muffy,24,Indore,10000,101,2009-11-2000:00:00,2,1560)
(7,Muffy,24,Indore,10000,100,2009-10-0800:00:00,3,1500)
(7,Muffy,24,Indore,10000,102,2009-10-0800:00:00,3,3000)
(6,Komal,22,MP,4500,103,2008-05-2000:00:00,4,2060)
(6,Komal,22,MP,4500,101,2009-11-2000:00:00,2,1560)
(6,Komal,22,MP,4500,100,2009-10-0800:00:00,3,1500)
(6,Komal,22,MP,4500,102,2009-10-0800:00:00,3,3000)
(5,Hardik,27,Bhopal,8500,103,2008-05-2000:00:00,4,2060)
(5,Hardik,27,Bhopal,8500,101,2009-11-2000:00:00,2,1560)
(5,Hardik,27,Bhopal,8500,100,2009-10-0800:00:00,3,1500)
(5,Hardik,27,Bhopal,8500,102,2009-10-0800:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-2000:00:00,4,2060)
(4,Chaitali,25,Mumbai,6500,101,2009-2000:00:00,4,2060)
(2,Khilan,25,Delhi,1500,101,2009-11-2000:00:00,2,1560)
(2,Khilan,25,Delhi,1500,100,2009-10-0800:00:00,3,1500)
(2,Khilan,25,Delhi,1500,102,2009-10-0800:00:00,3,3000)
(1,Ramesh,32,Ahmedabad,2000,103,2008-05-2000:00:00,4,2060)
(1,Ramesh,32,Ahmedabad,2000,101,2009-11-2000:00:00,2,1560)
(1,Ramesh,32,Ahmedabad,2000,100,2009-10-0800:00:00,3,1500)
(1,Ramesh,32,Ahmedabad,2000,102,2009-10-0800:00:00,3,3000)-11-2000:00:00,2,1560)
(4,Chaitali,25,Mumbai,6500,100,2009-10-0800:00:00,3,1500)
(4,Chaitali,25,Mumbai,6500,102,2009-10-0800:00:00,3,3000)
(3,kaushik,23,Kota,2000,103,2008-05-2000:00:00,4,2060)
(3,kaushik,23,Kota,2000,101,2009-11-2000:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-0800:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-0800:00:00,3,3000)
(2,Khilan,25,Delhi,1500,103,2008-05-2000:00:00,4,2060)
(2,Khilan,25,Delhi,1500,101,2009-11-2000:00:00,2,1560)
(2,Khilan,25,Delhi,1500,100,2009-10-0800:00:00,3,1500)
(2,Khilan,25,Delhi,1500,102,2009-10-0800:00:00,3,3000)
(1,Ramesh,32,Ahmedabad,2000,103,2008-05-2000:00:00,4,2060)
(1,Ramesh,32,Ahmedabad,2000,101,2009-11-2000:00:00,2,1560)
(1,Ramesh,32,Ahmedabad,2000,100,2009-10-0800:00:00,3,1500)
(1,Ramesh,32,Ahmedabad,2000,102,2009-10-0800:00:00,3,3000)
ApachePigUnion运算符
PigLatin的[b]UNION[/b]运算符用于合并两个关系的内容。要对两个关系执行UNION操作，它们的列和域必须相同。
语法
下面给出了[b]UNION[/b]运算符的语法。
grunt>Relation_name3=UNIONRelation_name1,Relation_name2;
例
假设在HDFS的[b]/pig_data/[/b]目录中有两个文件，即[b]student_data1.txt[/b]和[b]student_data2.txt[/b]，如下所示。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和[b]student2[/b]，如下所示。
grunt>student1=LOAD'hdfs://localhost:9000/pig_data/student_data1.txt'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray);
grunt>student2=LOAD'hdfs://localhost:9000/pig_data/student_data2.txt'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray);
现在，让我们使用[b]UNION[/b]运算符合并这两个关系的内容，如下所示。
grunt>student=UNIONstudent1,student2;
验证
使用[b]DUMP[/b]运算子验证关系student，如下所示。
grunt>Dumpstudent;
输出
它将显示以下输出，显示关系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)
ApachePigSplit运算符
SPLIT运算符用于将关系拆分为两个或多个关系。
语法
下面给出了[b]SPLIT[/b]运算符的语法。
grunt>SPLITRelation1_nameINTORelation2_nameIF(condition1),Relation2_name(condition2),
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray);
现在，让我们将关系分为两个，一个列出年龄小于23岁的员工，另一个列出年龄在22到25岁之间的员工。
SPLITstudent_detailsintostudent_details1ifage<23,student_details2if(22<ageandage>25);
验证
使用[b]DUMP[/b]操作符验证关系[b]student_details1[/b]和[b]student_details2[/b]，如下所示。
grunt>Dumpstudent_details1;
grunt>Dumpstudent_details2;
输出
它将产生以下输出，分别显示关系[b]student_details1[/b]和[b]student_details2[/b]的内容。
grunt>Dumpstudent_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>Dumpstudent_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)
ApachePigFilter运算符
FILTER运算符用于根据条件从关系中选择所需的元组。
语法
下面给出了[b]FILTER[/b]运算符的语法。
grunt>Relation2_name=FILTERRelation1_nameBY(condition);
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray);
现在使用Filter运算符来获取属于Chennai城市的学生的详细信息。
filter_data=FILTERstudent_detailsBYcity=='Chennai';
验证
使用[b]DUMP[/b]运算符验证关系[b]filter_data[/b]，如下所示。
grunt>Dumpfilter_data;
输出
它将产生以下输出，显示关系[b]filter_data[/b]的内容如下。
(6,Archana,Mishra,23,9848022335,Chennai)
(8,Bharathi,Nambiayar,24,9848022333,Chennai)
ApachePigDistinct运算符
DISTINCT运算符用于从关系中删除冗余（重复）元组。
语法
下面给出了[b]DISTINCT[/b]运算符的语法。
grunt>Relation_name2=DISTINCTRelatin_name1;
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray);
现在，让我们使用[b]DISTINCT[/b]运算符从[b]student_details[/b]关系中删除冗余（重复）元组，并将其另存在一个名为[b]distinct_data[/b]的关系如下所示。
grunt>distinct_data=DISTINCTstudent_details;
验证
使用[b]DUMP[/b]运算符验证关系[b]distinct_data[/b]，如下所示。
grunt>Dumpdistinct_data;
输出
它将产生以下输出，显示关系[b]distinct_data[/b]的内容如下。
(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)
ApachePigForeach运算符
FOREACH运算符用于基于列数据生成指定的数据转换。
语法
下面给出了[b]FOREACH[/b]运算符的语法。
grunt>Relation_name2=FOREACHRelatin_name1GENERATE(requireddata);
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray);
现在让我们从关系[b]student_details[/b]中获取每个学生的id，age和city值，并使用[b]foreach运算符[/b]将它存储到另一个名为[b]foreach_data[/b]关系，如下所示。
grunt>foreach_data=FOREACHstudent_detailsGENERATEid,age,city;
验证
使用[b]DUMP[/b]运算符验证关系[b]foreach_data[/b]，如下所示。
grunt>Dumpforeach_data;
输出
它将产生以下输出，显示关系[b]foreach_data[/b]的内容。
(1,21,Hyderabad)
(2,22,Kolkata)
(3,22,Delhi)
(4,21,Pune)
(5,23,Bhuwaneshwar)
(6,23,Chennai)
(7,24,trivendram)
(8,24,Chennai)
ApachePigOrderBy运算符
ORDERBY运算符用于以基于一个或多个字段的排序顺序显示关系的内容。
语法
下面给出了[b]ORDERBY[/b]运算符的语法。
grunt>Relation_name2=ORDERRelatin_name1BY(ASC|DESC);
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray);
现在让我们根据学生的年龄以降序排列关系，并使用[b]ORDERBY[/b]运算符将它存储到另一个名为[b]order_by_data[/b]的关系中，如下所示。
grunt>order_by_data=ORDERstudent_detailsBYageDESC;
验证
使用[b]DUMP[/b]运算符验证关系[b]order_by_data[/b]，如下所示。
grunt>Dumporder_by_data;
输出
它将产生以下输出，显示关系[b]order_by_data[/b]的内容。
(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)
ApachePigLimit运算符
LIMIT运算符用于从关系中获取有限数量的元组。
语法
下面给出了[b]LIMIT[/b]运算符的语法。
grunt>Result=LIMITRelation_namerequirednumberoftuples;
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray);
现在，让我们根据学生的年龄以降序对关系进行排序，并使用[b]ORDERBY[/b]运算符将其存储到另一个名为[b]limit_data[/b]的关系中，如下所示。
grunt>limit_data=LIMITstudent_details4;
验证
使用[b]DUMP运算符验证关系[b]limit_data[/b]，如下所示。
grunt>Dumplimit_data;
输出
它将产生以下输出，显示关系[b]limit_data[/b]的内容如下。
(1,Rajiv,Reddy,21,9848022337,Hyderabad)
(2,siddarth,Battacharya,22,9848022338,Kolkata)
(3,Rajesh,Khanna,22,9848022339,Delhi)
(4,Preethi,Agarwal,21,9848022330,Pune)
ApachePigEval函数
ApachePig提供了各种内置函数，即[b]eval，load，store，math，string，bag[/b]和[b]tuple[/b]函数。
Eval函数
下面给出了ApachePig提供的[b]eval[/b]函数列表。
S.N.函数＆描述
1AVG()计算包内数值的平均值。
2BagToString()将包的元素连接成字符串。在连接时，我们可以在这些值之间放置分隔符（可选）。
3CONCAT()连接两个或多个相同类型的表达式。
4COUNT()获取包中元素的数量，同时计算包中元组的数量。
5COUNT_STAR()它类似于COUNT()函数。它用于获取包中的元素数量。
6DIFF()比较元组中的两个包（字段）。
7IsEmpty()检查包或映射是否为空。
8MAX()计算单列包中的列（数值或字符）的最大值。
9MIN()要获取单列包中特定列的最小（最低）值（数字或字符）。
10PluckTuple()使用PigLatin的PluckTuple()函数，可以定义字符串Prefix，并过滤以给定prefix开头的关系中的列。
11SIZE()基于任何Pig数据类型计算元素的数量。
12SUBTRACT()两个包相减，它需要两个包作为输入，并返回包含第一个包中不在第二个包中的元组的包。
13SUM()要获取单列包中某列的数值总和。
14TOKENIZE()要在单个元组中拆分字符串（其中包含一组字），并返回包含拆分操作的输出的包。
ApachePig加载和存储函数
ApachePig中的加载和存储函数用于确定数据如何从Pig中弹出。这些函数与加载和存储运算符一起使用。下面给出了Pig中可用的加载和存储函数的列表。
S.N.函数&描述
1PigStorage()加载和存储结构化文件。
2TextLoader()将非结构化数据加载到Pig中。
3BinStorage()使用机器可读格式将数据加载并存储到Pig中。
4HandlingCompression在PigLatin中，我们可以加载和存储压缩数据。
ApachePig包和元组函数
下面给出了Bag和Tuple函数的列表。
S.N.函数＆描述
1TOBAG()将两个或多个表达式转换为包。
2TOP()获取关系的顶部N个元组。
3TOTUPLE()将一个或多个表达式转换为元组。
4TOMAP()将key-value对转换为Map。
ApachePig字符串函数
在ApachePig中有以下String函数。
S.N.函数＆描述
1ENDSWITH(string,testAgainst)验证给定字符串是否以特定子字符串结尾。
2STARTSWITH(string,substring)接受两个字符串参数，并验证第一个字符串是否以第二个字符串开头。
3SUBSTRING(string,startIndex,stopIndex)返回来自给定字符串的子字符串。
4EqualsIgnoreCase(string1,string2)比较两个字符串，忽略大小写。
5INDEXOF(string,‘character’,startIndex)返回字符串中第一个出现的字符，从开始索引向前搜索。
6LAST_INDEX_OF(expression)返回字符串中最后一次出现的字符的索引，从开始索引向后搜索。
7LCFIRST(expression)将字符串中的第一个字符转换为小写。
8UCFIRST(expression)返回一个字符串，其中第一个字符转换为大写。
9UPPER(expression)返回转换为大写的字符串。
10LOWER(expression)将字符串中的所有字符转换为小写。
11REPLACE(string,‘oldChar’,‘newChar’);使用新字符替换字符串中的现有字符。
12STRSPLIT(string,regex,limit)围绕给定正则表达式的匹配拆分字符串。
13STRSPLITTOBAG(string,regex,limit)与STRSPLIT()函数类似，它通过给定的分隔符将字符串拆分，并将结果返回到包中。
14TRIM(expression)返回删除了前端和尾部空格的字符串的副本。
15LTRIM(expression)返回删除了前端空格的字符串的副本。
16RTRIM(expression)返回已删除尾部空格的字符串的副本。
ApachePig日期时间函数
ApachePig提供以下日期和时间函数-
S.N.函数＆描述
1ToDate(milliseconds)此函数根据给定的参数返回日期时间对象。此函数的另一个替代方法是ToDate（iosstring），ToDate（userstring,format），ToDate（userstring,format,timezone）
2CurrentTime()返回当前时间的日期时间对象。
3GetDay(datetime)从日期时间对象返回一个月中的某一天。
4GetHour(datetime)从日期时间对象返回一天中的小时。
5GetMilliSecond(datetime)从日期时间对象返回秒中的毫秒。
6GetMinute(datetime)从日期时间对象返回一小时中的分钟。
7GetMonth(datetime)从日期时间对象返回一年中的月份。
8GetSecond(datetime)从日期时间对象返回一分钟的秒。
9GetWeek(datetime)从日期时间对象返回一年中的周。
10GetWeekYear(datetime)从日期时间对象返回周年。
11GetYear(datetime)从日期时间对象返回年份。
12AddDuration(datetime,duration)返回日期时间对象的结果以及持续时间对象。
13SubtractDuration(datetime,duration)从Date-Time对象中减去Duration对象并返回结果。
14DaysBetween(datetime1,datetime2)返回两个日期时间对象之间的天数。
15HoursBetween(datetime1,datetime2)返回两个日期时间对象之间的小时数。
16MilliSecondsBetween(datetime1,datetime2)返回两个日期时间对象之间的毫秒数。
17MinutesBetween(datetime1,datetime2)返回两个日期时间对象之间的分钟数。
18MonthsBetween(datetime1,datetime2)返回两个日期时间对象之间的月数。
19SecondsBetween(datetime1,datetime2)返回两个日期时间对象之间的秒数。
20WeeksBetween(datetime1,datetime2)返回两个日期时间对象之间的周数。
21YearsBetween(datetime1,datetime2)返回两个日期时间对象之间的年数。
ApachePig数学函数
我们在ApachePig中有以下Math（数学）函数:
S.N.函数＆描述
1ABS(expression)获取表达式的绝对值。
2ACOS(expression)获得表达式的反余弦值。
3ASIN(expression)获取表达式的反正弦值。
4ATAN(expression)此函数用于获取表达式的反正切值。
5CBRT(expression)此函数用于获取表达式的立方根。
6CEIL(expression)此函数用于获取向上舍入到最接近的整数的表达式的值（近1取整）。
7COS(expression)此函数用于获取表达式的三角余弦值。
8COSH(expression)此函数用于获取表达式的双曲余弦值。
9EXP(expression)此函数用于获得欧拉数e乘以x的幂，即指数。
10FLOOR(expression)要获得向下取整为最接近整数的表达式的值（四舍五入取整）。
11LOG(expression)获得表达式的自然对数（基于e）。
12LOG10(expression)得到表达式的基于10的对数。
13RANDOM()获得大于或等于0.0且小于1.0的伪随机数（double类型）。
14ROUND(expression)要将表达式的值四舍五入为整数（如果结果类型为float）或四舍五入为长整型（如果结果类型为double）。
15SIN(expression)获得表达式的正弦值。
16SINH(expression)获得表达式的双曲正弦值。
17SQRT(expression)获得表达式的正平方根。
18TAN(expression)获得角度的三角正切。
19TANH(expression)获得表达式的双曲正切。
ApachePig用户定义函数（UDF）
除了内置函数之外，ApachePig还为[b]U[/b]serDefinedFunction（UDF：用户定义函数）提供广泛的支持。使用这些UDF，可以定义我们自己的函数并使用它们。UDF支持六种编程语言，即Java，Jython，Python，JavaScript，Ruby和Groovy。对于编写UDF，在Java中提供全面的支持，并在所有其他语言中提供有限的支持。使用Java，你可以编写涉及处理的所有部分的UDF，如数据加载/存储，列转换和聚合。由于ApachePig是用Java编写的，因此与其他语言相比，使用Java语言编写的UDF工作效率更高。在ApachePig中，我们还有一个用于UDF名为[b]Piggybank[/b]的Java存储库。使用Piggybank，我们可以访问由其他用户编写的JavaUDF，并贡献我们自己的UDF。
Java中的UDF的类型
在使用Java编写UDF时，我们可以创建和使用以下三种类型的函数·Filter函数-Filter（过滤）函数用作过滤器语句中的条件。这些函数接受Pig值作为输入并返回布尔值。··Eval函数-Eval函数在FOREACH-GENERATE语句中使用。这些函数接受Pig值作为输入并返回Pig结果。··Algebraic函数-Algebraic（代数）函数对FOREACHGENERATE语句中的内包起作用。这些函数用于对内包执行完全MapReduce操作。·
使用Java编写UDF
要使用Java编写UDF，我们必须集成jar文件[b]Pig-0.15.0.jar[/b]。在本章节中，将讨论如何使用Eclipse编写示例UDF。在继续学习前，请确保你已在系统中安装了Eclipse和Maven。按照下面给出的步骤写一个UDF函数：打开Eclipse并创建一个新项目（例如[b]myproject[/b]）。将新创建的项目转换为Maven项目。在pom.xml中复制以下内容。此文件包含ApachePig和Hadoop-corejar文件的Maven依赖关系。
<projectxmlns="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>
·保存文件并刷新它。在[b]Maven依赖关系[/b]部分中，可以找到下载的jar文件。··创建名为[b]Sample_Eval[/b]的新的类文件，并在其中复制以下内容。·
importjava.io.IOException;
importorg.apache.pig.EvalFunc;
importorg.apache.pig.data.Tuple;
importjava.io.IOException;
importorg.apache.pig.EvalFunc;
importorg.apache.pig.data.Tuple;
publicclassSample_EvalextendsEvalFunc<String>{
publicStringexec(Tupleinput)throwsIOException{
if(input==null||input.size()==0)
returnnull;
Stringstr=(String)input.get(0);
returnstr.toUpperCase();
}
}
在编写UDF时，必须继承EvalFunc类并向[b]exec()[/b]函数提供实现。在此函数中，写入UDF所需的代码。在上面的例子中，我们返回了将给定列的内容转换为大写的代码。编译完类并确认没有错误后，右键单击Sample_Eval.java文件。它将呈现一个菜单。选择“export”，如以下屏幕截图所示。点击“export”，将看到以下窗口。点击“JARfile”。点击“Next>”按钮继续操作。将获得另一个窗口，你需要在本地文件系统中输入路径，在其中存储jar文件。最后，单击“Finish”按钮。在指定的文件夹中，创建一个Jar文件[b]sample_udf.jar[/b]。此jar文件包含用Java编写的UDF。
使用UDF
在编写UDF和生成Jar文件后，请按照下面给出的步骤：
步骤1：注册Jar文件
在写入UDF（在Java中）后，我们必须使用Register运算符注册包含UDF的Jar文件。通过注册Jar文件，用户可以将UDF的位置绑定到ApachePig。语法下面给出了Register运算符的语法。
REGISTERpath;
例让我们注册本章前面创建的sample_udf.jar。以本地模式启动ApachePig并注册jar文件sample_udf.jar，如下所示。
$cdPIG_HOME/bin
$./pig–xlocal
REGISTER'/$PIG_HOME/sample_udf.jar'
注意：假设路径中的Jar文件：/$PIG_HOME/sample_udf.jar
步骤2：定义别名
注册UDF后，可以使用[b]Define[/b]运算符为其定义一个别名。语法下面给出了Define运算符的语法。
DEFINEalias{function|[`command`[input][output][ship][cache][stderr]]};
例定义sample_eval的别名，如下所示。
DEFINEsample_evalsample_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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
现在使用UDFsample_eval将员工的姓名转换为大写。
grunt>Upper_case=FOREACHemp_dataGENERATEsample_eval(name);
请验证关系[b]Upper_case[/b]的内容，如下所示。
grunt>DumpUpper_case;
(ROBIN)
(BOB)
(MAYA)
(SARA)
(DAVID)
(MAGGY)
(ROBERT)
(SYAM)
(MARY)
(SARAN)
(STACY)
(KELLY)
ApachePig运行脚本
Pig脚本中的注释
在将脚本写入文件时，我们可以在其中包含注释，如下所示。
多行注释
我们将用'/*'开始多行注释，以'*/'结束。
/*Thesearethemulti-linecomments
Inthepigscript*/
单行注释
我们将用“--"开始单行注释。
--wecanwritesinglelinecommentslikethis.
在批处理模式下执行Pig脚本
在以批处理方式执行ApachePig语句时，请按照以下步骤操作。
步骤1
将所有需要的PigLatin语句写在单个文件中。我们可以将所有PigLatin语句和命令写入单个文件，并将其另存为[b].pig[/b]文件。
步骤2
执行ApachePig脚本。你可以从shell（Linux）执行Pig脚本，如下所示。
Local模式MapReduce模式
$pig-xlocalSample_script.pig$pig-xmapreduceSample_script.pig
你可以使用exec命令从Gruntshell执行它，如下所示。
grunt>exec/sample_script.pig
从HDFS执行Pig脚本
我们还可以执行驻留在HDFS中的Pig脚本。假设在名为[b]/pig_data/[/b]的HDFS目录中有名为[b]Sample_script.pig[/b]的Pig脚本。我们可以执行它如下所示。
$pig-xmapreducehdfs://localhost:9000/pig_data/Sample_script.pig
例
假设在HDFS中有一个具有以下内容的文件[b]student_details.txt[/b]。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目录中有一个名为[b]sample_script.pig[/b]的示例脚本。此文件包含对student关系执行操作和转换的语句，如下所示。
student=LOAD'hdfs://localhost:9000/pig_data/student_details.txt'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray);
student_order=ORDERstudentBYageDESC;
student_limit=LIMITstudent_order4;
Dumpstudent_limit;
·脚本的第一个语句会将名为[b]student_details.txt[/b]的文件中的数据加载为名为student的关系。··脚本的第二个语句将根据年龄以降序排列关系的元组，并将其存储为[b]student_order[/b]。··脚本的第三个语句会将[b]student_order[/b]的前4个元组存储为[b]student_limit[/b]。··最后，第四个语句将转储关系[b]student_limit[/b]的内容。·现在，执行[b]sample_script.pig[/b]，如下所示。
$./pig-xmapreducehdfs://localhost:9000/pig_data/sample_script.pig
ApachePig被执行，并提供具有以下内容的输出。
(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-1910:31:27,446[main]INFOorg.apache.pig.Main-Pigscriptcompletedin12
minutes,32secondsand751milliseconds(752751ms)
----------------------------------------------------------------------------------------------------------------------------------------------------------
ApachePigAVG()函数
Pig-LatinAVG()函数用于计算包内数值的平均值。在计算平均值时，[b]AVG()[/b]函数会忽略NULL值。注意·要获取全局平均值，我们需要执行GroupAll操作，并使用[b]AVG()[/b]函数计算平均值。··要获取组的平均值，我们需要使用GroupBy运算符对其进行分组，然后继续使用average函数。·
语法
下面给出了[b]AVG()[/b]函数的语法。grunt>AVG(expression)
例
假设我们在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray,gpa:int);
计算平均GPA
我们可以使用内置函数[b]AVG()[/b]（区分大小写）来计算一组数值的平均值。让我们使用GroupAll运算符将关系[b]student_details[/b]分组，并将结果存储在名为[b]student_group_all[/b]的关系中，如下所示。
grunt>student_group_all=Groupstudent_detailsAll;
这将产生如下所示的关系。
grunt>Dumpstudent_group_all;
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Kolkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89)})
现在让我们使用[b]AVG()[/b]函数计算所有学生的全球平均GPA，如下所示。
grunt>student_gpa_avg=foreachstudent_group_allGenerate
(student_details.firstname,student_details.gpa),AVG(student_details.gpa);
验证
使用[b]DUMP[/b]运算子验证关系[b]student_gpa_avg[/b]，如下所示。
grunt>Dumpstudent_gpa_avg;
输出
它将显示关系[b]student_gpa_avg[/b]的内容，如下所示。
(({(Bharathi),(Komal),(Archana),(Trupthi),(Preethi),(Rajesh),(siddarth),(Rajiv)},
{(72),(83),(87),(75),(93),(90),(78),(89)}),83.375)
ApachePigBagToString()函数
PigLatin的[b]BagToString()[/b]函数用于将包的元素连接成字符串。在连接时，我们可以在这些值之间放置分隔符（可选）。通常，包是无序的，可以使用ORDERBY运算符排序。
语法
下面给出了[b]BagToString()[/b]函数的语法。
grunt>BagToString(vals:bag[,delimiter:chararray])
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]dateofbirth.txt[/b]的文件，如下所示。此文件包含出生日期。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'USINGPigStorage(',')
as(day:int,month:int,year:int);
将包转换为字符串
使用[b]bagtostring()[/b]函数，我们可以将bag中的数据转换为字符串。让我们将[b]dob[/b]关系分组，组操作将生成含有关系的所有元组的包。使用GroupAll运算符将关系[b]dob[/b]分组，并将结果存储在名为[b]group_dob[/b]的关系中，如下所示。
grunt>group_dob=GroupdobAll;
它将产生如下所示的关系。
grunt>Dumpgroup_dob;
(all,{(26,9,1989),(2,6,1980),(1,3,1998),(23,11,1989),(22,3,1990)})
在这里，我们可以观察到一个有所有出生日期的包作为它的元组。现在，让我们使用函数[b]BagToString()[/b]将包转换为字符串。
grunt>dob_string=foreachgroup_dobGenerateBagToString(dob);
验证
使用[b]DUMP[/b]运算符验证关系[b]dob_string[/b]，如下所示。
grunt>Dumpdob_string;
输出
它将产生以下输出，显示关系[b]dob_string[/b]的内容。
(26_9_1989_2_6_1980_1_3_1998_23_11_1989_22_3_1990)
ApachePigCONCAT()函数
PigLatin的[b]CONCAT()[/b]函数用于连接两个或多个相同类型的表达式。
语法
grunt>CONCAT(expression,expression,[...expression])
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray,gpa:int);
连接两个字符串
我们可以使用[b]CONCAT()[/b]函数来连接两个或多个表达式。首先，使用Dump运算符验证[b]student_details[/b]关系的内容，如下所示。
grunt>Dumpstudent_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)
然后，使用[b]describe[/b]运算符验证schema（模式），如下所示。
grunt>Describestudent_details;
student_details:{id:int,firstname:chararray,lastname:chararray,age:int,
phone:chararray,city:chararray,gpa:int}
在上面的模式中，可以观察到学生的名称使用两个字符值即[b]firstname[/b]和[b]lastname[/b]来表示。让我们使用[b]CONCAT()[/b]函数来连接这两个值。
grunt>student_name_concat=foreachstudent_detailsGenerateCONCAT(firstname,lastname);
验证
使用[b]DUMP[/b]运算符验证关系[b]student_name_concat[/b]，如下所示。
grunt>Dumpstudent_name_concat;
输出
它将产生以下输出，显示关系[b]student_name_concat[/b]的内容。
(RajivReddy)
(siddarthBattacharya)
(RajeshKhanna)
(PreethiAgarwal)
(TrupthiMohanthy)
(ArchanaMishra)
(KomalNayak)
(BharathiNambiayar)
我们还可以在两个表达式之间使用可选的分隔符，如下所示。
grunt>CONCAT(firstname,'_',lastname);
现在，让我们通过将[b]student_details[/b]关系中的'_'连接学生记录的firstname和lastname，如下所示。
grunt>student_name_concat=foreachstudent_detailsGENERATECONCAT(firstname,'_',lastname);
验证
使用[b]DUMP[/b]运算符验证关系[b]student_name_concat[/b]，如下所示。
grunt>Dumpstudent_name_concat;
输出
它将产生以下输出，显示关系[b]student_name_concat[/b]的内容如下。
(Rajiv_Reddy)
(siddarth_Battacharya)
(Rajesh_Khanna)
(Preethi_Agarwal)
(Trupthi_Mohanthy)
(Archana_Mishra)
(Komal_Nayak)
(Bharathi_Nambiayar)
ApachePigCOUNT()函数
PigLatin的[b]COUNT()[/b]函数用于获取包中的元素数量。而在计算包中元组数量时，[b]COUNT()[/b]函数忽略（不计算）在FIRSTFIELD中具有NULL值的元组。注意·要获取全局计数值（包中的元组总数），我们需要执行GroupAll操作，并使用COUNT()函数计算计数值。··要获取组的计数值（组中的元组数），我们需要使用GroupBy运算符对其进行分组，然后继续count函数。·
语法
以下给出了[b]COUNT()[/b]函数的语法。
grunt>COUNT(expression)
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray,gpa:int);
计算元组数
我们可以使用内置函数[b]COUNT()[/b]（区分大小写）来计算关系中的元组数。使用GroupAll运算符将关系[b]student_details[/b]分组，并将结果存储在名为student_group_all的关系中，如下所示。
grunt>student_group_all=Groupstudent_detailsAll;
它将产生如下所示的关系。
grunt>Dumpstudent_group_all;
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Kolkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89)})
现在让我们计算关系中的元组/记录的数量。
grunt>student_count=foreachstudent_group_allGenerateCOUNT(student_details.gpa);
验证
使用[b]DUMP[/b]运算符验证关系[b]student_count[/b]，如下所示。
grunt>Dumpstudent_count;
输出
它将产生以下输出，显示关系student_count的内容。
8
ApachePigCOUNT_STAR()函数
PigLatin的[b]COUNT_STAR()[/b]函数与[b]COUNT()[/b]函数类似。它用于获取包中的元素数量。在计数元素时，[b]COUNT_STAR()[/b]函数包含NULL值。注意·要获取全局计数值（包中的元组总数），我们需要执行GroupAll操作，并使用COUNT_STAR()函数计算count_star值。··要获取组的计数值（组中的元组数），我们需要使用[b]GroupBy[/b]运算符对其进行分组，然后继续使用count_star函数。·
语法
下面给出了[b]COUNT_STAR()[/b]函数的语法。
grunt>COUNT_STAR(expression)
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示，此文件包含空记录。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray,gpa:int);
计算元组数
我们可以使用内置函数[b]COUNT_STAR()[/b]来计算关系中的元组数。让我们使用GroupAll运算符将关系[b]student_details[/b]分组，并将结果存储在名为student_group_all的关系中，如下所示。
grunt>student_group_all=Groupstudent_detailsAll;
它将产生如下所示的关系。
grunt>Dumpstudent_group_all;
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Kolkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89),
(,,,,,,)})
现在让我们计算关系中的元组/记录的数量。
grunt>student_count=foreachstudent_group_allGenerateCOUNT_STAR(student_details.gpa);
验证
使用[b]DUMP[/b]运算符验证关系[b]student_count[/b]，如下所示。
grunt>Dumpstudent_count;
输出
它将产生以下输出，显示关系[b]student_count[/b]的内容。
9
因为我们使用了函数[b]COUNT_STAR()[/b]，它包含了null元组并返回9。
ApachePigDIFF()函数
PigLatin的[b]DIFF()[/b]函数用于比较元组中的两个包（字段）。它需要一个元组的两个字段作为输入并匹配它们。如果它们匹配，则返回一个空包。如果它们不匹配，它将找到存在于一个字段（包）中而在另一个字段中找不到的元素，并通过将它们打包进包中来返回这些元素。
语法
下面给出了[b]DIFF()[/b]函数的语法。
grunt>DIFF(expression,expression)
例
通常，[b]DIFF()[/b]函数比较元组中的两个包。下面是它的例子，这里我们创建两个关系，将它们cogroup，并计算它们之间的差异。假设在HDFS目录/pig_data/中有两个文件，即[b]emp_sales.txt[/b]和[b]emp_bonus.txt[/b]，如下所示。emp_sales.txt包含销售部门员工的详细信息，[b]emp_bonus.txt[/b]包含获得奖金的员工详细信息。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'USINGPigStorage(',')
as(sno:int,name:chararray,age:int,salary:int,dept:chararray);
grunt>emp_bonus=LOAD'hdfs://localhost:9000/pig_data/emp_bonus.txt'USINGPigStorage(',')
as(sno:int,name:chararray,age:int,salary:int,dept:chararray);
使用COGROUP运算符和键[b]sno，[/b]将关系[b]emp_sales[/b]和[b]emp_bonus[/b]的记录/元组分组，如下所示。
grunt>cogroup_data=COGROUPemp_salesbysno,emp_bonusbysno;
使用[b]DUMP[/b]运算符验证关系[b]cogroup_data[/b]，如下所示。
grunt>Dumpcogroup_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)})
计算两个关系之间的差异
现在让我们使用[b]DIFF()[/b]函数计算两个关系之间的差异，并将其存储在关系[b]diff_data[/b]中，如下所示。
grunt>diff_data=FOREACHcogroup_dataGENERATEDIFF(emp_sales,emp_bonus);
验证
使用DUMP运算符验证关系[b]diff_data[/b]，如下所示。
grunt>Dumpdiff_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)})
如果[b]emp_bonus[/b]和[b]emp_sales[/b]中的记录匹配，则[b]diff_data[/b]关系将是空元组。在其他情况下，它将保存来自两个关系（不同的元组）的元组。例如，如果将[b]sno[/b]的记录视为[b]1[/b]，那么会发现它们在两个关系中都是相同的((1，Robin，22,25000，sales),(1，Robin，22,25000，sales))。因此，在[b]diff_data[/b]关系中，将为[b]sno1[/b]得到一个空元组，它是DIFF()函数的结果。
ApachePigIsEmpty()函数
PigLatin的[b]IsEmpty()[/b]函数用于检查包或映射是否为空。
语法
下面给出了[b]IsEmpty()[/b]函数的语法。
grunt>IsEmpty(expression)
例
假设在HDFS目录[b]/pig_data/[/b]中有两个文件，即[b]emp_sales.txt[/b]和[b]emp_bonus.txt[/b]，如下所示。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'USINGPigStorage(',')
as(sno:int,name:chararray,age:int,salary:int,dept:chararray);
grunt>emp_bonus=LOAD'hdfs://localhost:9000/pig_data/emp_bonus.txt'USINGPigStorage(',')
as(sno:int,name:chararray,age:int,salary:int,dept:chararray);
现在让我们使用[b]cogroup[/b]来分组[b]emp_sales[/b]和[b]emp_bonus[/b]关系的记录/运算符，如下所示。
grunt>cogroup_data=COGROUPemp_salesbyage,emp_bonusbyage;
使用[b]DUMP[/b]运算符验证关系[b]cogroup_data[/b]，如下所示。
grunt>Dumpcogroup_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的元组，则它返回一个空包。
获得有空包的组
让我们使用[b]IsEmpty()[/b]函数从组中的[b]emp_sales[/b]关系中列出这些空包。
grunt>isempty_data=filtercogroup_databyIsEmpty(emp_sales);
验证
使用DUMP运算符验证关系[b]isempty_data[/b]，如下所示。emp_sales关系保存了[b]emp_bonus[/b]关系中不存在的元组。
grunt>Dumpisempty_data;
(30,{},{(6,Omar,30,30000,admin)})
ApachePigMAX()函数
PigLatin的[b]MAX()[/b]函数用于计算单列包中的列（数值或字符）的最大值。在计算最大值时，[b]Max（）[/b]函数会忽略NULL值。注意-·要获取全局最大值，我们需要执行GroupAll操作，并使用MAX()函数计算最大值。··要获取组的最大值，我们需要使用GroupBy运算符对其进行分组，然后继续执行Max()函数。·
语法
下面给出了[b]Max()[/b]函数的语法。
grunt>Max(expression)
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray,gpa:int);
计算最大值GPA
我们可以使用内置函数[b]MAX()[/b]（区分大小写）从一组给定的数值计算最大值。让我们使用GroupAll运算符将关系[b]student_details[/b]分组，并将结果存储在名为[b]student_group_all[/b]的关系中，如下所示。
grunt>student_group_all=Groupstudent_detailsAll;
这将产生如下所示的关系。
grunt>Dumpstudent_group_all;
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Kolkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89)})
现在使用[b]MAX()[/b]函数计算GPA的全局最大值，即所有学生的GPA值中的最大值，如下所示。
grunt>student_gpa_max=foreachstudent_group_allGenerate
(student_details.firstname,student_details.gpa),MAX(student_details.gpa);
验证
使用[b]DUMP[/b]运算子验证关系[b]student_gpa_max[/b]，如下所示。
grunt>Dumpstudent_gpa_max;
输出
它将产生以下输出，显示关系[b]student_gpa_max[/b]的内容。
(({(Bharathi),(Komal),(Archana),(Trupthi),(Preethi),(Rajesh),(siddarth),(Rajiv)},
{(72),(83),(87),(75),(93),(90),(78),(89)}),93)
ApachePigMIN()函数
PigLatin的[b]MIN()[/b]函数用于获取单列包中某列的最小值（最低值）（数字或字符）。在计算最小值时，[b]MIN()[/b]函数会忽略NULL值。注意·要获得全局最小值，我们需要执行GroupAll操作，并使用MIN()函数计算最小值。··要获取组的最小值，我们需要使用[b]GroupBy[/b]运算符对其进行分组，然后继续执行Min()函数。·
语法
下面给出了[b]MIN()[/b]函数的语法。
grunt>MIN(expression)
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray,gpa:int);
计算最小值GPA
我们可以使用内置函数[b]MIN()[/b]（区分大小写）从一组给定的数值计算最小值。让我们使用GroupAll运算符将关系[b]student_details[/b]分组，并将结果存储在名为[b]student_group_all[/b]的关系中，如下所示
grunt>student_group_all=Groupstudent_detailsAll;
它将产生如下所示的关系。
grunt>Dumpstudent_group_all;
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai,72),
(7,Komal,Nayak,24,9848022334,trivendram,83),
(6,Archana,Mishra,23,9848022335,Chennai,87),
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar,75),
(4,Preethi,Agarwal,21,9848022330,Pune,93),
(3,Rajesh,Khanna,22,9848022339,Delhi,90),
(2,siddarth,Battacharya,22,9848022338,Kolkata,78),
(1,Rajiv,Reddy,21,9848022337,Hyderabad,89)})
现在让我们使用[b]MIN()[/b]函数计算GPA的全局最小值，即所有学生的GPA值中的最小值，如下所示。
grunt>student_gpa_min=foreachstudent_group_allGenerate
(student_details.firstname,student_details.gpa),MIN(student_details.gpa);
验证
使用[b]DUMP[/b]运算子验证关系[b]student_gpa_min[/b]，如下所示。
grunt>Dumpstudent_gpa_min;
输出
它将产生以下输出，显示关系[b]student_gpa_min[/b]的内容。
(({(Bharathi),(Komal),(Archana),(Trupthi),(Preethi),(Rajesh),(siddarth),(Rajiv)},
{(72),(83),(87),(75),(93),(90),(78),(89)}),72)
ApachePigSIZE()函数
PigLatin的[b]SIZE()[/b]函数用于基于任何Pig数据类型计算元素的数量。
语法
下面给出了[b]SIZE()[/b]函数的语法。
grunt>SIZE(expression)
返回值根据ApachePig中的数据类型而有所不同。
数据类型值
int，long，float，double对于所有这些类型，size()函数返回1。
Chararray对于char数组，size()函数返回数组中的字符数。
Bytearray对于bytearray，size()函数返回数组中的字节数。
Tuple对于元组，size()函数返回元组中的字段数。
Bag对于包，size()函数返回包中的元组数。
Map对于映射，size()函数返回映射中键/值对的数量。
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]employee.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,name:chararray,workdate:chararray,daily_typing_pages:int);
计算类型的大小
要计算特定列的类型大小，可以使用[b]SIZE()[/b]函数。让我们计算name类型的大小，如下所示。
grunt>size=FOREACHemployee_dataGENERATESIZE(name);
验证
使用[b]DUMP[/b]运算符验证关系[b]size[/b]，如下所示。
grunt>Dumpsize;
输出
它将产生以下输出，显示关系[b]size[/b]的内容如下。在示例中，我们计算了[b]name[/b]列的大小。由于它是varchar类型，因此[b]SIZE()[/b]函数给出每个员工姓名中的字符数。
(4)
(3)
(4)
(4)
(4)
(4)
(4)
ApachePigPluckTuple()函数
在执行join之类的操作以区分两个模式的列之后，我们使用函数[b]PluckTuple()[/b]。要使用此函数，首先，我们必须定义一个字符串Prefix，并且我们必须对以该prefix开头的关系中的列进行过滤。
语法
下面给出了[b]PluckTuple()[/b]函数的语法。
DEFINEpluckPluckTuple(expression1)
DEFINEpluckPluckTuple(expression1,expression3)
pluck(expression2)
例
假设在HDFS目录[b]/pig_data/[/b]中有两个文件，分别是[b]emp_sales.txt[/b]和[b]emp_bonus.txt[/b]。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'USINGPigStorage(',')
as(sno:int,name:chararray,age:int,salary:int,dept:chararray);
grunt>emp_bonus=LOAD'hdfs://localhost:9000/pig_data/emp_bonus.txt'USINGPigStorage(',')
as(sno:int,name:chararray,age:int,salary:int,dept:chararray);
使用[b]join[/b]运算符连接这两个关系，如下所示。
grunt>join_data=joinemp_salesbysno,emp_bonusbysno;
使用Dump运算符验证关系[b]join_data[/b]。
grunt>Dumpjoin_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()函数
现在，使用[b]PluckTupe()[/b]函数定义要用来区分列的必需表达式。
grunt>DEFINEpluckPluckTuple('a::');
过滤[b]join_data[/b]关系中的列，如下所示。
grunt>data=foreachjoin_datagenerateFLATTEN(pluck(*));
描述名为[b]data[/b]的关系，如下所示。
grunt>Describedata;
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::"，因此[b]emp_sales[/b]模式的列将被作为[b]emp_sales::columnname[/b]，emp_bonus模式的列将被作为emp_bonus::columnname
ApachePigSUBTRACT()函数
PigLatin的[b]SUBTRACT()[/b]函数用于两个包相减，它需要两个包作为输入，并返回包含第一个包中不在第二个包中的元组的包。
语法
下面给出了[b]SUBTRACT()[/b]函数的语法。
grunt>SUBTRACT(expression,expression)
例
假设在HDFS目录[b]/pig_data/[/b]中有两个文件，即[b]emp_sales.txt[/b]和[b]emp_bonus.txt[/b]，如下所示。emp_sales.txt包含销售部门员工的详细信息，[b]emp_bonus.txt[/b]包含获得奖金的员工详细信息。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'USINGPigStorage(',')
as(sno:int,name:chararray,age:int,salary:int,dept:chararray);
grunt>emp_bonus=LOAD'hdfs://localhost:9000/pig_data/emp_bonus.txt'USINGPigStorage(',')
as(sno:int,name:chararray,age:int,salary:int,dept:chararray);
现在，让我们使用COGROUP运算符将关系[b]emp_sales[/b]和[b]emp_bonus[/b]的记录/元组与键[b]sno[/b]分组，如下所示。
grunt>cogroup_data=COGROUPemp_salesbysno,emp_bonusbysno;
使用[b]DUMP[/b]运算符验证关系[b]cogroup_data[/b]，如下所示。
grunt>Dumpcogroup_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)})
从一个关系中减去另一个关系
现在让我们从[b]emp_sales[/b]关系中减去[b]emp_bonus[/b]关系的元组。生成的关系保存[b]emp_sales[/b]中不在[b]emp_bonus[/b]中的元组。
grunt>sub_data=FOREACHcogroup_dataGENERATESUBTRACT(emp_sales,emp_bonus);
验证
使用DUMP运算符验证关系[b]sub_data[/b]，如下所示。emp_sales关系保存了[b]emp_bonus[/b]关系中不存在的元组。
grunt>Dumpsub_data;
({})
({(2,BOB,23,30000,sales)})
({})
({(4,Sara,25,40000,sales)})
({})
({(6,Maggy,22,35000,sales)})
以同样的方式，让我们从[b]emp_bonus[/b]关系中减去[b]emp_sales[/b]关系，如下所示。
grunt>sub_data=FOREACHcogroup_dataGENERATESUBTRACT(emp_bonus,emp_sales);
使用Dump运算符验证[b]sub_data[/b]关系的内容，如下所示。
grunt>Dumpsub_data;
({})
({(2,Jaya,23,20000,admin)})
({})
({(4,Alia,25,50000,admin)})
({})
({(6,Omar,30,30000,admin)})
ApachePigSUM()函数
可以使用PigLatin的[b]SUM()[/b]函数获取单列包中列的总数值。在计算总和时，[b]SUM()[/b]函数会忽略NULL值。注意·要获得全局总和，我们需要执行GroupAll操作，并使用SUM()函数计算总和值。··要获取组的总和，我们需要使用[b]GroupBy[/b]运算符对其进行分组，然后继续SUM()函数。·
语法
下面给出了[b]SUM()[/b]函数的语法。
grunt>SUM(expression)
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]employee.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,name:chararray,workdate:chararray,daily_typing_pages:int);
计算所有GPA的总和
让我们尝试计算每天输入的所有员工的总页数来演示SUM()函数。可以使用ApachePig的内置函数[b]SUM()[/b]（区分大小写）来计算数值的总和。让我们使用[b]GroupAll[/b]运算符将关系employee_data分组，并将结果存储在名为employee_group的关系中，如下所示。
grunt>employee_group=Groupemployee_dataall;
它将产生如下所示的关系。
grunt>Dumpemployee_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=foreachemployee_groupGenerate
(employee_data.name,employee_data.daily_typing_pages),SUM(employee_data.daily_typing_pages);
验证
使用[b]DUMP[/b]运算符验证关系[b]student_workpages_sum[/b]，如下所示。
grunt>Dumpstudent_workpages_sum;
输出
它将产生以下输出，显示关系[b]student_workpages_sum[/b]的内容如下。
(({(Zara),(Zara),(Jill),(Jack),(Jack),(Ram),(John)},
{(350),(300),(220),(100),(170),(220),(250)}),1610)
ApachePigTOKENIZE()函数
PigLatin的[b]TOKENIZE()[/b]函数用于在单个元组中分割字符串（其中包含一组字），并返回包含拆分操作输出的包。
语法
下面给出了[b]TOKENIZE()[/b]函数的语法。
grunt>TOKENIZE(expression[,'field_delimiter'])
作为[b]TOKENIZE()[/b]函数的分隔符，我们可以传递空格[]，双引号[“"]，逗号[,]，括号[()]，星号[*]。
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]student_details.txt[/b]的文件，如下所示。此文件包含学生的详细信息，如id，姓名，年龄和城市。如果我们仔细观察，学生的姓名包括用空格[]分隔的名字和姓氏。student_details.txt
001,RajivReddy,21,Hyderabad
002,siddarthBattacharya,22,Kolkata
003,RajeshKhanna,22,Delhi
004,PreethiAgarwal,21,Pune
005,TrupthiMohanthy,23,Bhuwaneshwar
006,ArchanaMishra,23,Chennai
007,KomalNayak,24,trivendram
008,BharathiNambiayar,24,Chennai
通过关系student_details将此文件加载到的Pig中，如下所示。
grunt>student_details=LOAD'hdfs://localhost:9000/pig_data/student_details.txt'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
拆分字符串
我们可以使用[b]TOKENIZE()[/b]函数拆分字符串。作为示例，让我们使用此函数分割名称，如下所示。
grunt>student_name_tokenize=foreachstudent_detailsGenerateTOKENIZE(name);
验证
使用[b]DUMP[/b]运算符验证关系[b]student_name_tokenize[/b]，如下所示。
grunt>Dumpstudent_name_tokenize;
输出
它将产生以下输出，显示关系[b]student_name_tokenize[/b]的内容如下。
({(Rajaiv),(Reddy)})
({(siddarth),(Battacharya)})
({(Rajesh),(Khanna)})
({(Preethi),(Agarwal)})
({(Trupthi),(Mohanthy)})
({(Archana),(Mishra)})
({(Komal),(Nayak)})
({(Bharathi),(Nambiayar)})
其他分隔符
以同样的方式，TOKENIZE（）函数接受空格[]，双引号[“"]，逗号[,]，括号[()]，星号[*]作为分隔符。
例
假设有一个名为[b]details.txt[/b]的文件，其中包含学生的详细信息，如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
现在，尝试使用TOKENIZE()分隔学生的名字和姓氏如下。
grunt>tokenize_data=foreachdetailsGenerateTOKENIZE(name);
在使用dump运算符验证[b]tokenize_data[/b]关系时，将获得以下结果。
grunt>Dumptokenize_data;
({(siddarth),(Battacharya)})
({(Rajesh),(Khanna)})
({(Preethi),(Agarwal)})
ApachePigPigStorage()函数
PigStorage()函数将数据加载并存储为结构化文本文件。它采用分隔符，使用它来将元组的每个实体分隔为一个参数。默认情况下，以'\t'作为参数。
语法
下面给出了[b]PigStorage()[/b]函数的语法。
grunt>PigStorage(field_delimiter)
例
假设在名为[b]/data/[/b]的HDFS目录中有一个名为[b]student_data.txt[/b]的文件，其中包含以下内容。
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'USINGPigStorage(',')
as(id:int,firstname:chararray,lastname:chararray,phone:chararray,city:chararray);
在上面的例子中，我们已经看到过使用逗号（','）分隔符。因此，我们使用（,）分隔了记录的值。同样，我们可以使用[b]PigStorage()[/b]函数将数据存储到HDFS目录中，如下所示。
grunt>STOREstudentINTO'hdfs://localhost:9000/pig_Output/'USINGPigStorage(',');
这将把数据存储到给定的目录中。可以按如下所示验证数据。
验证
你可以如下所示验证存储的数据。首先，使用[b]ls[/b]命令列出名为[b]pig_output[/b]的目录中的文件，如下所示。
$hdfsdfs-ls'hdfs://localhost:9000/pig_Output/'
Found2items
rw-r--r-1Hadoopsupergroup02015-10-0513:03hdfs://localhost:9000/pig_Output/_SUCCESS
rw-r--r-1Hadoopsupergroup2242015-10-0513:03hdfs://localhost:9000/pig_Output/part-m-00000
可以观察到在执行[b]Store[/b]语句后创建了两个文件。然后，使用[b]cat[/b]命令，列出名为[b]part-m-00000[/b]的文件的内容，如下所示。
$hdfsdfs-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
ApachePigTextLoader()函数
PigLatin函数[b]TextLoader()[/b]是一个Load函数，用于以UTF-8格式加载非结构化数据。
语法
下面给出了[b]TextLoader()[/b]函数的语法。
grunt>TextLoader()
例
假设在名为[b]/data/[/b]的HDFS目录中有一个名为[b]stu_data.txt[/b]的文件，如下所示。
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
现在让我们使用[b]TextLoader()[/b]函数加载上述文件。
grunt>details=LOAD'hdfs://localhost:9000/pig_data/stu_data.txt'USINGTextLoader();
你可以使用Dump运算符验证加载的数据。
grunt>dumpdetails;
(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)
ApachePigBinStorage()函数
BinStorage()函数使用机器可读格式将数据加载并存储到Pig中。Pig中的[b]BinStorge()[/b]通常用于存储MapReduce作业之间生成的临时数据，它支持多个位置作为输入。
语法
下面给出了[b]BinStorage()[/b]函数的语法。
grunt>BinStorage();
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]stu_data.txt[/b]的文件，如下所示。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'USINGPigStorage(',')
as(id:int,firstname:chararray,age:int,city:chararray);
现在，我们可以使用[b]BinStorage()[/b]函数将此关系存储到名为[b]/pig_data/[/b]的HDFS目录中。
grunt>STOREstudent_detailsINTO'hdfs://localhost:9000/pig_Output/mydata'USINGBinStorage();
执行上述语句后，关系存储在给定的HDFS目录中。你可以使用HDFSls命令查看它，如下所示。
$hdfsdfs-lshdfs://localhost:9000/pig_Output/mydata/
Found2items
-rw-r--r--1Hadoopsupergroup02015-10-2616:58
hdfs://localhost:9000/pig_Output/mydata/_SUCCESS
-rw-r--r--1Hadoopsupergroup3722015-10-2616:58
hdfs://localhost:9000/pig_Output/mydata/part-m-00000
现在，从文件[b]part-m-00000[/b]加载数据。
grunt>result=LOAD'hdfs://localhost:9000/pig_Output/b/part-m-00000'USINGBinStorage();
验证关系的内容如下所示
grunt>Dumpresult;
(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)
ApachePig压缩数据处理
我们可以使用函数[b]BinStorage()[/b]和[b]TextLoader()[/b]在ApachePig中加载和存储压缩数据。
例
假设在HDFS目录[b]/pigdata/[/b]中有一个名为[b]employee.txt.zip[/b]的文件。然后，我们可以将压缩文件加载到pig，如下所示。
UsingPigStorage:
grunt>data=LOAD'hdfs://localhost:9000/pig_data/employee.txt.zip'USINGPigStorage(',');
UsingTextLoader:
grunt>data=LOAD'hdfs://localhost:9000/pig_data/employee.txt.zip'USINGTextLoader;
同样，我们可以将压缩文件存储在pig中，如下所示。
UsingPigStorage:
grunt>storedataINTO'hdfs://localhost:9000/pig_Output/data.bz'USINGPigStorage(',');
ApachePigTOBAG()函数
PigLatin的[b]TOBAG()[/b]函数将一个或多个表达式转换为单个元组，这些元组被放在一个包里。
语法
下面给出了[b]TOBAG()[/b]函数的语法。
TOBAG(expression[,expression...])
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]employee_details.txt[/b]的文件，其中包含以下内容。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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
现在让我们将每个员工（记录）的id，姓名，年龄和城市转换为一个元组，如下所示。
tobag=FOREACHemp_dataGENERATETOBAG(id,name,age,city);
验证
可以使用Dump运算符验证[b]tobag[/b]关系的内容，如下所示。
grunt>DUMPtobag;
({(1),(Robin),(22),(newyork)})
({(2),(BOB),(23),(Kolkata)})
({(3),(Maya),(23),(Tokyo)})
({(4),(Sara),(25),(London)})
({(5),(David),(23),(Bhuwaneshwar)})
({(6),(Maggy),(22),(Chennai)})
ApachePigTOP()函数
PigLatin的[b]TOP()[/b]函数用于获取包的顶部[b]N[/b]个元组。对于这个函数，作为输入，我们必须传递一个关系，我们想要的元组的数量，以及其值被比较的列名。此函数将返回包含所需列的包。
语法
下面给出了函数[b]TOP()[/b]的语法。
grunt>TOP(topN,column,relation)
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]employee_details.txt[/b]的文件，其中包含以下内容。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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
按年龄对关系[b]emp_data[/b]进行分组，并将其存储在关系[b]emp_group[/b]中。
grunt>emp_group=Groupemp_dataBYage;
使用Dump运算符验证关系[b]emp_group[/b]，如下所示。
grunt>Dumpemp_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=FOREACHemp_group{
top=TOP(2,0,emp_data);
GENERATEtop;
}
在这个例子中，我们正在检索具有较大id的组的前2个元组。由于我们基于[b]id[/b]检索前2个元组，我们将列名id的索引作为TOP()函数的第二个参数传递。
验证
使用Dump运算符验证[b]data_top[/b]关系的内容，如下所示。
grunt>Dumpdata_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)})
ApachePigTOTUPLE()函数
TOTUPLE()函数用于将一个或多个表达式转换为数据类型[b]tuple[/b]。
语法
下面给出了[b]TOTUPLE()[/b]函数的语法。
grunt>TOTUPLE(expression[,expression...])
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]employee_details.txt[/b]的文件，其中包含以下内容。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
通过使用关系名称[b]emp_data[/b]将此文件加载到Pig中，如下所示。
grunt>emp_data=LOAD'hdfs://localhost:9000/pig_data/employee_details.txt'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
现在让我们将每个学生的id，名字和年龄（记录）转换成一个元组。
grunt>totuple=FOREACHemp_dataGENERATETOTUPLE(id,name,age);
验证
你可以使用Dump运算符验证[b]totuple[/b]模式的内容，如下所示。
grunt>DUMPtotuple;
((1,Robin,22))
((2,BOB,23))
((3,Maya,23))
((4,Sara,25))
((5,David,23))
((6,Maggy,22))
ApachePigTOMAP()函数
PigLatin的[b]TOMAP()[/b]函数用于将key-value对转换为Map。
语法
下面给出了[b]TOMAP()[/b]函数的语法。
grunt>TOMAP(key-expression,value-expression[,key-expression,valueexpression...])
例
假设在HDFS目录[b]/pig_data/[/b]中有一个名为[b]employee_details.txt[/b]的文件，其中包含以下内容。employee_details.txt
001,Robin20000,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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
现在让我们将每个记录的名称和年龄作为key-value对，并将它们转换为map，如下所示。
grunt>tomap=FOREACHemp_dataGENERATETOMAP(name,age);
验证
您可以使用Dump运算符验证[b]tomap[/b]关系的内容，如下所示。
grunt>DUMPtomap;
([Robin#22])
([BOB#23])
([Maya#23])
([Sara#25])
([David#23])
([Maggy#22])
ApachePigENDSWITH()函数
此函数接受两个String参数，它用于验证第一个字符串是否以第二个字符串结尾。
语法
grunt>ENDSWITH(string1,string2)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，例如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
以下是[b]ENDSWITH()[/b]函数的示例，在本示例中，我们在验证每个员工的姓名是否以字符[b]n[/b]结束。
grunt>emp_endswith=FOREACHemp_dataGENERATE(id,name),ENDSWITH(name,'n');
上述语句验证员工姓名是否以字母n结束。由于[b]Saran[/b]和[b]Robin[/b]的这两个元组的以字母n结束，所以[b]ENDSWITH()[/b]函数返回布尔值'true'，对于剩余的元组的值为'false'。语句的结果将存储在名为[b]emp_endswith[/b]的关系中。使用Dump运算符验证关系[b]emp_endswith[/b]的内容，如下所示。
grunt>Dumpemp_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)
ApachePigSTARTSWITH()函数
此函数接受两个字符串参数。它验证第一个字符串是否以第二个开头。
语法
下面给出了[b]STARTSWITH()[/b]函数的语法。
grunt>STARTSWITH(string,substring)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
例
以下是[b]STARTSWITH()[/b]函数的示例。在此示例中，我们验证所有员工的姓名是否以子字符串“Ro"开头。
grunt>startswith_data=FOREACHemp_dataGENERATE(id,name),STARTSWITH(name,’Ro’);
如果任何这些名称以字符串'Ro'开头，上述语句将解析所有员工的名称。因为员工姓名'Robin'和'Robert'这两个元组以子串'Ro'开头，所以STARTSWITH()函数返回布尔值'true'，剩余的元组的值将为'false'。语句的结果将存储在名为[b]startswith_data[/b]的关系中。使用Dump运算符验证关系[b]startswith_data[/b]的内容，如下所示。
grunt>Dumpstartswith_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)
ApachePigSUBSTRING()函数
此函数从给定字符串返回一个子字符串。
语法
下面给出了[b]SUBSTRING()[/b]函数的语法。这个函数接受三个参数，一个是我们想要的字符串的列名，另外两个是所需子串的开始和停止索引。
grunt>SUBSTRING(string,startIndex,stopIndex)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，例如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'USINGPigStorage(',')as(id:int,name:chararray,age:int,city:chararray);
以下是[b]SUBSTRING()[/b]函数的示例。此示例获取以0th字母开头并以2nd字母结尾的员工姓名。
grunt>substring_data=FOREACHemp_dataGENERATE(id,name),SUBSTRING(name,0,2);
上述语句从员工的姓名中提取所需的子字符串。语句的结果将存储在名为[b]substring_data[/b]的关系中。使用Dump运算符验证关系[b]substring_data[/b]的内容，如下所示。
grunt>Dumpsubstring_data;
((1,Robin),Rob)
((2,Stacy),Sta)
((3,Kelly),Kel)
ApachePigEqualsIgnoreCase()函数
EqualsIgnoreCase()函数用于比较两个字符串并验证它们是否相等。如果两者相等，则此函数返回布尔值[b]true[/b]，否则返回值[b]false[/b]。
语法
下面给出了函数[b]EqualsIgnoreCase()[/b]的语法
grunt>EqualsIgnoreCase(string1,string2)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，例如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
下面给出了[b]EqualsIgnoreCase()[/b]函数的示例。在本示例中，我们将每个员工的姓名与字符串值'Robin'进行比较。
grunt>equals_data=FOREACHemp_dataGENERATE(id,name),EqualsIgnoreCase(name,'Robin');
上面的语句将字符串“Robin"（不区分大小写）与员工的姓名进行比较，如果值匹配则返回[b]true[/b]否则返回[b]false[/b]。简而言之，此语句搜索名为'Robin'的员工记录。语句的结果将存储在名为[b]equals_data[/b]的关系中。使用Dump运算符验证关系[b]equals_data[/b]的内容，如下所示。
grunt>Dumpequals_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)
ApachePigINDEXOF()函数
INDEXOF()函数接受字符串值，字符和索引（整数）。它返回字符串中第一个出现的给定的字符，从开始索引向前搜索。
语法
下面给出了[b]INDEXOF()[/b]函数的语法。
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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
下面给出了[b]INDEXOF()[/b]函数的示例。在此示例中，我们使用此函数查找每个员工姓名中出现的字母'r'。
grunt>indexof_data=FOREACHemp_dataGENERATE(id,name),INDEXOF(name,'r',0);
上述语句解析每个员工的姓名，并返回第一个字母为'r'的索引值。如果名称不包含字母'r'，则返回值-1。语句的结果将存储在名为indexof_data的关系中。使用Dump运算符验证关系indexof_data的内容，如下所示。
grunt>Dumpindexof_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)
ApachePigLAST_INDEX_OF()函数
LAST_INDEX_OF()函数接受字符串值和字符。它返回字符串中给定字符最后一次出现的值，从字符串的结尾向后搜索。
语法
下面给出了[b]LAST_INDEX_OF()[/b]函数的语法
grunt>LAST_INDEX_OF(string,'character')
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
下面给出了[b]LAST_INDEX_OF()[/b]函数的示例。在这个例子中，我们将从每个员工的名字中找到字母'g'的出现。
grunt>last_index_data=FOREACHemp_dataGENERATE(id,name),LAST_INDEX_OF(name,'g');
上述语句从结尾解析每个员工的姓名，并返回第一次发现字母'g'的索引值。如果名称不包含字母'g'，则返回值[b]-1[/b]。语句的结果将存储在名为[b]last_index_data[/b]的关系中。使用Dump运算符验证关系[b]last_index_data[/b]的内容，如下所示。
grunt>Dumplast_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)
ApachePigLCFIRST()函数
此函数用于将给定字符串的第一个字符转换为小写。
语法
以下是[b]LCFIRST()[/b]函数的语法。
grunt>LCFIRST(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
下面给出了[b]LCFIRST()[/b]函数的示例。在此示例中，我们将所有员工姓名的第一个字母转换为小写。
grunt>Lcfirst_data=FOREACHemp_dataGENERATE(id,name),LCFIRST(name);
语句的结果将存储在名为[b]Lcfirst_data[/b]的关系中。使用Dump运算符验证关系[b]Lcfirst_data[/b]的内容，如下所示。
grunt>DumpLcfirst_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)
ApachePigUPPER()函数
此函数用于将字符串中的所有字符转换为大写。
语法
UPPER()函数的语法如下
grunt>UPPER(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件。此文件包含员工详细信息，如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
下面给出了[b]UPPER()[/b]函数的示例。在此示例中，我们已将所有员工的姓名转换为大写。
grunt>upper_data=FOREACHemp_dataGENERATE(id,name),UPPER(name);
上述语句将所有员工的名称转换为大写并返回结果。语句的结果将存储在名为[b]upper_data[/b]的关系中。使用Dump运算符验证关系[b]upper_data[/b]的内容，如下所示。
grunt>Dumpupper_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)
ApachePigLOWER()函数
此函数用于将字符串中的所有字符转换为小写。
语法
以下是[b]LOWER()[/b]函数的语法。
grunt>LOWER(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
下面给出了[b]LOWER()[/b]函数的示例。在此示例中，我们将所有员工的姓名转换为小写。
grunt>lower_data=FOREACHemp_dataGENERATE(id,name),LOWER(name);
上述语句将所有员工的姓名转换为小写并返回结果。语句的结果将存储在名为[b]lower_data[/b]的关系中。使用Dump运算符验证关系[b]lower_data[/b]的内容。
grunt>Dumplower_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)
ApachePigREPLACE()函数
此函数用于将给定字符串中的所有字符替换为新字符。
语法
下面给出了[b]REPLACE()[/b]函数的语法。该函数接受三个参数，即：·string-要替换的字符串。如果我们想替换关系中的字符串，我们必须传递字符串所属的列名。··regEXP-这里我们必须传递要替换的字符串/正则表达式。··newChar-这里我们必须传递字符串的新值。·
grunt>REPLACE(string,'regExp','newChar');
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
以下是[b]REPLACE()[/b]函数的示例。在此示例中，我们使用缩写形式[b]Bhuw[/b]替换了城市[b]Bhuwaneshwar[/b]的名称。
grunt>replace_data=FOREACHemp_dataGENERATE(id,city),REPLACE(city,'Bhuwaneshwar','Bhuw');
上述语句在[b]emp_data[/b]关系中使用'Bhuw'字符串替换[b]city[/b]中的'Bhuwaneshwar'并返回结果。此结果存储在名为[b]replace_data[/b]的关系中。使用Dump运算符验证关系[b]replace_data[/b]的内容，如下所示。
grunt>Dumpreplace_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)
ApachePigSTRSPLIT()函数
此函数用于通过给定的分隔符拆分给定的字符串。
语法
STRSPLIT()的语法如下。此函数接受需要拆分的字符串，正则表达式和指定限制的整数值（字符串应该拆分的子字符串数）。当遇到给定的正则表达式时，此函数解析字符串，它会将字符串拆分为[b]n[/b]个子字符串，其中[b]n[/b]将传递给limit。
grunt>STRSPLIT(string,regex,limit)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
以下是[b]STRSPLIT()[/b]函数的示例。如果你观察emp.txt文件，可以发现在[b]name[/b]列中，我们有由分隔符'_'分隔的员工的姓名和姓氏。在此示例中，我们尝试使用[b]STRSPLIT()[/b]函数拆分员工的姓名和姓氏。
grunt>strsplit_data=FOREACHemp_dataGENERATE(id,name),STRSPLIT(name,'_',2);
语句的结果将存储在名为strsplit_data的关系中。使用Dump运算符验证关系[b]strsplit_data[/b]的内容，如下所示。
grunt>Dumpstrsplit_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))
ApachePigSTRSPLITTOBAG()函数
此函数类似于[b]STRSPLIT()[/b]函数。它使用给定的分隔符分隔字符串，并将结果返回到包中。
语法
STRSPLITTOBAG()的语法如下。此函数接受需要拆分的字符串，正则表达式和指定限制的整数值（字符串应该拆分的子字符串数）。当遇到给定的正则表达式时，此函数解析字符串，它将该字符串拆分为[b]n[/b]个子字符串，其中[b]n[/b]将传递给limit。
grunt>STRSPLITTOBAG(string,regex,limit)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]emp.txt[/b]的文件，如下所示。此文件包含员工详细信息，如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'USINGPigStorage(',')
as(id:int,name:chararray,age:int,city:chararray);
以下是[b]STRSPLITTOBAG()[/b]函数的示例。如果你观察emp.txt文件，可以发现在[b]name[/b]列中，我们有由分隔符"_"分隔的员工的姓名和姓氏。在此示例中，我们尝试拆分员工的姓名和姓氏，并使用[b]STRSPLITTOBAG()[/b]函数在包中获取结果。
grunt>strsplittobag_data=FOREACHemp_dataGENERATE(id,name),STRSPLITTOBAG(name,'_',2);
语句的结果将存储在名为[b]strsplittobag_data[/b]的关系中。使用Dump运算符验证关系[b]strsplittobag_data[/b]的内容，如下所示。
grunt>Dumpstrsplittobag_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)})
ApachePigTRIM()函数
TRIM()函数接受字符串，并在删除它前端和尾部的空格后返回其副本。
语法
这是[b]TRIM()[/b]函数的语法。
grunt>TRIM(expression)
例
假设我们在[b]emp_data[/b]关系的记录中的员工姓名的前端和尾部有一些不必要的空格。
grunt>Dumpemp_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=FOREACHemp_dataGENERATE(id,name),TRIM(name);
上述语句通过从员工姓名中删除前端和尾部空格来返回姓名的副本。结果存储在名为[b]trim_data[/b]的关系中。使用Dump运算符验证关系[b]trim_data[/b]的结果，如下所示。
grunt>Dumptrim_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)
ApachePigLTRIM()函数
函数[b]LTRIM()[/b]与函数[b]TRIM()[/b]相同。它从给定字符串（标题空格）的左侧删除不需要的空格。
语法
这里是LTRIM()函数的语法。
grunt>LTRIM(expression)
例
假设在[b]emp_data[/b]关系的记录中的员工姓名之前和之后有一些不必要的空格。
grunt>Dumpemp_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)
使用[b]LTRIM()[/b]函数，我们可以从姓名中删除前端空格，如下所示。
grunt>ltrim_data=FOREACHemp_dataGENERATE(id,name),LTRIM(name);
上述语句通过从员工的姓名中删除前端空格来返回姓名的副本。结果存储在名为[b]ltrim_data[/b]的关联中。使用Dump运算符验证关系[b]ltrim_data[/b]的结果，如下所示。
grunt>Dumpltrim_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)
ApachePigRTRIM()函数
函数[b]RTRIM()[/b]与函数[b]TRIM()[/b]相同。它从给定字符串（尾部空格）的右侧删除不需要的空格。
语法
RTRIM()函数的语法如下
grunt>RTRIM(expression)
例
假设在[b]emp_data[/b]关系的记录中的员工姓名的之前和之后有一些不必要的空格，如下所示。
grunt>Dumpemp_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)
使用[b]RTRIM()[/b]函数，我们可以从姓名中删除尾部空格，如下所示
grunt>rtrim_data=FOREACHemp_dataGENERATE(id,name),RTRIM(name);
上述语句通过从员工姓名中删除尾部空格来返回姓名副本。结果存储在名为[b]rtrim_data[/b]的关系中。使用Dump运算符验证关系[b]rtrim_data[/b]的结果，如下所示。
grunt>Dumprtrim_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)
ApachePigToDate()函数
此函数用于根据给定的参数生成[b]DateTime[/b]对象。
语法
ToDate()函数的语法可以是以下任何一种:
grunt>ToDate(milliseconds)
grunt>ToDate(iosstring)
grunt>ToDate(userstring,format)
grunt>ToDate(userstring,format,timezone)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
以下是[b]ToDate()[/b]函数的示例。这里我们转换对应于每个员工的出生日期的DateTime对象。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime>);
语句的结果（每个员工的[b]DateTime[/b]对象）将存储在名为[b]todate_data[/b]的关系中。使用Dump运算符验证此关系的内容，如下所示。
grunt>Dumptodate_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)
ApachePigCurrentTime()函数
此函数用于生成当前时间的[b]DateTime[/b]对象。
语法
这是[b]CurrentTime()[/b]函数的语法。
grunt>CurrentTime()
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
以下是[b]CurrentTime()[/b]函数的示例。这里我们生成当前时间。
grunt>currenttime_data=foreachtodate_datagenerateCurrentTime();
语句的结果将存储在名为[b]currenttime_data[/b]的关系中。使用Dump操作符验证此关系的内容。
grunt>Dumpcurrenttime_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)
ApachePigGetDay()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前日期。
语法
这是[b]GetDay()[/b]函数的语法。
grunt>GetDay(datetime)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
以下是[b]GetDay()[/b]函数的示例。GetDay()函数将从给定的Date-Time对象中检索日期。因此，首先，让我们使用[b]todate()[/b]函数生成所有员工的日期时间对象，如下所示。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime);
grunt>Dumptodate_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()函数从出生日期中获取日期，并将它存储在名为[b]getday_data[/b]的关系中。
grunt>getday_data=foreachtodate_datagenerate(date_time),GetDay(date_time);
使用Dump运算符验证getday_data关系的内容。
grunt>Dumpgetday_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)
ApachePigGetHour()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前日期的当前小时。
语法
这是[b]GetHour()[/b]函数的语法。
grunt>GetHour(datetime)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
下面是[b]GetHour()[/b]函数的示例。GetHour()函数将从给定的Date-Time对象中检索一天中的小时。因此，首先，让我们使用[b]todate()[/b]函数生成所有员工的Date-Time对象。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime);
grunt>Dumptodate_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)
现在让我们使用[b]GetDay()[/b]函数从每个员工的出生时间开始计算小时，并将其存储在名为[b]gethour_data[/b]的关系中。
grunt>gethour_data=foreachtodate_datagenerate(date_time),GetHour(date_time);
现在使用Dump运算符验证[b]getday_data[/b]关系的内容，如下所示。
grunt>Dumpgethour_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)
ApachePigGetMilliSecond()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前秒的毫秒数。
语法
这是[b]GetMilliSecond（）[/b]函数的语法。
grunt>GetMilliSecond(datetime)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
下面是[b]GetMilliSecond()[/b]函数的示例。GetMilliSecond()函数将从给定的日期时间对象中检索当前秒的毫秒数。因此，首先，我们使用[b]todate()[/b]函数生成所有员工的日期时间对象，如下所示。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime);
grunt>Dumptodate_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)
现在，让我们使用[b]GetMilliSecond()[/b]函数从每个员工的出生时间开始计算毫秒数，并将其存储在名为[b]getmillisecond_data[/b]的关系中，如下所示。
grunt>getmillisecond_data=foreachtodate_datagenerate(date_time),GetMilliSecond(date_time);
现在使用Dump运算符验证[b]getmillisecond_data[/b]关系的内容，如下所示。
grunt>Dumpgetmillisecond_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)
ApachePigGetMinute()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前小时的分钟。
语法
这是[b]GetMinute()[/b]函数的语法。
grunt>GetMinute(datetime)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
以下是[b]GetMinute()[/b]函数的示例。GetMinute()函数将从给定的日期时间对象中检索小时的分钟。因此，首先，让我们使用[b]todate()[/b]函数生成所有员工的日期时间对象。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime);
grunt>Dumptodate_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)
现在，让我们使用[b]GetMinute()[/b]获得每个员工出生时间的分钟，并将其存储在名为[b]getminute_data[/b]的关系中，如下所示。
grunt>getminute_data=foreachtodate_datagenerate(date_time),GetMinute(date_time);
现在使用Dump运算符验证getminute_data关系的内容，如下所示。
grunt>Dumpgetminute_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)
ApachePigGetMonth()函数
此函数接受日期时间对象作为参数，并从给定的日期时间对象返回当前年份的当前月份。
语法
这是[b]GetMonth()[/b]函数的语法。
grunt>GetMonth(datetime)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
下面是[b]GetMonth()[/b]函数的示例。它将从给定的日期时间对象中检索当前月份。因此，首先，我们使用[b]todate()[/b]函数生成所有员工的日期时间对象，如下所示。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime);
grunt>Dumptodate_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)
现在让我们使用[b]GetMonth()[/b]函数从每个员工的出生日期开始计算月份，并将其存储在名为[b]getmonth_data[/b]的关系中。
grunt>getmonth_data=foreachtodate_datagenerate(date_time),GetMonth(date_time);
现在使用Dump运算符验证[b]getmonth_data[/b]关系的内容，如下所示。
grunt>Dumpgetmonth_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)
ApachePigGetSecond()函数
此函数接受日期时间对象作为参数，并返回给定日期时间对象的当前分钟的秒数。
语法
这是[b]GetSecond()[/b]函数的语法。
grunt>GetSecond(datetime)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
下面是[b]GetSecond()[/b]函数的示例。它从给定的日期时间对象中检索一分钟的秒数。因此，让我们使用[b]todate()[/b]函数生成所有员工的日期时间对象，如下所示。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime);
grunt>Dumptodate_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)
现在让我们使用[b]GetSecond()[/b]函数从每个员工的出生时间开始计算秒数，并将其存储在名为[b]getsecond_data[/b]的关系中，如下所示。
grunt>getsecond_data=foreachtodate_datagenerate(date_time),GetSecond(date_time);
使用Dump运算符验证[b]getsecond_data[/b]关系的内容，如下所示。
grunt>Dumpgetsecond_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)
ApachePigGetWeek()函数
此函数接受日期时间对象作为参数，并从给定的日期时间对象返回当前月份的当前周。
语法
这是[b]GetWeek()[/b]函数的语法。
grunt>GetWeek(datetime)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
下面是[b]GetWeek()[/b]函数的示例。它将从给定的日期时间对象中检索当前周。因此，让我们使用[b]todate()[/b]函数生成所有员工的日期时间对象，如下所示。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime);
grunt>Dumptodate_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)
现在，让我们使用[b]GetWeek()[/b]从每个员工的出生日期开始计算月份，并将其存储在名为[b]getweek_data[/b]的关系中。
grunt>getweek_data=foreachtodate_datagenerate(date_time),GetWeek(date_time);
使用Dump运算符验证[b]getweek_data[/b]关系的内容。
grunt>DumpgetWeek_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)
ApachePigGetWeekYear()函数
此函数接受日期时间对象作为参数，并从给定的日期时间对象返回当前的周年。
语法
这是[b]GetWeekYear()[/b]函数的语法。
grunt>GetWeekYear(datetime)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
以下是[b]GetWeekYear()[/b]函数的示例。它将从给定的日期时间对象中检索当前的周年。因此，让我们使用[b]todate()[/b]函数生成所有员工的日期时间对象，如下所示。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime);
grunt>Dumptodate_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)
使用[b]GetWeekYear()[/b]函数从每个员工的出生日期开始计算周年，并将其存储在名为[b]getweekyear_data[/b]的关系中，如下所示。
grunt>getweekyear_data=foreachtodate_datagenerate(date_time),GetWeekYear(date_time);
使用Dump运算符验证[b]getweekyear_data[/b]关系的内容。
grunt>Dumpgetweekyear_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)
ApachePigGetYear()函数
此函数接受日期时间对象作为参数，并从给定的日期时间对象返回当前的年份。
语法
这是[b]GetYear()[/b]函数的语法。
grunt>GetYear(datetime)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件，如下所示。此文件包含特定人员的出生日期的详细信息：id，日期和时间。date.txt
001,1989/09/2609:00:00
002,1980/06/2010:22:00
003,1990/12/1903:11:44
通过使用date_data关系将此文件加载到Pig中，如下所示。
grunt>date_data=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray);
以下是[b]GetYear()[/b]函数的示例。它将从给定的日期时间对象中检索当前年份。因此，首先，我们使用[b]todate()[/b]函数生成所有员工的日期时间对象，如下所示。
grunt>todate_data=foreachdate_datagenerateToDate(date,'yyyy/MM/ddHH:mm:ss')
as(date_time:DateTime);
grunt>Dumptodate_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)
现在，使用[b]GetYear()[/b]函数从每个员工的出生日期开始计算年份，并将其存储在名为[b]getyear_data[/b]的关系中。
grunt>getyear_data=foreachtodate_datagenerate(date_time),GetYear(date_time);
使用Dump运算符验证getyear_data关系的内容，如下所示。
grunt>Dumpgetyear_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)
ApachePigAddDuration()函数
此函数接受日期时间对象和持续时间对象，并将给定的持续时间添加到日期时间对象，并返回具有添加的持续时间的新的日期时间对象。
语法
这里是AddDuration()函数的语法。
grunt>AddDuration(datetime,duration)
注意：持续时间以ISO8601标准表示。根据ISO8601标准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秒。·
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件。此文件包含特定人员的出生日期的详细信息：id，日期和时间以及根据ISO8601标准的一段时间。date.txt
001,1989/09/2609:00:00,PT1M
002,1980/06/2010:22:00,P1Y
003,1990/12/1903:11:44,P3M
通过使用date_duration关系将此文件加载到Pig中，如下所示。
grunt>date_duration=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray,duration:chararray)
以下是[b]AddDuration()[/b]函数的示例。你可以使用此方法将某个持续时间添加到给定的日期时间对象，如下所示。
grunt>Add_duration_data=foreachdate_durationgenerate(date,duration),
AddDuration(ToDate(date,'yyyy/MM/ddHH:mm:ss'),duration);
语句的结果将存储在名为[b]add_duration_data[/b]的关系中。使用Dump运算符验证此关系的内容，如下所示。
grunt>Dumpadd_duration_data;
((1989/09/2609:00:00,PT1M),1989-09-26T09:01:00.000+05:30)
((1980/06/2010:22:00,P1Y),1981-06-20T10:22:00.000+05:30)
((1990/12/1903:11:44,P3M),1991-03-19T03:11:44.000+05:30)
ApachePigSubtractDuration()函数
此函数接受日期时间对象和持续时间对象，并从日期时间对象中减去给定的持续时间，返回新的日期时间对象。
语法
这是[b]SubtractDuration()[/b]函数的语法。
grunt>SubtractDuration(datetime,duration)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]date.txt[/b]的文件。此文件包含特定人员的出生日期的详细信息：id，日期和时间以及根据ISO8601标准的一些持续时间。date.txt
001,1989/09/2609:00:00,PT1M
002,1980/06/2010:22:00,P1Y
003,1990/12/1903:11:44,P3M
通过使用date_duration关系将此文件加载到Pig中，如下所示。
grunt>date_duration=LOAD'hdfs://localhost:9000/pig_data/date.txt'USINGPigStorage(',')
as(id:int,date:chararray,duration:chararray)
以下是[b]SubtractDuration()[/b]函数的示例。你可以使用此方法从给定的日期时间对象中减去某个持续时间，如下所示。
subtractduration_data=foreachdate_durationgenerate(date,duration),
SubtractDuration(ToDate(date,'yyyy/MM/ddHH:mm:ss'),duration);
语句的结果将存储在名为[b]subtractduration_data[/b]的关系中。使用Dump运算符验证此关系的内容，如下所示。
grunt>Dumpsubtractduration_data;
((1989/09/2609:00:00,PT1M),1989-09-26T08:59:00.000+05:30)
((1980/06/2010:22:00,P1Y),1979-06-20T10:22:00.000+05:30)
((1990/12/1903:11:44,P3M),1990-09-19T03:11:44.000+05:30)
ApachePigDaysBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的天数。
语法
这是[b]DaysBetween()[/b]函数的语法。
grunt>DaysBetween(datetime1,datetime2)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]doj_dob.txt[/b]的文件。此文件包含特定人员的出生日期和入职日期的详细信息：ID，出生日期和入职日期。doj_dob.txt
001,26/09/198909:00:00,16/01/201509:00:00
002,20/06/198010:22:00,10/08/201109:00:00
003,19/12/199003:11:44,25/10/201209:00:00
通过使用doj_dob_data关系将此文件加载到Pig中，如下所示。
doj_dob_data=LOAD'hdfs://localhost:9000/pig_data/doj_dob.txt'USINGPigStorage(',')
as(id:int,dob:chararray,doj:chararray);
现在使用[b]DaysBetween()[/b]函数计算员工的出生日期和入职日期之间的天数。
grunt>daysbetween_data=foreachdoj_dob_datagenerateDaysBetween(ToDate(doj,'dd/MM/yyyyHH:mm:ss'),
ToDate(dob,'dd/MM/yyyyHH:mm:ss'));
上述语句结果存储在名为[b]daysbetween_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpdaysbetween_data;
(9243)
(11372)
(7981)
ApachePigHoursBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的小时数。
语法
这是[b]HoursBetween()[/b]函数的语法。
grunt>HoursBetween(datetime1,datetime2)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]doj_dob.txt[/b]的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。doj_dob.txt
001,26/09/198909:00:00,16/01/201509:00:00
002,20/06/198010:22:00,10/08/201109:00:00
003,19/12/199003:11:44,25/10/201209:00:00
通过使用doj_dob_data关系将此文件加载到Pig中，如下所示。
doj_dob_data=LOAD'hdfs://localhost:9000/pig_data/doj_dob.txt'USINGPigStorage(',')
as(id:int,dob:chararray,doj:chararray);
现在使用[b]HoursBetween()[/b]函数计算员工出生日期和入职日期之间的小时数，如下所示。
hoursbetween_data=foreachdoj_dob_datagenerateHoursBetween(ToDate(doj,
'dd/MM/yyyyHH:mm:ss'),ToDate(dob,'dd/MM/yyyyHH:mm:ss'));
上述语句的结果存储在名为[b]hoursbetween_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>DumpHoursBetween;
(221832)
(272950)
(191549)
ApachePigMilliSecondsBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的毫秒数。
语法
这是[b]MilliSecondsBetween()[/b]函数的语法。
grunt>MilliSecondsBetween(datetime1,datetime2)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]doj_dob.txt[/b]的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。doj_dob.txt
001,26/09/198909:00:00,16/01/201509:00:00
002,20/06/198010:22:00,10/08/201109:00:00
003,19/12/199003:11:44,25/10/201209:00:00
通过使用doj_dob_data关系将此文件加载到Pig中，如下所示。
doj_doba_data=LOAD'hdfs://localhost:9000/pig_data/doj_dob.txt'USINGPigStorage(',')
as(id:int,dob:chararray,doj:chararray);
现在使用[b]MilliSecondsBetween()[/b]函数计算员工出生日期和入职日期之间的毫秒数，如下所示。
grunt>millisecondsbetween_data=foreachdoj_dob_datagenerate
MilliSecondsBetween(ToDate(doj,'dd/MM/yyyyHH:mm:ss'),ToDate(dob,'dd/MM/yyyyHH:mm:ss'));
上述语句结果将存储在名为[b]millisecondsbetween_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpmillisecondsbetween_data;
(798595200000)
(982622280000)
(689579296000)
ApachePigMinutesBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的分钟数。
语法
这是[b]MinutesBetween()[/b]函数的语法。
grunt>MinutesBetween(datetime1,datetime2)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]doj_dob.txt[/b]的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。doj_dob.txt
001,26/09/198909:00:00,16/01/201509:00:00
002,20/06/198010:22:00,10/08/201109:00:00
003,19/12/199003:11:44,25/10/201209:00:00
通过使用doj_dob_data关系将此文件加载到Pig中，如下所示。
doj_dob_data=LOAD'hdfs://localhost:9000/pig_data/doj_dob.txt'USINGPigStorage(',')
as(id:int,dob:chararray,doj:chararray);
现在，使用[b]MinutesBetween()[/b]函数计算员工出生日期和入职日期之间的分钟数，如下所示。
grunt>minutesbetween_data=foreachdoj_dob_datagenerate
MinutesBetween(ToDate(doj,'dd/MM/yyyyHH:mm:ss'),ToDate(dob,'dd/MM/yyyyHH:mm:ss'));
上述语句结果将存储在名为[b]minutesbetween_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpminutesbetween_data;
(13309920)
(16377038)
(11492988)
ApachePigMonthsBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的月数。
语法
这是[b]MonthsBetween()[/b]函数的语法。
grunt>MonthsBetween(datetime1,datetime2)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]doj_dob.txt[/b]的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。doj_dob.txt
001,26/09/198909:00:00,16/01/201509:00:00
002,20/06/198010:22:00,10/08/201109:00:00
003,19/12/199003:11:44,25/10/201209:00:00
通过使用doj_dob_data关系将此文件加载到Pig中，如下所示。
doj_dob_data=LOAD'hdfs://localhost:9000/pig_data/doj_dob.txt'USINGPigStorage(',')
as(id:int,dob:chararray,doj:chararray);
现在使用[b]MonthsBetween()[/b]函数计算员工出生日期和入职日期之间的分钟数，如下所示。
grunt>monthsbetween_data=foreachdoj_dob_datagenerate
MinutesBetween(ToDate(doj,'dd/MM/yyyyHH:mm:ss'),ToDate(dob,'dd/MM/yyyyHH:mm:ss'));
上述语句结果将存储在名为[b]monthsbetween_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpmonthsbetween;
(300)
(374)
(262)
ApachePigSecondsBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的秒数。
语法
这是[b]SecondsBetween()[/b]函数的语法。
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]doj_dob.txt[/b]的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。doj_dob.txt
001,26/09/198909:00:00,16/01/201509:00:00
002,20/06/198010:22:00,10/08/201109:00:00
003,19/12/199003:11:44,25/10/201209:00:00
通过使用doj_dob_data关系将此文件加载到Pig中，如下所示。
doj_dob_data=LOAD'hdfs://localhost:9000/pig_data/doj_dob.txt'USINGPigStorage(',')
as(id:int,dob:chararray,doj:chararray);
现在使用[b]SecondsBetween()[/b]函数计算员工出生日期和入职日期之间的秒数，如下所示。
secondsbetween_data=foreachdoj_dob_datagenerateSecondsBetween(ToDate(doj,
'dd/MM/yyyyHH:mm:ss'),ToDate(dob,'dd/MM/yyyyHH:mm:ss'));
上述语句结果将存储在名为[b]secondsbetween_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpsecondsbetween_data;
(798595200)
(982622280)
(689579296)
ApachePigWeeksBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的周数。
语法
这是[b]WeeksBetween()[/b]函数的语法。
grunt>WeeksBetween(datetime1,datetime2)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]doj_dob.txt[/b]的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和入职日期。doj_dob.txt
001,26/09/198909:00:00,16/01/201509:00:00
002,20/06/198010:22:00,10/08/201109:00:00
003,19/12/199003:11:44,25/10/201209:00:00
通过使用doj_dob_data关系将此文件加载到Pig中，如下所示。
grunt>doj_dob_data=LOAD'hdfs://localhost:9000/pig_data/doj_dob.txt'USINGPigStorage(',')
as(id:int,dob:chararray,doj:chararray);
现在使用[b]WeeksBetween()[/b]函数计算员工的出生日期和入职日期之间的周数，如下所示。
grunt>weeksbetween_data=foreachdoj_dob_datagenerateWeeksBetween(ToDate(doj,
'dd/MM/yyyyHH:mm:ss'),ToDate(dob,'dd/MM/yyyyHH:mm:ss'));
上述语句结果将存储在名为[b]weeksbetween_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpweeksbetween_data;
(1320)
(1624)
(1140)
ApachePigYearsBetween()函数
此函数接受两个日期时间对象，并计算两个给定日期时间对象之间的年数。
语法
这是[b]YearsBetween()[/b]函数的语法。
grunt>YearsBetween(datetime1,datetime2)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]doj_dob.txt[/b]的文件。此文件包含特定人员的出生日期和入职日期的详细信息：id，出生日期和加入日期。doj_dob.txt
001,26/09/198909:00:00,16/01/201509:00:00
002,20/06/198010:22:00,10/08/201109:00:00
003,19/12/199003:11:44,25/10/201209:00:00
通过使用doj_dob_data关系将此文件加载到Pig中，如下所示。
doj_dob_data=LOAD'hdfs://localhost:9000/pig_data/doj_dob.txt'USINGPigStorage(',')
as(id:int,dob:chararray,doj:chararray);
现在使用[b]YearsBetween()[/b]函数计算员工出生日期和入职日期之间的年数，如下所示。
grunt>yearsbetween_data=foreachdoj_dob_datagenerateYearsBetween(ToDate(doj,
'dd/MM/yyyyHH:mm:ss'),ToDate(dob,'dd/MM/yyyyHH:mm:ss'));
上述语句结果将存储在名为[b]yearsbetween_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpyearsbetween_data;
(25)
(31)
(21)
ApachePigABS()函数
PigLatin的[b]ABS()[/b]函数用于计算给定表达式的绝对值。
语法
这是[b]ABS()[/b]函数的语法。
grunt>ABS(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
使用[b]ABS()[/b]函数计算math.txt文件内容的绝对值，如下所示。
grunt>abs_data=foreachmath_datagenerate(data),ABS(data);
上述语句结果将存储在名为[b]abs_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpabs_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)
ApachePigACOS()函数
PigLatin的[b]ACOS()[/b]函数用于计算给定表达式的反余弦值。
语法
这是[b]ACOS()[/b]函数的语法。
grunt>ACOS(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]ACOS()[/b]函数计算math.txt文件内容的反余弦值，如下所示。
grunt>acos_data=foreachmath_datagenerate(data),ACOS(data);
上述语句结果将存储在名为[b]abs_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpacos_data;
(5.0,NaN)
(16.0,NaN)
(9.0,NaN)
(2.5,NaN)
(5.9,NaN)
(3.1,NaN)
ApachePigASIN()函数
ASIN()函数用于计算给定表达式的反正弦值。
语法
这里是[b]ASIN()[/b]函数的语法。
grunt>ASIN(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]ASIN()[/b]函数计算math.txt文件内容的反正弦值，如下所示。
grunt>asin_data=foreachmath_datagenerate(data),ASIN(data);
上面的语句结果将存储在名为[b]asin_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpasin_data;
(5.0,NaN)
(16.0,NaN)
(9.0,NaN)
(2.5,NaN)
(5.9,NaN)
(3.1,NaN)
ApachePigATAN()函数
PigLatin的[b]ATAN()[/b]函数用于计算给定表达式的反正切值。
语法
这是[b]ATAN()[/b]函数的语法。
grunt>ATAN(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]ATAN()[/b]函数计算math.txt文件内容的反正切值，如下所示。
grunt>atan_data=foreachmath_datagenerate(data),ATAN(data);
上面的语句结果将存储在名为[b]asin_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpatan_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)
ApachePigCBRT()函数
PigLatin的[b]CBRT()[/b]函数用于计算给定表达式的立方根。
语法
这是[b]CBRT()[/b]函数的语法。
grunt>CBRT(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]CBRT()[/b]函数计算math.txt文件内容的立方根值，如下所示。
grunt>cbrt_data=foreachmath_datagenerate(data),CBRT(data);
上面的语句结果将存储在名为[b]cbrt_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpcbrt_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)
ApachePigCEIL()函数
CECIL()函数用于计算向上取整为最接近整数的给定表达式的值（近1取整）。
语法
这是[b]CECIL()[/b]函数的语法。
grunt>CEIL(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]CEIL()[/b]函数计算math.txt文件内容的ceil值，如下所示。
grunt>ceil_data=foreachmath_datagenerate(data),CEIL(data);
上述语句结果将存储在名为[b]ceil_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpceil_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)
ApachePigCOS()函数
PigLatin的[b]COS()[/b]函数用于计算给定表达式的余弦值。
语法
这是[b]COS()[/b]函数的语法。
grunt>COS(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float)
现在，使用[b]COS()[/b]函数计算math.txt文件内容的余弦值，如下所示。
grunt>cos_data=foreachmath_datagenerate(data),COS(data);
上述语句结果将存储在名为[b]cos_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpcos_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)
ApachePigCOSH()函数
PigLatin的[b]COSH()[/b]函数用于计算给定表达式的双曲余弦值。
语法
这是[b]COSH()[/b]函数的语法。
grunt>COSH(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]COSH()[/b]函数计算math.txt文件内容的双曲余弦值，如下所示。
grunt>cosh_data=foreachmath_datagenerate(data),COSH(data);
上述语句结果将存储在名为[b]cosh_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpcosh_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)
ApachePigEXP()函数
PigLatin的[b]EXP()[/b]函数用于将欧拉数[b]e[/b]提升到[b]x[/b]（给定表达式）的大小，即指数。
语法
这是[b]EXP()[/b]函数的语法。
grunt>EXP(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。math.txt
5
16
9
2.5
5.9
3.1
通过使用math_data关系将此文件加载到Pig中，如下所示。
grunt>math_data=LOAD'hdfs://localhost:9001044f0/pig_data/math.txt'USINGPigStorage(',')
as(data:float);
现在使用[b]EXP()[/b]函数计算math.txt文件内容的指数值，如下所示。
grunt>exp_data=foreachmath_datagenerate(data),EXP(data);
上面的语句结果将存储在名为exp_data的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpexp_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)
ApachePigFLOOR()函数
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'USINGPigStorage(',')
as(data:float);
现在，使用[b]FLOOR()[/b]计算math.txt文件内容的四舍五入值，如下所示。
grunt>floor_data=foreachmath_datagenerate(data),FLOOR(data);
上述语句结果将存储在名为[b]floor_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpfloor_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)
ApachePigLOG()函数
PigLatin的[b]LOG()[/b]函数用于计算给定表达式的自然对数（基于e）值。
grunt>LOG(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]LOG()[/b]函数计算math.txt文件内容的对数值，如下所示。
grunt>log_data=foreachmath_datagenerate(data),LOG(data);
上述语句结果将存储在名为[b]log_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumplog_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)
ApachePigLOG10()函数
PigLatin的[b]LOG10()[/b]函数用于计算给定表达式的基于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'USINGPigStorage(',')
as(data:float);
现在使用[b]LOG10()[/b]函数计算math.txt文件内容的log10值，如下所示。
grunt>log_data=foreachmath_datagenerate(data),LOG10(data);
上述语句结果将存储在名为[b]log_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumplog10_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)
ApachePigRANDOM()函数
RANDOM()函数用于获取大于或等于0.0且小于1.0的伪随机数（double类型）。
grunt>RANDOM()
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]RANDOM()[/b]函数生成math.txt文件内容的随机值，如下所示。
grunt>random_data=foreachmath_datagenerate(data),RANDOM();
上述语句结果将存储在名为[b]random_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumprandom_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)
ApachePigROUND()函数
ROUND()函数用于获取四舍五入为整数（如果结果类型为float）或四舍五入为长整型（如果结果类型为double）的表达式的值。
grunt>ROUND()
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]ROUND()[/b]函数生成math.txt文件内容的舍入值，如下所示。
grunt>round_data=foreachmath_datagenerate(data),ROUND(data);
上述语句结果将存储在名为[b]round_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpround_data;
(5.0,5)
(16.0,16)
(9.0,9)
(2.5,3)
(5.9,6)
(3.1,3)
ApachePigSIN()函数
PigLatin的[b]SIN()[/b]函数用于计算给定表达式的正弦值。
语法
这是[b]SIN()[/b]函数的语法。
grunt>SIN(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在，使用[b]SIN()[/b]函数计算math.txt文件内容的正弦值，如下所示。
grunt>sin_data=foreachmath_datagenerate(data),SIN(data);
上述语句结果将存储在名为[b]sin_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpsin_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)
ApachePigSINH()函数
SINH()函数用于计算给定表达式的双曲正弦值。
语法
这里是SINH()函数的语法。
grunt>SINH(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]SINH()[/b]函数计算math.txt文件内容的双曲正弦值，如下所示。
grunt>sinh_data=foreachmath_datagenerate(data),SINH(data);
上述语句结果将存储在名为[b]sinh_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpsinh_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)
ApachePigSQRT()函数
SQRT()函数用于计算给定表达式的平方根。
语法
以下是[b]SQRT()[/b]函数的语法。
grunt>SQRT(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]SQRT()[/b]函数计算math.txt文件内容的平方根值，如下所示。
grunt>sqrt_data=foreachmath_datagenerate(data),SQRT(data);
上面的语句结果将存储在名为[b]sqrt_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumpsqrt_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)
ApachePigTAN()函数
TAN()函数用于计算给定表达式（角度）的三角正切。
语法
这是[b]TAN()[/b]函数的语法。
grunt>TAN(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]TAN()[/b]函数计算math.txt文件内容的正切值，如下所示。
grunt>tan_data=foreachmath_datagenerate(data),TAN(data);
上述语句结果将存储在名为[b]tan_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumptan_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)
ApachePigTANH()函数
TANH()函数用于计算给定表达式（角度）的双曲三角正切。
语法
这是[b]TANH()[/b]函数的语法。
grunt>TANH(expression)
例
假设在[b]HDFS[/b]目录[b]/pig_data/[/b]中有一个名为[b]math.txt[/b]的文件。此文件包含整数和浮点值，如下所示。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'USINGPigStorage(',')
as(data:float);
现在使用[b]TANH()[/b]函数计算math.txt文件内容的双曲正切值，如下所示。
grunt>tanh_data=foreachmath_datagenerate(data),TANH(data);
上述语句结果将存储在名为[b]tanh_data[/b]的关系中。使用Dump运算符验证关系的内容，如下所示。
grunt>Dumptanh_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)

                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                pig
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航