Apache Pig – 快速指南
Apache Pig – 快速指南
Apache Pig – 概述
什么是阿帕奇猪？
Apache Pig 是对 MapReduce 的抽象。它是一个工具/平台，用于分析更大的数据集，将它们表示为数据流。Pig 通常与Hadoop 一起使用；我们可以使用 Apache Pig 在 Hadoop 中执行所有数据操作操作。
为了编写数据分析程序，Pig 提供了一种称为Pig Latin的高级语言。该语言提供了各种运算符，程序员可以使用这些运算符开发自己的读取、写入和处理数据的功能。
要使用Apache Pig分析数据，程序员需要使用 Pig Latin 语言编写脚本。所有这些脚本都在内部转换为 Map 和 Reduce 任务。Apache Pig 有一个称为Pig Engine的组件，它接受 Pig Latin 脚本作为输入并将这些脚本转换为 MapReduce 作业。
为什么我们需要 Apache Pig？
不太擅长 Java 的程序员通常在使用 Hadoop 时遇到困难，尤其是在执行任何 MapReduce 任务时。Apache Pig 是所有此类程序员的福音。
-
使用Pig Latin，程序员可以轻松地执行 MapReduce 任务，而无需在 Java 中键入复杂的代码。
-
Apache Pig 使用多查询方式，从而减少代码长度。例如，需要您在 Java 中键入 200 行代码 (LoC) 的操作可以通过在 Apache Pig 中键入少至 10 LoC 来轻松完成。最终，Apache Pig 将开发时间缩短了近 16 倍。
-
Pig Latin 是类SQL 语言，熟悉 SQL 后很容易学习 Apache Pig。
-
Apache Pig 提供了许多内置操作符来支持数据操作，如连接、过滤器、排序等。此外，它还提供嵌套数据类型，如 MapReduce 中缺少的元组、包和映射。
猪的特点
Apache Pig 具有以下功能 –
-
丰富的运算符集– 它提供了许多运算符来执行连接、排序、过滤器等操作。
-
易于编程– Pig Latin 类似于 SQL，如果您擅长 SQL，则很容易编写 Pig 脚本。
-
优化机会– Apache Pig 中的任务会自动优化其执行，因此程序员只需关注语言的语义。
-
可扩展性– 使用现有的运算符，用户可以开发自己的功能来读取、处理和写入数据。
-
UDF 的– Pig 提供了在其他编程语言（如 Java）中创建用户定义函数的工具，并将它们调用或嵌入到 Pig 脚本中。
-
处理各种数据– Apache Pig 分析各种结构化和非结构化数据。它将结果存储在 HDFS 中。
Apache Pig 与 MapReduce
下面列出了 Apache Pig 和 MapReduce 之间的主要区别。
| Apache Pig | 映射简化 |
|---|---|
| Apache Pig is a data flow language. | MapReduce 是一种数据处理范式。 |
| It is a high level language. | MapReduce 是低级和刚性的。 |
| Performing a Join operation in Apache Pig is pretty simple. | 在 MapReduce 中执行数据集之间的 Join 操作非常困难。 |
| Any novice programmer with a basic knowledge of SQL can work conveniently with Apache Pig. | 要使用 MapReduce，必须接触 Java。 |
| Apache Pig uses multi-query approach, thereby reducing the length of the codes to a great extent. | MapReduce 将需要几乎 20 倍以上的行数来执行相同的任务。 |
| There is no need for compilation. On execution, every Apache Pig operator is converted internally into a MapReduce job. | MapReduce 作业的编译过程很长。 |
Apache Pig 与 SQL
下面列出了 Apache Pig 和 SQL 之间的主要区别。
| Pig | SQL |
|---|---|
| Pig Latin is a procedural language. | SQL 是一种声明性语言。 |
| In Apache Pig, schema is optional. We can store data without designing a schema (values are stored as $01, $02 etc.) | Schema 在 SQL 中是强制性的。 |
| The data model in Apache Pig is nested relational. | SQL 中使用的数据模型是平面关系。 |
| Apache Pig provides limited opportunity for Query optimization. | 在 SQL 中有更多的查询优化机会。 |
除了上述差异之外，Apache Pig Latin –
- 允许在管道中拆分。
- 允许开发人员将数据存储在管道中的任何位置。
- 声明执行计划。
- 提供运算符来执行 ETL（提取、转换和加载）功能。
Apache Pig 与 Hive
Apache Pig 和 Hive 都用于创建 MapReduce 作业。在某些情况下，Hive 以与 Apache Pig 类似的方式在 HDFS 上运行。在下表中，我们列出了将 Apache Pig 与 Hive 区分开来的几个重要点。
| Apache Pig | 蜂巢 |
|---|---|
| Apache Pig uses a language called Pig Latin. It was originally created at Yahoo. | Hive 使用一种称为HiveQL的语言。它最初是在Facebook创建的。 |
| Pig Latin is a data flow language. | HiveQL 是一种查询处理语言。 |
| Pig Latin is a procedural language and it fits in pipeline paradigm. | HiveQL 是一种声明性语言。 |
| Apache Pig can handle structured, unstructured, and semi-structured data. | Hive 主要用于结构化数据。 |
Apache Pig 的应用
数据科学家通常使用 Apache Pig 来执行涉及临时处理和快速原型设计的任务。使用 Apache Pig –
- 处理网络日志等海量数据源。
- 为搜索平台执行数据处理。
- 处理时间敏感的数据加载。
Apache Pig – 历史
在2006年，Apache的猪是发展成为雅虎的一个研究项目，特别是建立和每个数据集执行MapReduce作业。在2007年，Apache的猪是通过开放Apache孵化器采购。在2008年，Apache的猪的第一个版本出来。在2010，Apache的猪毕业作为Apache顶级项目。
Apache Pig – 架构
用于使用 Pig 在 Hadoop 中分析数据的语言称为Pig Latin。它是一种高级数据处理语言，提供了丰富的数据类型和操作符来对数据进行各种操作。
要使用 Pig 执行特定任务，程序员需要使用 Pig Latin 语言编写 Pig 脚本，并使用任何执行机制（Grunt Shell、UDF、Embedded）执行它们。执行后，这些脚本将经过 Pig 框架应用的一系列转换，以生成所需的输出。
在内部，Apache Pig 将这些脚本转换为一系列 MapReduce 作业，从而使程序员的工作变得轻松。Apache Pig 的架构如下所示。
Apache Pig 组件
如图所示，Apache Pig 框架中有各种组件。让我们来看看主要组件。
解析器
最初，Pig 脚本由解析器处理。它检查脚本的语法、类型检查和其他杂项检查。解析器的输出将是一个 DAG（有向无环图），它代表 Pig Latin 语句和逻辑运算符。
在 DAG 中，脚本的逻辑运算符表示为节点，数据流表示为边。
优化器
逻辑计划（DAG）被传递给逻辑优化器，它执行诸如投影和下推等逻辑优化。
编译器
编译器将优化后的逻辑计划编译成一系列 MapReduce 作业。
执行引擎
最后，MapReduce 作业按排序顺序提交给 Hadoop。最后，这些 MapReduce 作业在 Hadoop 上执行，产生所需的结果。
猪拉丁数据模型
Pig Latin 的数据模型是完全嵌套的，它允许使用复杂的非原子数据类型，例如map和tuple。下面给出了 Pig Latin 数据模型的图示。
原子
Pig Latin 中的任何单个值，无论其数据类型如何，都称为Atom。它存储为字符串，可以用作字符串和数字。int、long、float、double、chararray 和 bytearray 是 Pig 的原子值。一段数据或一个简单的原子值称为字段。
示例– ‘raja’ 或 ’30’
元组
由一组有序字段组成的记录称为元组，字段可以是任何类型。元组类似于 RDBMS 表中的一行。
示例– (Raja, 30)
包
包是一组无序的元组。换句话说，一组元组（非唯一）被称为包。每个元组可以有任意数量的字段（灵活模式）。包由“{}”表示。它类似于 RDBMS 中的表，但与 RDBMS 中的表不同，不必每个元组包含相同数量的字段或相同位置（列）的字段具有相同类型。
示例– {(Raja, 30), (Mohammad, 45)}
包可以是关系中的一个字段；在这种情况下，它被称为内袋。
示例– {Raja, 30, {9848022338, [email protected],} }
地图
映射（或数据映射）是一组键值对。在关键的需求是类型chararray的，应该是唯一的。该值可能是任何类型。它由'[]’表示
示例– [name#Raja, age#30]
关系
关系是一袋元组。Pig Latin 中的关系是无序的（不能保证以任何特定顺序处理元组）。
Apache Pig – 安装
本章解释了如何在您的系统中下载、安装和设置Apache Pig。
先决条件
在使用 Apache Pig 之前，您的系统上必须安装 Hadoop 和 Java，这一点至关重要。因此，在安装 Apache Pig 之前，请按照以下链接中给出的步骤安装 Hadoop 和 Java –
http://www.tutorialspoint.com/hadoop/hadoop_enviornment_setup.htm
下载 Apache Pig
首先，从以下网站下载最新版本的 Apache Pig – https://pig.apache.org/
步骤1
打开 Apache Pig 网站的主页。在新闻部分下，单击链接发布页面，如下面的快照所示。
第2步
单击指定的链接后，您将被重定向到Apache Pig 发布页面。在此页面上的“下载”部分下，您将有两个链接，即Pig 0.8 及更高版本和Pig 0.7 及之前版本。单击链接Pig 0.8 and later，然后您将被重定向到具有一组镜像的页面。
第 3 步
选择并单击这些镜像中的任何一个，如下所示。
第四步
这些镜像将带您进入Pig Releases页面。此页面包含 Apache Pig 的各种版本。单击其中的最新版本。
第 5 步
在这些文件夹中，您将拥有各种发行版中 Apache Pig 的源文件和二进制文件。下载Apache Pig 0.15、pig0.15.0-src.tar.gz和pig-0.15.0.tar.gz的源码和二进制文件的tar文件。
安装 Apache Pig
下载 Apache Pig 软件后，请按照以下步骤将其安装到您的 Linux 环境中。
步骤1
在Hadoop、Java等软件的安装目录下创建一个名为Pig的目录。（在我们的教程中，我们在名为 Hadoop 的用户中创建了 Pig 目录）。
$ mkdir Pig
第2步
解压缩下载的 tar 文件，如下所示。
$ cd Downloads/ $ tar zxvf pig-0.15.0-src.tar.gz $ tar zxvf pig-0.15.0.tar.gz
第 3 步
将pig-0.15.0-src.tar.gz文件的内容移动到之前创建的Pig目录中，如下所示。
$ mv pig-0.15.0-src.tar.gz/* /home/Hadoop/Pig/
配置 Apache Pig
安装 Apache Pig 后，我们必须对其进行配置。要配置，我们需要编辑两个文件 – bashrc 和 pig.properties。
.bashrc 文件
在.bashrc文件中，设置以下变量 –
-
PIG_HOME文件夹到 Apache Pig 的安装文件夹，
-
PATH环境变量到 bin 文件夹，以及
-
PIG_CLASSPATH环境变量添加到 Hadoop 安装的 etc（配置）文件夹（包含 core-site.xml、hdfs-site.xml 和 mapred-site.xml 文件的目录）。
export PIG_HOME = /home/Hadoop/Pig export PATH = $PATH:/home/Hadoop/pig/bin export PIG_CLASSPATH = $HADOOP_HOME/conf
pig.properties 文件
在Pig的conf文件夹中，我们有一个名为pig.properties的文件。在 pig.properties 文件中，您可以设置如下所示的各种参数。
pig -h properties
支持以下属性 –
Logging: verbose = true|false; default is false. This property is the same as -v
switch brief=true|false; default is false. This property is the same
as -b switch debug=OFF|ERROR|WARN|INFO|DEBUG; default is INFO.
This property is the same as -d switch aggregate.warning = true|false; default is true.
If true, prints count of warnings of each type rather than logging each warning.
Performance tuning: pig.cachedbag.memusage=<mem fraction>; default is 0.2 (20% of all memory).
Note that this memory is shared across all large bags used by the application.
pig.skewedjoin.reduce.memusagea=<mem fraction>; default is 0.3 (30% of all memory).
Specifies the fraction of heap available for the reducer to perform the join.
pig.exec.nocombiner = true|false; default is false.
Only disable combiner as a temporary workaround for problems.
opt.multiquery = true|false; multiquery is on by default.
Only disable multiquery as a temporary workaround for problems.
opt.fetch=true|false; fetch is on by default.
Scripts containing Filter, Foreach, Limit, Stream, and Union can be dumped without MR jobs.
pig.tmpfilecompression = true|false; compression is off by default.
Determines whether output of intermediate jobs is compressed.
pig.tmpfilecompression.codec = lzo|gzip; default is gzip.
Used in conjunction with pig.tmpfilecompression. Defines compression type.
pig.noSplitCombination = true|false. Split combination is on by default.
Determines if multiple small files are combined into a single map.
pig.exec.mapPartAgg = true|false. Default is false.
Determines if partial aggregation is done within map phase, before records are sent to combiner.
pig.exec.mapPartAgg.minReduction=<min aggregation factor>. Default is 10.
If the in-map partial aggregation does not reduce the output num records by this factor, it gets disabled.
Miscellaneous: exectype = mapreduce|tez|local; default is mapreduce. This property is the same as -x switch
pig.additional.jars.uris=<comma seperated list of jars>. Used in place of register command.
udf.import.list=<comma seperated list of imports>. Used to avoid package names in UDF.
stop.on.failure = true|false; default is false. Set to true to terminate on the first error.
pig.datetime.default.tz=<UTC time offset>. e.g. +08:00. Default is the default timezone of the host.
Determines the timezone used to handle datetime datatype and UDFs.
Additionally, any Hadoop property can be specified.
验证安装
通过键入 version 命令验证 Apache Pig 的安装。如果安装成功，您将获得如下所示的 Apache Pig 版本。
$ pig –version Apache Pig version 0.15.0 (r1682971) compiled Jun 01 2015, 11:44:35
Apache Pig – 执行
在上一章中，我们解释了如何安装 Apache Pig。在本章中，我们将讨论如何执行 Apache Pig。
Apache Pig 执行模式
您可以在两种模式下运行 Apache Pig，即本地模式和HDFS 模式。
本地模式
在此模式下，所有文件都从本地主机和本地文件系统安装和运行。不需要 Hadoop 或 HDFS。此模式一般用于测试目的。
MapReduce 模式
MapReduce 模式是我们使用 Apache Pig 加载或处理 Hadoop 文件系统 (HDFS) 中存在的数据的地方。在这种模式下，每当我们执行 Pig Latin 语句来处理数据时，都会在后端调用 MapReduce 作业对 HDFS 中存在的数据执行特定操作。
Apache Pig 执行机制
Apache Pig 脚本可以通过三种方式执行，即交互模式、批处理模式和嵌入模式。
-
交互模式（Grunt shell）- 您可以使用 Grunt shell 以交互模式运行 Apache Pig。在此 shell 中，您可以输入 Pig Latin 语句并获取输出（使用 Dump 运算符）。
-
批处理模式（脚本）- 您可以通过在单个文件中编写 Pig Latin 脚本以.pig扩展名以批处理模式运行 Apache Pig 。
-
嵌入模式（UDF） -阿帕奇猪提供了定义我们自己的函数（的规定ü SER d efined ˚F unctions）在诸如Java编程语言，并在我们的脚本中使用它们。
调用 Grunt Shell
您可以使用-x选项以所需模式（本地/MapReduce）调用 Grunt shell，如下所示。
| Local mode | MapReduce 模式 |
|---|---|
|
Command − $ ./pig –x local |
Command − $ ./pig -x mapreduce |
|
Output −
|
输出–
|
这些命令中的任何一个都会为您提供 Grunt shell 提示，如下所示。
grunt>
您可以使用‘ctrl &plus d’退出 Grunt shell 。
调用 Grunt shell 后，您可以通过直接在其中输入 Pig Latin 语句来执行 Pig 脚本。
grunt> customers = LOAD 'customers.txt' USING PigStorage(',');
以批处理模式执行 Apache Pig
您可以在文件中编写整个 Pig Latin 脚本并使用–x 命令执行它。假设我们在名为sample_script.pig的文件中有一个 Pig 脚本，如下所示。
sample_script.pig
student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING
PigStorage(',') as (id:int,name:chararray,city:chararray);
Dump student;
现在，您可以执行上述文件中的脚本，如下所示。
| Local mode | MapReduce 模式 |
|---|---|
| $ pig -x local Sample_script.pig | $ pig -x mapreduce Sample_script.pig |
注意– 我们将在后续章节中详细讨论如何在Bach 模式和嵌入模式下运行 Pig 脚本。
Apache Pig – Grunt Shell
调用 Grunt shell 后，您可以在 shell 中运行您的 Pig 脚本。除此之外，Grunt shell 还提供了一些有用的 shell 和实用程序命令。本章解释了 Grunt shell 提供的 shell 和实用程序命令。
注意– 在本章的某些部分中，使用了Load和Store等命令。请参阅相应章节以获取有关它们的详细信息。
外壳命令
Apache Pig 的 Grunt shell 主要用于编写 Pig Latin 脚本。在此之前，我们可以使用sh和fs调用任何 shell 命令。
sh 命令
使用sh命令，我们可以从 Grunt shell 调用任何 shell 命令。使用来自 Grunt shell 的sh命令，我们无法执行作为 shell 环境一部分的命令（例如– cd）。
句法
下面给出了sh命令的语法。
grunt> sh shell command parameters
例子
我们可以使用sh选项从 Grunt shell调用Linux shell的ls命令，如下所示。在本例中，它列出了/pig/bin/目录中的文件。
grunt> sh ls pig pig_1444799121955.log pig.cmd pig.py
fs 命令
使用fs命令，我们可以从 Grunt shell 调用任何 FsShell 命令。
句法
下面给出的是fs命令的语法。
grunt> sh File System command parameters
例子
我们可以使用 fs 命令从 Grunt shell 调用 HDFS 的 ls 命令。在以下示例中，它列出了 HDFS 根目录中的文件。
grunt> fs –ls Found 3 items drwxrwxrwx - Hadoop supergroup 0 2015-09-08 14:13 Hbase drwxr-xr-x - Hadoop supergroup 0 2015-09-09 14:52 seqgen_data drwxr-xr-x - Hadoop supergroup 0 2015-09-08 11:30 twitter_data
同样，我们可以使用fs命令从 Grunt shell 调用所有其他文件系统 shell 命令。
实用命令
Grunt shell 提供了一组实用命令。其中包括实用命令，例如clear、help、history、quit和set；以及诸如exec、kill和run 之类的命令，用于从 Grunt shell 控制 Pig。下面给出了 Grunt shell 提供的实用程序命令的描述。
清除命令
的明确命令用于清除咕噜壳的屏幕。
句法
您可以使用clear命令清除grunt shell 的屏幕，如下所示。
grunt> clear
帮助命令
的帮助下命令给你猪命令或猪的属性列表。
用法
您可以使用help命令获取 Pig 命令列表，如下所示。
grunt> help
Commands: <pig latin statement>; - See the PigLatin manual for details:
http://hadoop.apache.org/pig
File system commands:fs <fs arguments> - Equivalent to Hadoop dfs command:
http://hadoop.apache.org/common/docs/current/hdfs_shell.html
Diagnostic Commands:describe <alias>[::<alias] - Show the schema for the alias.
Inner aliases can be described as A::B.
explain [-script <pigscript>] [-out <path>] [-brief] [-dot|-xml]
[-param <param_name>=<pCram_value>]
[-param_file <file_name>] [<alias>] -
Show the execution plan to compute the alias or for entire script.
-script - Explain the entire script.
-out - Store the output into directory rather than print to stdout.
-brief - Don't expand nested plans (presenting a smaller graph for overview).
-dot - Generate the output in .dot format. Default is text format.
-xml - Generate the output in .xml format. Default is text format.
-param <param_name - See parameter substitution for details.
-param_file <file_name> - See parameter substitution for details.
alias - Alias to explain.
dump <alias> - Compute the alias and writes the results to stdout.
Utility Commands: exec [-param <param_name>=param_value] [-param_file <file_name>] <script> -
Execute the script with access to grunt environment including aliases.
-param <param_name - See parameter substitution for details.
-param_file <file_name> - See parameter substitution for details.
script - Script to be executed.
run [-param <param_name>=param_value] [-param_file <file_name>] <script> -
Execute the script with access to grunt environment.
-param <param_name - See parameter substitution for details.
-param_file <file_name> - See parameter substitution for details.
script - Script to be executed.
sh <shell command> - Invoke a shell command.
kill <job_id> - Kill the hadoop job specified by the hadoop job id.
set <key> <value> - Provide execution parameters to Pig. Keys and values are case sensitive.
The following keys are supported:
default_parallel - Script-level reduce parallelism. Basic input size heuristics used
by default.
debug - Set debug on or off. Default is off.
job.name - Single-quoted name for jobs. Default is PigLatin:<script name>
job.priority - Priority for jobs. Values: very_low, low, normal, high, very_high.
Default is normal stream.skippath - String that contains the path.
This is used by streaming any hadoop property.
help - Display this message.
history [-n] - Display the list statements in cache.
-n Hide line numbers.
quit - Quit the grunt shell.
历史命令
此命令显示自调用 Grunt sell 以来执行/使用的语句列表。
用法
假设自从打开 Grunt shell 以来我们已经执行了三个语句。
grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',');
grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',');
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',');
然后，使用history命令将产生以下输出。
grunt> history
customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',');
orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',');
student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',');
设置命令
该组命令用于显示在猪中使用的密钥/分配值。
用法
使用此命令，您可以为以下键设置值。
| Key | 描述和值 |
|---|---|
| default_parallel | 您可以通过将任何整数作为值传递给此键来设置映射作业的减速器数量。 |
| debug | 您可以通过将 on/off 传递给该键来关闭或打开 Pig 中的调试功能。 |
| job.name | 您可以通过将字符串值传递给此键，将作业名称设置为所需的作业。 |
| job.priority |
您可以通过将以下值之一传递给此键来为作业设置作业优先级 –
|
| stream.skippath | 对于流式传输，您可以设置不传输数据的路径，方法是将所需的路径以字符串的形式传递给该键。 |
退出命令
您可以使用此命令从 Grunt shell 退出。
用法
退出 Grunt shell，如下所示。
grunt> quit
现在让我们来看看您可以使用哪些命令从 Grunt shell 控制 Apache Pig。
执行命令
使用exec命令，我们可以从 Grunt shell 执行 Pig 脚本。
句法
下面给出了实用程序命令exec的语法。
grunt> exec [–param param_name = param_value] [–param_file file_name] [script]
例子
假设HDFS的/pig_data/目录下有一个名为student.txt的文件，内容如下。
学生.txt
001,Rajiv,Hyderabad 002,siddarth,Kolkata 003,Rajesh,Delhi
并且，假设我们在HDFS的/pig_data/目录中有一个名为sample_script.pig的脚本文件，其内容如下。
sample_script.pig
student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',')
as (id:int,name:chararray,city:chararray);
Dump student;
现在，让我们使用exec命令从 Grunt shell 执行上述脚本，如下所示。
grunt> exec /sample_script.pig
输出
在EXEC命令执行脚本sample_script.pig。按照脚本中的指示，它将student.txt文件加载到 Pig 中，并为您提供显示以下内容的 Dump 运算符的结果。
(1,Rajiv,Hyderabad) (2,siddarth,Kolkata) (3,Rajesh,Delhi)
杀死命令
您可以使用此命令从 Grunt shell 中终止作业。
句法
下面给出了kill命令的语法。
grunt> kill JobId
例子
假设有一个正在运行的 Pig 作业，其 ID 为Id_0055，您可以使用kill命令从 Grunt shell 中将其杀死，如下所示。
grunt> kill Id_0055
运行命令
您可以使用run命令从 Grunt shell 运行 Pig 脚本
句法
下面给出了运行命令的语法。
grunt> run [–param param_name = param_value] [–param_file file_name] script
例子
假设HDFS的/pig_data/目录下有一个名为student.txt的文件，内容如下。
学生.txt
001,Rajiv,Hyderabad 002,siddarth,Kolkata 003,Rajesh,Delhi
并且，假设我们在本地文件系统中有一个名为sample_script.pig的脚本文件，其内容如下。
sample_script.pig
student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING
PigStorage(',') as (id:int,name:chararray,city:chararray);
现在，让我们使用如下所示的 run 命令从 Grunt shell 运行上述脚本。
grunt> run /sample_script.pig
您可以使用Dump 运算符查看脚本的输出，如下所示。
grunt> Dump; (1,Rajiv,Hyderabad) (2,siddarth,Kolkata) (3,Rajesh,Delhi)
注意– exec和run命令之间的区别在于，如果我们使用run，则脚本中的语句在命令历史记录中可用。
猪拉丁语 – 基础
Pig Latin 是用于使用 Apache Pig 在 Hadoop 中分析数据的语言。在本章中，我们将讨论 Pig Latin 的基础知识，例如 Pig Latin 语句、数据类型、一般和关系运算符以及 Pig Latin UDF。
Pig Latin – 数据模型
正如前几章所讨论的，Pig 的数据模型是完全嵌套的。一个关系是隐语数据模型的最外层结构。它是一个袋子–
- 包是元组的集合。
- 元组是一组有序的字段。
- 字段是一段数据。
Pig Latin – Statemets
使用 Pig Latin 处理数据时，语句是基本结构。
-
这些语句适用于关系。它们包括表达式和模式。
-
每个语句都以分号 (;) 结尾。
-
我们将使用 Pig Latin 提供的运算符通过语句执行各种操作。
-
除了 LOAD 和 STORE，在执行所有其他操作时，Pig Latin 语句将一个关系作为输入并生成另一个关系作为输出。
-
一旦您在 Grunt shell 中输入Load语句，就会执行其语义检查。要查看架构的内容，您需要使用Dump运算符。只有在执行转储操作后，才会执行将数据加载到文件系统的 MapReduce 作业。
例子
下面给出的是一个 Pig Latin 语句，它将数据加载到 Apache Pig。
grunt> Student_data = LOAD 'student_data.txt' USING PigStorage(',')as
( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );
Pig Latin – 数据类型
下表描述了 Pig Latin 数据类型。
| S.N. | 数据类型 | 说明和示例 |
|---|---|---|
| 1 | 整数 |
表示一个有符号的 32 位整数。 示例：8 |
| 2 | 长 |
表示一个有符号的 64 位整数。 示例：5L |
| 3 | 漂浮 |
表示有符号的 32 位浮点。 例子：5.5F |
| 4 | 双倍的 |
表示 64 位浮点数。 示例：10.5 |
| 5 | 字符数组 |
表示 Unicode UTF-8 格式的字符数组（字符串）。 示例：’教程点’ |
| 6 | 字节数组 |
表示一个字节数组（blob）。 |
| 7 | 布尔值 |
表示一个布尔值。 示例：真/假。 |
| 8 | 约会时间 |
表示日期时间。 示例：1970-01-01T00:00:00.000+00:00 |
| 9 | 大整数 |
表示一个 Java BigInteger。 示例：60708090709 |
| 10 | 大十进制 |
表示一个 Java BigDecimal 示例：185.98376256272893883 |
| Complex Types | ||
| 11 | 元组 |
元组是一组有序的字段。 示例: (raja, 30) |
| 12 | 包 |
包是元组的集合。 示例：{(raju,30),(Mohhammad,45)} |
| 13 | 地图 |
Map 是一组键值对。 示例：[‘name’#’Raju’, ‘age’#30] |
空值
上述所有数据类型的值都可以为 NULL。Apache Pig 以与 SQL 类似的方式处理空值。
null 可以是未知值或不存在的值。它用作可选值的占位符。这些空值可以自然发生，也可以是操作的结果。
Pig Latin – 算术运算符
下表描述了 Pig Latin 的算术运算符。假设 a = 10 且 b = 20。
| Operator | 描述 | 例子 |
|---|---|---|
| &plus |
加法– 在运算符的任一侧添加值 |
a &plus b 将给 30 |
| − |
减法– 从左手操作数中减去右手操作数 |
a – b 将给出 -10 |
| * |
乘法– 将运算符两侧的值相乘 |
a * b 将给出 200 |
| / |
除法– 将左手操作数除以右手操作数 |
b / a 会给 2 |
| % |
模数– 将左手操作数除以右手操作数并返回余数 |
b % a 将给出 0 |
| ? : |
Bincond – 评估布尔运算符。它具有三个操作数，如下所示。 变量x = (表达式) ? value1 如果为 true：value2 如果为 false。 |
b = (a == 1)？20: 30; 如果 a=1，则 b 的值为 20。 如果 a!=1，则 b 的值为 30。 |
|
CASE WHEN THEN ELSE END |
Case – case 运算符等效于嵌套的 bincond 运算符。 |
案例 f2 % 2 WHEN 0 THEN ‘偶数’ WHEN 1 THEN ‘奇数’ 结尾 |
Pig Latin – 比较运算符
下表描述了 Pig Latin 的比较运算符。
| Operator | 描述 | 例子 |
|---|---|---|
| == |
Equal – 检查两个操作数的值是否相等；如果是，则条件变为真。 |
(a = b) 不是真的 |
| != |
不等于– 检查两个操作数的值是否相等。如果值不相等，则条件变为真。 |
(a != b) 是真的。 |
| > |
大于– 检查左操作数的值是否大于右操作数的值。如果是，则条件变为真。 |
(a > b) 不正确。 |
| < |
小于– 检查左操作数的值是否小于右操作数的值。如果是，则条件变为真。 |
(a < b) 是真的。 |
| >= |
大于或等于– 检查左操作数的值是否大于或等于右操作数的值。如果是，则条件变为真。 |
(a >= b) 不是真的。 |
| <= |
小于或等于– 检查左操作数的值是否小于或等于右操作数的值。如果是，则条件变为真。 |
(a <= b) 是真的。 |
| matches |
模式匹配– 检查左侧的字符串是否与右侧的常量匹配。 |
f1 匹配 ‘.*tutorial.*’ |
Pig Latin – 类型构造运算符
下表描述了 Pig Latin 的类型构造运算符。
| Operator | 描述 | 例子 |
|---|---|---|
| () |
元组构造器运算符– 此运算符用于构造元组。 |
（拉朱，30 岁） |
| {} |
Bag constructor operator – 此运算符用于构造一个包。 |
{(Raju, 30), (Mohammad, 45)} |
| [] |
Map constructor operator – 此运算符用于构造元组。 |
[姓名#Raja，年龄#30] |
Pig Latin – 关系运算
下表描述了 Pig Latin 的关系运算符。
| Operator | 描述 |
|---|---|
| Loading and Storing | |
| LOAD | 将文件系统（本地/HDFS）中的数据加载到关系中。 |
| STORE | 保存与文件系统（本地/HDFS）的关系。 |
| Filtering | |
| FILTER | 从关系中删除不需要的行。 |
| DISTINCT | 从关系中删除重复的行。 |
| FOREACH, GENERATE | 基于数据列生成数据转换。 |
| STREAM | 使用外部程序转换关系。 |
| Grouping and Joining | |
| JOIN | 加入两个或多个关系。 |
| COGROUP | 将数据分组为两个或多个关系。 |
| GROUP | 将数据分组为单个关系。 |
| CROSS | 创建两个或多个关系的叉积。 |
| Sorting | |
| ORDER | 根据一个或多个字段（升序或降序）按排序顺序排列关系。 |
| LIMIT | 从关系中获取有限数量的元组。 |
| Combining and Splitting | |
| UNION | 将两个或多个关系合并为一个关系。 |
| SPLIT | 将单个关系拆分为两个或多个关系。 |
| Diagnostic Operators | |
| DUMP | 在控制台上打印关系的内容。 |
| DESCRIBE | 描述关系的模式。 |
| EXPLAIN | 查看逻辑、物理或 MapReduce 执行计划以计算关系。 |
| ILLUSTRATE | 查看一系列语句的逐步执行。 |
Apache Pig – 读取数据
一般来说，Apache Pig 工作在 Hadoop 之上。它是一种分析工具，用于分析存在于大型数据集ħ adoop ˚F ILE小号ystem。要使用 Apache Pig 分析数据，我们必须首先将数据加载到 Apache Pig。本章介绍如何从 HDFS 将数据加载到 Apache Pig。
准备 HDFS
在 MapReduce 模式下，Pig 从 HDFS 读取（加载）数据并将结果存储回 HDFS。因此，让我们启动 HDFS 并在 HDFS 中创建以下示例数据。
| Student ID | 名 | 姓 | 电话 | 城市 |
|---|---|---|---|---|
| 001 | 拉吉夫 | 雷迪 | 9848022337 | 海得拉巴 |
| 002 | 悉达斯 | 巴塔查里亚 | 9848022338 | 加尔各答 |
| 003 | 拉杰什 | 卡纳 | 9848022339 | 德里 |
| 004 | 普瑞提 | 阿加瓦尔 | 9848022330 | 浦那 |
| 005 | 特鲁蒂 | 莫汉西 | 9848022336 | 布瓦内什瓦尔 |
| 006 | 阿卡纳 | 米什拉 | 9848022335 | 钦奈 |
上述数据集包含六个学生的个人详细信息，如 ID、名字、姓氏、电话号码和城市。
步骤 1：验证 Hadoop
首先，使用Hadoop version命令验证安装，如下图。
$ hadoop version
如果您的系统包含 Hadoop，并且您已经设置了 PATH 变量，那么您将获得以下输出 –
Hadoop 2.6.0 Subversion https://git-wip-us.apache.org/repos/asf/hadoop.git -r e3496499ecb8d220fba99dc5ed4c99c8f9e33bb1 Compiled by jenkins on 2014-11-13T21:10Z Compiled with protoc 2.5.0 From source with checksum 18e43357c8f927c0695f1e9522859d6a This command was run using /home/Hadoop/hadoop/share/hadoop/common/hadoop common-2.6.0.jar
第 2 步：启动 HDFS
浏览Hadoop的sbin目录，启动yarn和Hadoop dfs（分布式文件系统），如下图。
cd /$Hadoop_Home/sbin/ $ start-dfs.sh localhost: starting namenode, logging to /home/Hadoop/hadoop/logs/hadoopHadoop-namenode-localhost.localdomain.out localhost: starting datanode, logging to /home/Hadoop/hadoop/logs/hadoopHadoop-datanode-localhost.localdomain.out Starting secondary namenodes [0.0.0.0] starting secondarynamenode, logging to /home/Hadoop/hadoop/logs/hadoop-Hadoopsecondarynamenode-localhost.localdomain.out $ start-yarn.sh starting yarn daemons starting resourcemanager, logging to /home/Hadoop/hadoop/logs/yarn-Hadoopresourcemanager-localhost.localdomain.out localhost: starting nodemanager, logging to /home/Hadoop/hadoop/logs/yarnHadoop-nodemanager-localhost.localdomain.out
第 3 步：在 HDFS 中创建目录
在 Hadoop DFS 中，您可以使用命令mkdir创建目录。在 HDFS中的所需路径中创建一个名为Pig_Data的新目录，如下所示。
$cd /$Hadoop_Home/bin/ $ hdfs dfs -mkdir hdfs://localhost:9000/Pig_Data
第 4 步：将数据放入 HDFS
Pig 的输入文件在单独的行中包含每个元组/记录。记录的实体由分隔符分隔（在我们的示例中，我们使用了“,”）。
在本地文件系统中，创建一个包含数据的输入文件student_data.txt，如下所示。
001,Rajiv,Reddy,9848022337,Hyderabad 002,siddarth,Battacharya,9848022338,Kolkata 003,Rajesh,Khanna,9848022339,Delhi 004,Preethi,Agarwal,9848022330,Pune 005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 006,Archana,Mishra,9848022335,Chennai.
现在，使用put命令将文件从本地文件系统移动到 HDFS ，如下所示。（您也可以使用copyFromLocal命令。）
$ cd $HADOOP_HOME/bin $ hdfs dfs -put /home/Hadoop/Pig/Pig_Data/student_data.txt dfs://localhost:9000/pig_data/
验证文件
可以使用cat命令验证文件是否已经移入HDFS，如下图。
$ cd $HADOOP_HOME/bin $ hdfs dfs -cat hdfs://localhost:9000/pig_data/student_data.txt
输出
您可以看到文件的内容，如下所示。
15/10/01 12:16:55 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable 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
加载运算符
您可以使用Pig Latin 的LOAD运算符将数据从文件系统（HDFS/本地）加载到 Apache Pig 。
句法
load 语句由两部分组成，由“=”操作符分隔。在左侧，我们需要提及的关系的名称这里我们要存储的数据，并在右边，我们要定义如何，我们存储数据。下面给出的是Load运算符的语法。
Relation_name = LOAD 'Input file path' USING function as schema;
在哪里，
-
关系名称– 我们必须提到我们要存储数据的关系。
-
输入文件路径– 我们必须提到存储文件的 HDFS 目录。（在 MapReduce 模式下）
-
function – 我们必须从 Apache Pig 提供的加载函数集中选择一个函数（BinStorage、JsonLoader、PigStorage、TextLoader）。
-
架构– 我们必须定义数据的架构。我们可以定义所需的架构如下 –
(column1 : data type, column2 : data type, column3 : data type);
注意– 我们在不指定架构的情况下加载数据。在这种情况下，列将被寻址为 $01、$02 等……（检查）。
例子
例如，让我们使用LOAD命令在名为Student的模式下加载Pig中student_data.txt中的数据。
启动 Pig Grunt Shell
首先，打开Linux终端。在 MapReduce 模式下启动 Pig Grunt shell，如下所示。
$ Pig –x mapreduce
它将启动 Pig Grunt shell，如下所示。
15/10/01 12:33:37 INFO pig.ExecTypeProvider: Trying ExecType : LOCAL 15/10/01 12:33:37 INFO pig.ExecTypeProvider: Trying ExecType : MAPREDUCE 15/10/01 12:33:37 INFO pig.ExecTypeProvider: Picked MAPREDUCE as the ExecType 2015-10-01 12:33:38,080 [main] INFO org.apache.pig.Main - Apache Pig version 0.15.0 (r1682971) compiled Jun 01 2015, 11:44:35 2015-10-01 12:33:38,080 [main] INFO org.apache.pig.Main - Logging error messages to: /home/Hadoop/pig_1443683018078.log 2015-10-01 12:33:38,242 [main] INFO org.apache.pig.impl.util.Utils - Default bootup file /home/Hadoop/.pigbootup not found 2015-10-01 12:33:39,630 [main] INFO org.apache.pig.backend.hadoop.executionengine.HExecutionEngine - Connecting to hadoop file system at: hdfs://localhost:9000 grunt>
执行加载语句
现在，通过在 Grunt shell 中执行以下 Pig Latin 语句，将student_data.txt文件中的数据加载到 Pig 中。
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt'
USING PigStorage(',')
as ( id:int, firstname:chararray, lastname:chararray, phone:chararray,
city:chararray );
以下是对上述语句的描述。
| Relation name | 我们已将数据存储在模式student 中。 | ||||||||||||
| Input file path | 我们正在从文件student_data.txt中读取数据，该文件位于 HDFS 的 /pig_data/ 目录中。 | ||||||||||||
| Storage function | 我们已经使用了PigStorage()函数。它将数据加载和存储为结构化文本文件。它需要一个分隔符，使用它来分隔元组的每个实体，作为参数。默认情况下，它采用 ‘\t’ 作为参数。 | ||||||||||||
| schema |
我们使用以下模式存储了数据。
|
注意– load语句将简单地将数据加载到 Pig 中的指定关系中。要验证Load语句的执行，您必须使用下一章中讨论的诊断运算符。
Apache Pig – 存储数据
在上一章中，我们学习了如何将数据加载到 Apache Pig 中。您可以使用store运算符将加载的数据存储在文件系统中。本章解释了如何使用Store操作符在 Apache Pig 中存储数据。
句法
下面给出了 Store 语句的语法。
STORE Relation_name INTO ' required_directory_path ' [USING function];
例子
假设我们在 HDFS 中有一个文件student_data.txt，其内容如下。
001,Rajiv,Reddy,9848022337,Hyderabad 002,siddarth,Battacharya,9848022338,Kolkata 003,Rajesh,Khanna,9848022339,Delhi 004,Preethi,Agarwal,9848022330,Pune 005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 006,Archana,Mishra,9848022335,Chennai.
我们已经使用 LOAD 运算符将其读入关系学生中，如下所示。
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt'
USING PigStorage(',')
as ( id:int, firstname:chararray, lastname:chararray, phone:chararray,
city:chararray );
现在，让我们将关系存储在 HDFS 目录“/pig_Output/”中，如下所示。
grunt> STORE student INTO ' hdfs://localhost:9000/pig_Output/ ' USING PigStorage (',');
输出
执行store语句后，您将获得以下输出。使用指定名称创建一个目录，数据将存储在其中。
2015-10-05 13:05:05,429 [main] INFO org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.
MapReduceLau ncher - 100% complete
2015-10-05 13:05:05,429 [main] INFO org.apache.pig.tools.pigstats.mapreduce.SimplePigStats -
Script Statistics:
HadoopVersion PigVersion UserId StartedAt FinishedAt Features
2.6.0 0.15.0 Hadoop 2015-10-0 13:03:03 2015-10-05 13:05:05 UNKNOWN
Success!
Job Stats (time in seconds):
JobId Maps Reduces MaxMapTime MinMapTime AvgMapTime MedianMapTime
job_14459_06 1 0 n/a n/a n/a n/a
MaxReduceTime MinReduceTime AvgReduceTime MedianReducetime Alias Feature
0 0 0 0 student MAP_ONLY
OutPut folder
hdfs://localhost:9000/pig_Output/
Input(s): Successfully read 0 records from: "hdfs://localhost:9000/pig_data/student_data.txt"
Output(s): Successfully stored 0 records in: "hdfs://localhost:9000/pig_Output"
Counters:
Total records written : 0
Total bytes written : 0
Spillable Memory Manager spill count : 0
Total bags proactively spilled: 0
Total records proactively spilled: 0
Job DAG: job_1443519499159_0006
2015-10-05 13:06:06,192 [main] INFO org.apache.pig.backend.hadoop.executionengine
.mapReduceLayer.MapReduceLau ncher - Success!
确认
您可以验证存储的数据，如下所示。
步骤1
首先，使用ls命令列出pig_output目录下的文件，如下图。
hdfs dfs -ls 'hdfs://localhost:9000/pig_Output/' Found 2 items rw-r--r- 1 Hadoop supergroup 0 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/_SUCCESS rw-r--r- 1 Hadoop supergroup 224 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/part-m-00000
可以观察到执行store语句后创建了两个文件。
第2步
使用cat命令，列出名为part-m-00000的文件的内容，如下所示。
$ hdfs dfs -cat 'hdfs://localhost:9000/pig_Output/part-m-00000' 1,Rajiv,Reddy,9848022337,Hyderabad 2,siddarth,Battacharya,9848022338,Kolkata 3,Rajesh,Khanna,9848022339,Delhi 4,Preethi,Agarwal,9848022330,Pune 5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 6,Archana,Mishra,9848022335,Chennai
Apache Pig – 诊断运算符
该负载语句将简单地将数据加载到Apache的猪指定的关系。要验证Load语句的执行，您必须使用Diagnostic Operators。Pig Latin 提供四种不同类型的诊断运算符 –
- 转储操作符
- 描述运算符
- 解释运算符
- 插图运算符
在本章中，我们将讨论 Pig Latin 的 Dump 运算符。
转储操作员
该转储操作来运行的Pig Latin语句并在屏幕上显示的结果。它一般用于调试目的。
句法
下面给出的是转储运算符的语法。
grunt> Dump Relation_Name
例子
假设我们在 HDFS 中有一个文件student_data.txt，其内容如下。
001,Rajiv,Reddy,9848022337,Hyderabad 002,siddarth,Battacharya,9848022338,Kolkata 003,Rajesh,Khanna,9848022339,Delhi 004,Preethi,Agarwal,9848022330,Pune 005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 006,Archana,Mishra,9848022335,Chennai.
我们已经使用 LOAD 运算符将其读入关系学生中，如下所示。
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt'
USING PigStorage(',')
as ( id:int, firstname:chararray, lastname:chararray, phone:chararray,
city:chararray );
现在，让我们使用Dump 运算符打印关系的内容，如下所示。
grunt> Dump student
执行上述Pig Latin语句后，它将启动 MapReduce 作业以从 HDFS 读取数据。它将产生以下输出。
2015-10-01 15:05:27,642 [main]
INFO org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLauncher -
100% complete
2015-10-01 15:05:27,652 [main]
INFO org.apache.pig.tools.pigstats.mapreduce.SimplePigStats - Script Statistics:
HadoopVersion PigVersion UserId StartedAt FinishedAt Features
2.6.0 0.15.0 Hadoop 2015-10-01 15:03:11 2015-10-01 05:27 UNKNOWN
Success!
Job Stats (time in seconds):
JobId job_14459_0004
Maps 1
Reduces 0
MaxMapTime n/a
MinMapTime n/a
AvgMapTime n/a
MedianMapTime n/a
MaxReduceTime 0
MinReduceTime 0
AvgReduceTime 0
MedianReducetime 0
Alias student
Feature MAP_ONLY
Outputs hdfs://localhost:9000/tmp/temp580182027/tmp757878456,
Input(s): Successfully read 0 records from: "hdfs://localhost:9000/pig_data/
student_data.txt"
Output(s): Successfully stored 0 records in: "hdfs://localhost:9000/tmp/temp580182027/
tmp757878456"
Counters: Total records written : 0 Total bytes written : 0 Spillable Memory Manager
spill count : 0Total bags proactively spilled: 0 Total records proactively spilled: 0
Job DAG: job_1443519499159_0004
2015-10-01 15:06:28,403 [main]
INFO org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLau ncher - Success!
2015-10-01 15:06:28,441 [main] INFO org.apache.pig.data.SchemaTupleBackend -
Key [pig.schematuple] was not set... will not generate code.
2015-10-01 15:06:28,485 [main]
INFO org.apache.hadoop.mapreduce.lib.input.FileInputFormat - Total input paths
to process : 1
2015-10-01 15:06:28,485 [main]
INFO org.apache.pig.backend.hadoop.executionengine.util.MapRedUtil - Total input paths
to process : 1
(1,Rajiv,Reddy,9848022337,Hyderabad)
(2,siddarth,Battacharya,9848022338,Kolkata)
(3,Rajesh,Khanna,9848022339,Delhi)
(4,Preethi,Agarwal,9848022330,Pune)
(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,9848022335,Chennai)
Apache Pig – 描述运算符
将描述操作者用于查看的关系的模式。
句法
描述运算符的语法如下 –
grunt> Describe Relation_name
例子
假设我们在 HDFS 中有一个文件student_data.txt，其内容如下。
001,Rajiv,Reddy,9848022337,Hyderabad 002,siddarth,Battacharya,9848022338,Kolkata 003,Rajesh,Khanna,9848022339,Delhi 004,Preethi,Agarwal,9848022330,Pune 005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 006,Archana,Mishra,9848022335,Chennai.
我们已经使用 LOAD 运算符将其读入关系学生中，如下所示。
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );
现在，让我们描述名为student的关系并验证模式，如下所示。
grunt> describe student;
输出
执行上述Pig Latin语句后，它将产生以下输出。
grunt> student: { id: int,firstname: chararray,lastname: chararray,phone: chararray,city: chararray }
Apache Pig – 解释运算符
在解释操作者用于显示的关系的逻辑，物理和MapReduce的执行计划。
句法
下面给出了解释运算符的语法。
grunt> explain Relation_name;
例子
假设我们在 HDFS 中有一个文件student_data.txt，其内容如下。
001,Rajiv,Reddy,9848022337,Hyderabad 002,siddarth,Battacharya,9848022338,Kolkata 003,Rajesh,Khanna,9848022339,Delhi 004,Preethi,Agarwal,9848022330,Pune 005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 006,Archana,Mishra,9848022335,Chennai.
我们已经使用 LOAD 运算符将其读入关系学生中，如下所示。
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );
现在，让我们使用解释运算符解释名为 student 的关系，如下所示。
grunt> explain student;
输出
它将产生以下输出。
$ explain student;
2015-10-05 11:32:43,660 [main]
2015-10-05 11:32:43,660 [main] INFO org.apache.pig.newplan.logical.optimizer
.LogicalPlanOptimizer -
{RULES_ENABLED=[AddForEach, ColumnMapKeyPrune, ConstantCalculator,
GroupByConstParallelSetter, LimitOptimizer, LoadTypeCastInserter, MergeFilter,
MergeForEach, PartitionFilterOptimizer, PredicatePushdownOptimizer,
PushDownForEachFlatten, PushUpFilter, SplitFilter, StreamTypeCastInserter]}
#-----------------------------------------------
# New Logical Plan:
#-----------------------------------------------
student: (Name: LOStore Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)
|
|---student: (Name: LOForEach Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)
| |
| (Name: LOGenerate[false,false,false,false,false] Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)ColumnPrune:InputUids=[34, 35, 32, 33,
31]ColumnPrune:OutputUids=[34, 35, 32, 33, 31]
| | |
| | (Name: Cast Type: int Uid: 31)
| | | | | |---id:(Name: Project Type: bytearray Uid: 31 Input: 0 Column: (*))
| | |
| | (Name: Cast Type: chararray Uid: 32)
| | |
| | |---firstname:(Name: Project Type: bytearray Uid: 32 Input: 1
Column: (*))
| | |
| | (Name: Cast Type: chararray Uid: 33)
| | |
| | |---lastname:(Name: Project Type: bytearray Uid: 33 Input: 2
Column: (*))
| | |
| | (Name: Cast Type: chararray Uid: 34)
| | |
| | |---phone:(Name: Project Type: bytearray Uid: 34 Input: 3 Column:
(*))
| | |
| | (Name: Cast Type: chararray Uid: 35)
| | |
| | |---city:(Name: Project Type: bytearray Uid: 35 Input: 4 Column:
(*))
| |
| |---(Name: LOInnerLoad[0] Schema: id#31:bytearray)
| |
| |---(Name: LOInnerLoad[1] Schema: firstname#32:bytearray)
| |
| |---(Name: LOInnerLoad[2] Schema: lastname#33:bytearray)
| |
| |---(Name: LOInnerLoad[3] Schema: phone#34:bytearray)
| |
| |---(Name: LOInnerLoad[4] Schema: city#35:bytearray)
|
|---student: (Name: LOLoad Schema:
id#31:bytearray,firstname#32:bytearray,lastname#33:bytearray,phone#34:bytearray
,city#35:bytearray)RequiredFields:null
#-----------------------------------------------
# Physical Plan: #-----------------------------------------------
student: Store(fakefile:org.apache.pig.builtin.PigStorage) - scope-36
|
|---student: New For Each(false,false,false,false,false)[bag] - scope-35
| |
| Cast[int] - scope-21
| |
| |---Project[bytearray][0] - scope-20
| |
| Cast[chararray] - scope-24
| |
| |---Project[bytearray][1] - scope-23
| |
| Cast[chararray] - scope-27
| |
| |---Project[bytearray][2] - scope-26
| |
| Cast[chararray] - scope-30
| |
| |---Project[bytearray][3] - scope-29
| |
| Cast[chararray] - scope-33
| |
| |---Project[bytearray][4] - scope-32
|
|---student: Load(hdfs://localhost:9000/pig_data/student_data.txt:PigStorage(',')) - scope19
2015-10-05 11:32:43,682 [main]
INFO org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MRCompiler -
File concatenation threshold: 100 optimistic? false
2015-10-05 11:32:43,684 [main]
INFO org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MultiQueryOp timizer -
MR plan size before optimization: 1 2015-10-05 11:32:43,685 [main]
INFO org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.
MultiQueryOp timizer - MR plan size after optimization: 1
#--------------------------------------------------
# Map Reduce Plan
#--------------------------------------------------
MapReduce node scope-37
Map Plan
student: Store(fakefile:org.apache.pig.builtin.PigStorage) - scope-36
|
|---student: New For Each(false,false,false,false,false)[bag] - scope-35
| |
| Cast[int] - scope-21
| |
| |---Project[bytearray][0] - scope-20
| |
| Cast[chararray] - scope-24
| |
| |---Project[bytearray][1] - scope-23
| |
| Cast[chararray] - scope-27
| |
| |---Project[bytearray][2] - scope-26
| |
| Cast[chararray] - scope-30
| |
| |---Project[bytearray][3] - scope-29
| |
| Cast[chararray] - scope-33
| |
| |---Project[bytearray][4] - scope-32
|
|---student:
Load(hdfs://localhost:9000/pig_data/student_data.txt:PigStorage(',')) - scope
19-------- Global sort: false
----------------
Apache Pig – Illustrate Operator
该演示操作给你一步一步的执行语句序列。
句法
下面给出了说明运算符的语法。
grunt> illustrate Relation_name;
例子
假设我们在 HDFS 中有一个文件student_data.txt，其内容如下。
001,Rajiv,Reddy,9848022337,Hyderabad 002,siddarth,Battacharya,9848022338,Kolkata 003,Rajesh,Khanna,9848022339,Delhi 004,Preethi,Agarwal,9848022330,Pune 005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 006,Archana,Mishra,9848022335,Chennai.
我们已经使用 LOAD 运算符将其读入关系学生中，如下所示。
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );
现在，让我们说明名为 student 的关系，如下所示。
grunt> illustrate student;
输出
执行上述语句后，您将获得以下输出。
grunt> illustrate student; INFO org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.PigMapOnly$M ap - Aliases being processed per job phase (AliasName[line,offset]): M: student[1,10] C: R: --------------------------------------------------------------------------------------------- |student | id:int | firstname:chararray | lastname:chararray | phone:chararray | city:chararray | --------------------------------------------------------------------------------------------- | | 002 | siddarth | Battacharya | 9848022338 | Kolkata | ---------------------------------------------------------------------------------------------
Apache Pig – 组操作员
的GROUP运算符用于组中的数据的一个或多个关系。它收集具有相同密钥的数据。
句法
下面给出了组运算符的语法。
grunt> Group_data = GROUP Relation_name BY age;
例子
假设我们在 HDFS 目录/pig_data/ 中有一个名为student_details.txt的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad 002,siddarth,Battacharya,22,9848022338,Kolkata 003,Rajesh,Khanna,22,9848022339,Delhi 004,Preethi,Agarwal,21,9848022330,Pune 005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 006,Archana,Mishra,23,9848022335,Chennai 007,Komal,Nayak,24,9848022334,trivendram 008,Bharathi,Nambiayar,24,9848022333,Chennai
我们已经将此文件加载到 Apache Pig 中，关系名称为student_details，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);
现在，让我们按年龄对关系中的记录/元组进行分组，如下所示。
grunt> group_data = GROUP student_details by age;
确认
使用DUMP运算符验证关系group_data，如下所示。
grunt> Dump group_data;
输出
然后您将获得显示名为group_data的关系的内容的输出，如下所示。在这里您可以观察到结果模式有两列 –
-
一个是age，我们根据它对关系进行分组。
-
另一个是一个bag，其中包含一组元组，以及各自年龄的学生记录。
(21,{(4,Preethi,Agarwal,21,9848022330,Pune),(1,Rajiv,Reddy,21,9848022337,Hydera bad)})
(22,{(3,Rajesh,Khanna,22,9848022339,Delhi),(2,siddarth,Battacharya,22,984802233 8,Kolkata)})
(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)})
(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)})
您可以在使用describe命令对数据进行分组后查看表的架构，如下所示。
grunt> Describe group_data;
group_data: {group: int,student_details: {(id: int,firstname: chararray,
lastname: chararray,age: int,phone: chararray,city: chararray)}}
同样，您可以使用说明命令获取模式的示例说明，如下所示。
$ Illustrate group_data;
它将产生以下输出 –
-------------------------------------------------------------------------------------------------
|group_data| group:int | student_details:bag{:tuple(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray)}|
-------------------------------------------------------------------------------------------------
| | 21 | { 4, Preethi, Agarwal, 21, 9848022330, Pune), (1, Rajiv, Reddy, 21, 9848022337, Hyderabad)}|
| | 2 | {(2,siddarth,Battacharya,22,9848022338,Kolkata),(003,Rajesh,Khanna,22,9848022339,Delhi)}|
-------------------------------------------------------------------------------------------------
按多列分组
让我们按年龄和城市对关系进行分组，如下所示。
grunt> group_multiple = GROUP student_details by (age, city);
您可以使用 Dump 运算符验证名为group_multiple的关系的内容，如下所示。
grunt> Dump group_multiple;
((21,Pune),{(4,Preethi,Agarwal,21,9848022330,Pune)})
((21,Hyderabad),{(1,Rajiv,Reddy,21,9848022337,Hyderabad)})
((22,Delhi),{(3,Rajesh,Khanna,22,9848022339,Delhi)})
((22,Kolkata),{(2,siddarth,Battacharya,22,9848022338,Kolkata)})
((23,Chennai),{(6,Archana,Mishra,23,9848022335,Chennai)})
((23,Bhuwaneshwar),{(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)})
((24,Chennai),{(8,Bharathi,Nambiayar,24,9848022333,Chennai)})
(24,trivendram),{(7,Komal,Nayak,24,9848022334,trivendram)})
全部分组
您可以按所有列对关系进行分组，如下所示。
grunt> group_all = GROUP student_details All;
现在，验证关系group_all的内容，如下所示。
grunt> Dump group_all;
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334 ,trivendram),
(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336,Bhuw aneshwar),
(4,Preethi,Agarwal,21,9848022330,Pune),(3,Rajesh,Khanna,22,9848022339,Delhi),
(2,siddarth,Battacharya,22,9848022338,Kolkata),(1,Rajiv,Reddy,21,9848022337,Hyd erabad)})
Apache Pig – Cogroup 运营商
该协同组操作员的工作或多或少以同样的方式为集团运营。两个运算符的唯一区别是群运算符通常用于一个关系，而组运算符用于涉及两个或多个关系的语句。
使用 Cogroup 将两个关系分组
假设我们在 HDFS 目录/pig_data/ 中有两个文件，即student_details.txt和employee_details.txt，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad 002,siddarth,Battacharya,22,9848022338,Kolkata 003,Rajesh,Khanna,22,9848022339,Delhi 004,Preethi,Agarwal,21,9848022330,Pune 005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 006,Archana,Mishra,23,9848022335,Chennai 007,Komal,Nayak,24,9848022334,trivendram 008,Bharathi,Nambiayar,24,9848022333,Chennai
员工详细信息.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
我们已经将这些文件分别以student_details和employee_details的关系名加载到Pig 中，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);
grunt> employee_details = LOAD 'hdfs://localhost:9000/pig_data/employee_details.txt' USING PigStorage(',')
as (id:int, name:chararray, age:int, city:chararray);
现在，让我们将关系student_details和employee_details的记录/元组与关键年龄分组，如下所示。
grunt> cogroup_data = COGROUP student_details by age, employee_details by age;
确认
使用DUMP运算符验证关系cogroup_data，如下所示。
grunt> Dump cogroup_data;
输出
它将产生以下输出，显示名为cogroup_data的关系的内容，如下所示。
(21,{(4,Preethi,Agarwal,21,9848022330,Pune), (1,Rajiv,Reddy,21,9848022337,Hyderabad)},
{ })
(22,{ (3,Rajesh,Khanna,22,9848022339,Delhi), (2,siddarth,Battacharya,22,9848022338,Kolkata) },
{ (6,Maggy,22,Chennai),(1,Robin,22,newyork) })
(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)},
{(5,David,23,Bhuwaneshwar),(3,Maya,23,Tokyo),(2,BOB,23,Kolkata)})
(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)},
{ })
(25,{ },
{(4,Sara,25,London)})
在协同组根据年龄，其中每个组示出了特定的年龄值从每个关系操作员组的元组。
例如，如果我们考虑结果的第一个元组，它按年龄 21 分组。它包含两个袋子 –
-
第一个包包含来自第一个关系（在本例中为student_details）的所有 21 岁的元组，并且
-
第二个包包含来自第二个关系（在本例中为employee_details）的所有年龄为 21的元组。
如果关系没有年龄值为 21 的元组，它将返回一个空包。
Apache Pig – 加入运算符
在JOIN操作符是用来记录从两个或两个以上的关系结合起来。在执行连接操作时，我们将每个关系中的一个（或一组）元组声明为键。当这些键匹配时，两个特定的元组匹配，否则记录被删除。连接可以是以下类型 –
- 自加入
- 内部联接
- 外连接 – 左连接、右连接和完全连接
本章通过示例说明如何使用 Pig Latin 中的连接运算符。假设我们在HDFS的/pig_data/目录中有两个文件，customers.txt和orders.txt，如下所示。
客户.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
订单.txt
102,2009-10-08 00:00:00,3,3000 100,2009-10-08 00:00:00,3,1500 101,2009-11-20 00:00:00,2,1560 103,2008-05-20 00:00:00,4,2060
我们已经将这两个文件加载到 Pig 中，其中包含客户和订单的关系，如下所示。
grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
as (id:int, name:chararray, age:int, address:chararray, salary:int);
grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')
as (oid:int, date:chararray, customer_id:int, amount:int);
现在让我们对这两个关系执行各种 Join 操作。
自加入
自联接用于将表与自身联接，就好像该表是两个关系一样，临时重命名至少一个关系。
通常，在 Apache Pig 中，为了执行自联接，我们会在不同的别名（名称）下多次加载相同的数据。因此，让我们将文件customers.txt的内容加载为两个表，如下所示。
grunt> customers1 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
as (id:int, name:chararray, age:int, address:chararray, salary:int);
grunt> customers2 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
as (id:int, name:chararray, age:int, address:chararray, salary:int);
句法
下面给出了使用JOIN运算符执行自联接操作的语法。
grunt> Relation3_name = JOIN Relation1_name BY key, Relation2_name BY key ;
例子
让我们对关系customers进行自连接操作，通过连接两个关系customers1和customers2，如下所示。
grunt> customers3 = JOIN customers1 BY id, customers2 BY id;
确认
使用DUMP运算符验证关系customers3，如下所示。
grunt> Dump customers3;
输出
它将产生以下输出，显示关系customers的内容。
(1,Ramesh,32,Ahmedabad,2000,1,Ramesh,32,Ahmedabad,2000) (2,Khilan,25,Delhi,1500,2,Khilan,25,Delhi,1500) (3,kaushik,23,Kota,2000,3,kaushik,23,Kota,2000) (4,Chaitali,25,Mumbai,6500,4,Chaitali,25,Mumbai,6500) (5,Hardik,27,Bhopal,8500,5,Hardik,27,Bhopal,8500) (6,Komal,22,MP,4500,6,Komal,22,MP,4500) (7,Muffy,24,Indore,10000,7,Muffy,24,Indore,10000)
内部联接
Inner Join使用非常频繁；它也称为equijoin。当两个表中存在匹配时，内部联接返回行。
它通过基于连接谓词组合两个关系（例如 A 和 B）的列值来创建新关系。该查询将 A 的每一行与 B 的每一行进行比较，以找到满足连接谓词的所有行对。当满足连接谓词时，A 和 B 的每对匹配的行的列值组合成一个结果行。
句法
下面是使用JOIN运算符执行内连接操作的语法。
grunt> result = JOIN relation1 BY columnname, relation2 BY columnname;
例子
让我们对客户和订单这两个关系进行内连接操作，如下所示。
grunt> coustomer_orders = JOIN customers BY id, orders BY customer_id;
确认
使用DUMP运算符验证关系coustomer_orders，如下所示。
grunt> Dump coustomer_orders;
输出
您将获得以下输出，其中包含名为coustomer_orders的关系的内容。
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) (3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500) (3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000) (4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
注意–
外连接：与内连接不同，外连接返回来自至少一个关系的所有行。外连接操作以三种方式进行 –
- 左外连接
- 右外连接
- 全外连接
左外连接
在LEFT OUTER JOIN操作返回的所有行左表中，即使是在正确的关系不匹配。
句法
下面给出了使用JOIN运算符执行左外连接操作的语法。
grunt> Relation3_name = JOIN Relation1_name BY id LEFT OUTER, Relation2_name BY customer_id;
例子
让我们对两个关系客户和订单执行左外连接操作，如下所示。
grunt> outer_left = JOIN customers BY id LEFT OUTER, orders BY customer_id;
确认
使用DUMP运算符验证关系outer_left，如下所示。
grunt> Dump outer_left;
输出
它将产生以下输出，显示关系outer_left的内容。
(1,Ramesh,32,Ahmedabad,2000,,,,) (2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) (3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500) (3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000) (4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060) (5,Hardik,27,Bhopal,8500,,,,) (6,Komal,22,MP,4500,,,,) (7,Muffy,24,Indore,10000,,,,)
右外连接
在右外连接操作返回的所有行右表中，即使有左表中的不匹配。
句法
下面给出了使用JOIN运算符执行右外连接操作的语法。
grunt> outer_right = JOIN customers BY id RIGHT, orders BY customer_id;
例子
让我们对两个关系客户和订单执行右外连接操作，如下所示。
grunt> outer_right = JOIN customers BY id RIGHT, orders BY customer_id;
确认
使用DUMP运算符验证关系outer_right，如下所示。
grunt> Dump outer_right
输出
它将产生以下输出，显示关系outer_right的内容。
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) (3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500) (3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000) (4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
全外连接
当其中一个关系匹配时，全外连接操作返回行。
句法
下面给出了使用JOIN运算符执行完全外连接的语法。
grunt> outer_full = JOIN customers BY id FULL OUTER, orders BY customer_id;
例子
让我们对两个关系客户和订单执行全外连接操作，如下所示。
grunt> outer_full = JOIN customers BY id FULL OUTER, orders BY customer_id;
确认
使用DUMP运算符验证关系outer_full，如下所示。
grun> Dump outer_full;
输出
它将产生以下输出，显示关系outer_full的内容。
(1,Ramesh,32,Ahmedabad,2000,,,,) (2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) (3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500) (3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000) (4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060) (5,Hardik,27,Bhopal,8500,,,,) (6,Komal,22,MP,4500,,,,) (7,Muffy,24,Indore,10000,,,,)
使用多个键
我们可以使用多个键来执行 JOIN 操作。
句法
以下是如何使用多个键对两个表执行 JOIN 操作。
grunt> Relation3_name = JOIN Relation2_name BY (key1, key2), Relation3_name BY (key1, key2);
假设我们在HDFS的/pig_data/目录中有两个文件，即employee.txt和employee_contact.txt，如下所示。
员工.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
员工联系人.txt
001,9848022337,[email protected],Hyderabad,003 002,9848022338,[email protected],Kolkata,003 003,9848022339,[email protected],Delhi,003 004,9848022330,[email protected],Pune,003 005,9848022336,[email protected],Bhuwaneshwar,003 006,9848022335,[email protected],Chennai,003 007,9848022334,[email protected],trivendram,002 008,9848022333,[email protected],Chennai,001
我们已经将这两个文件加载到 Pig 中，其关系为employee和employee_contact，如下所示。
grunt> employee = LOAD 'hdfs://localhost:9000/pig_data/employee.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray, age:int, designation:chararray, jobid:int);
grunt> employee_contact = LOAD 'hdfs://localhost:9000/pig_data/employee_contact.txt' USING PigStorage(',')
as (id:int, phone:chararray, email:chararray, city:chararray, jobid:int);
现在，让我们使用JOIN运算符连接这两个关系的内容，如下所示。
grunt> emp = JOIN employee BY (id,jobid), employee_contact BY (id,jobid);
确认
使用DUMP运算符验证关系emp，如下所示。
grunt> Dump emp;
输出
它将产生以下输出，显示名为emp的关系的内容，如下所示。
(1,Rajiv,Reddy,21,programmer,113,1,9848022337,[email protected],Hyderabad,113) (2,siddarth,Battacharya,22,programmer,113,2,9848022338,[email protected],Kolka ta,113) (3,Rajesh,Khanna,22,programmer,113,3,9848022339,[email protected],Delhi,113) (4,Preethi,Agarwal,21,programmer,113,4,9848022330,[email protected],Pune,113) (5,Trupthi,Mohanthy,23,programmer,113,5,9848022336,[email protected],Bhuwaneshw ar,113) (6,Archana,Mishra,23,programmer,113,6,9848022335,[email protected],Chennai,113) (7,Komal,Nayak,24,teamlead,112,7,9848022334,[email protected],trivendram,112) (8,Bharathi,Nambiayar,24,manager,111,8,9848022333,[email protected],Chennai,111)
Apache Pig – 交叉运算符
该CROSS操作符计算两个或两个以上关系的跨产品。本章举例说明如何在 Pig Latin 中使用交叉运算符。
句法
下面给出了CROSS运算符的语法。
grunt> Relation3_name = CROSS Relation1_name, Relation2_name;
例子
假设我们在HDFS的/pig_data/目录中有两个文件，customers.txt和orders.txt，如下所示。
客户.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
订单.txt
102,2009-10-08 00:00:00,3,3000 100,2009-10-08 00:00:00,3,1500 101,2009-11-20 00:00:00,2,1560 103,2008-05-20 00:00:00,4,2060
我们已经将这两个文件加载到 Pig 中，其中包含客户和订单的关系，如下所示。
grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
as (id:int, name:chararray, age:int, address:chararray, salary:int);
grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')
as (oid:int, date:chararray, customer_id:int, amount:int);
现在让我们在这两个关系上使用交叉运算符来获得这两个关系的叉积，如下所示。
grunt> cross_data = CROSS customers, orders;
确认
使用DUMP运算符验证关系cross_data，如下所示。
grunt> Dump cross_data;
输出
它将产生以下输出，显示关系cross_data的内容。
(7,Muffy,24,Indore,10000,103,2008-05-20 00:00:00,4,2060) (7,Muffy,24,Indore,10000,101,2009-11-20 00:00:00,2,1560) (7,Muffy,24,Indore,10000,100,2009-10-08 00:00:00,3,1500) (7,Muffy,24,Indore,10000,102,2009-10-08 00:00:00,3,3000) (6,Komal,22,MP,4500,103,2008-05-20 00:00:00,4,2060) (6,Komal,22,MP,4500,101,2009-11-20 00:00:00,2,1560) (6,Komal,22,MP,4500,100,2009-10-08 00:00:00,3,1500) (6,Komal,22,MP,4500,102,2009-10-08 00:00:00,3,3000) (5,Hardik,27,Bhopal,8500,103,2008-05-20 00:00:00,4,2060) (5,Hardik,27,Bhopal,8500,101,2009-11-20 00:00:00,2,1560) (5,Hardik,27,Bhopal,8500,100,2009-10-08 00:00:00,3,1500) (5,Hardik,27,Bhopal,8500,102,2009-10-08 00:00:00,3,3000) (4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060) (4,Chaitali,25,Mumbai,6500,101,2009-20 00:00:00,4,2060) (2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) (2,Khilan,25,Delhi,1500,100,2009-10-08 00:00:00,3,1500) (2,Khilan,25,Delhi,1500,102,2009-10-08 00:00:00,3,3000) (1,Ramesh,32,Ahmedabad,2000,103,2008-05-20 00:00:00,4,2060) (1,Ramesh,32,Ahmedabad,2000,101,2009-11-20 00:00:00,2,1560) (1,Ramesh,32,Ahmedabad,2000,100,2009-10-08 00:00:00,3,1500) (1,Ramesh,32,Ahmedabad,2000,102,2009-10-08 00:00:00,3,3000)-11-20 00:00:00,2,1560) (4,Chaitali,25,Mumbai,6500,100,2009-10-08 00:00:00,3,1500) (4,Chaitali,25,Mumbai,6500,102,2009-10-08 00:00:00,3,3000) (3,kaushik,23,Kota,2000,103,2008-05-20 00:00:00,4,2060) (3,kaushik,23,Kota,2000,101,2009-11-20 00:00:00,2,1560) (3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500) (3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000) (2,Khilan,25,Delhi,1500,103,2008-05-20 00:00:00,4,2060) (2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) (2,Khilan,25,Delhi,1500,100,2009-10-08 00:00:00,3,1500) (2,Khilan,25,Delhi,1500,102,2009-10-08 00:00:00,3,3000) (1,Ramesh,32,Ahmedabad,2000,103,2008-05-20 00:00:00,4,2060) (1,Ramesh,32,Ahmedabad,2000,101,2009-11-20 00:00:00,2,1560) (1,Ramesh,32,Ahmedabad,2000,100,2009-10-08 00:00:00,3,1500) (1,Ramesh,32,Ahmedabad,2000,102,2009-10-08 00:00:00,3,3000)
Apache Pig – 联合运营商
Pig Latin的UNION运算符用于合并两个关系的内容。要对两个关系执行 UNION 操作，它们的列和域必须相同。
句法
下面给出了UNION运算符的语法。
grunt> Relation_name3 = UNION Relation_name1, Relation_name2;
例子
假设我们在HDFS的/pig_data/目录中有两个文件，即student_data1.txt和student_data2.txt，如下所示。
学生数据1.txt
001,Rajiv,Reddy,9848022337,Hyderabad 002,siddarth,Battacharya,9848022338,Kolkata 003,Rajesh,Khanna,9848022339,Delhi 004,Preethi,Agarwal,9848022330,Pune 005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 006,Archana,Mishra,9848022335,Chennai.
Student_data2.txt
7,Komal,Nayak,9848022334,trivendram. 8,Bharathi,Nambiayar,9848022333,Chennai.
我们已经将这两个文件加载到 Pig 中，关系为student1和student2，如下所示。
grunt> student1 = LOAD 'hdfs://localhost:9000/pig_data/student_data1.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);
grunt> student2 = LOAD 'hdfs://localhost:9000/pig_data/student_data2.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);
现在让我们使用UNION运算符合并这两个关系的内容，如下所示。
grunt> student = UNION student1, student2;
确认
使用DUMP运算符验证关系学生，如下所示。
grunt> Dump student;
输出
它将显示以下输出，显示关系student的内容。
(1,Rajiv,Reddy,9848022337,Hyderabad) (2,siddarth,Battacharya,9848022338,Kolkata) (3,Rajesh,Khanna,9848022339,Delhi) (4,Preethi,Agarwal,9848022330,Pune) (5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar) (6,Archana,Mishra,9848022335,Chennai) (7,Komal,Nayak,9848022334,trivendram) (8,Bharathi,Nambiayar,9848022333,Chennai)
Apache Pig – 拆分运算符
该SPLIT运算符用于关系分成两个或更多的关系。
句法
下面给出了SPLIT运算符的语法。
grunt> SPLIT Relation1_name INTO Relation2_name IF (condition1), Relation2_name (condition2),
例子
假设我们在 HDFS 目录/pig_data/ 中有一个名为student_details.txt的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad 002,siddarth,Battacharya,22,9848022338,Kolkata 003,Rajesh,Khanna,22,9848022339,Delhi 004,Preethi,Agarwal,21,9848022330,Pune 005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 006,Archana,Mishra,23,9848022335,Chennai 007,Komal,Nayak,24,9848022334,trivendram 008,Bharathi,Nambiayar,24,9848022333,Chennai
我们已经将此文件加载到 Pig 中，关系名称为student_details，如下所示。
student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);
现在让我们将关系分成两部分，一个列出年龄小于 23 岁的员工，另一个列出年龄在 22 到 25 岁之间的员工。
SPLIT student_details into student_details1 if age<23, student_details2 if (22<age and age>25);
确认
使用DUMP运算符验证student_details1和student_details2关系，如下所示。
grunt> Dump student_details1; grunt> Dump student_details2;
输出
它将产生以下输出，分别显示关系student_details1和student_details2的内容。
grunt> Dump student_details1; (1,Rajiv,Reddy,21,9848022337,Hyderabad) (2,siddarth,Battacharya,22,9848022338,Kolkata) (3,Rajesh,Khanna,22,9848022339,Delhi) (4,Preethi,Agarwal,21,9848022330,Pune) grunt> Dump student_details2; (5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar) (6,Archana,Mishra,23,9848022335,Chennai) (7,Komal,Nayak,24,9848022334,trivendram) (8,Bharathi,Nambiayar,24,9848022333,Chennai)
Apache Pig – 过滤器操作符
的FILTER运算符用于从基于条件的关系选择所需的元组。
句法
下面给出了FILTER运算符的语法。
grunt> Relation2_name = FILTER Relation1_name BY (condition);
例子
假设我们在 HDFS 目录/pig_data/ 中有一个名为student_details.txt的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad 002,siddarth,Battacharya,22,9848022338,Kolkata 003,Rajesh,Khanna,22,9848022339,Delhi 004,Preethi,Agarwal,21,9848022330,Pune 005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 006,Archana,Mishra,23,9848022335,Chennai 007,Komal,Nayak,24,9848022334,trivendram 008,Bharathi,Nambiayar,24,9848022333,Chennai
我们已经将此文件加载到 Pig 中，关系名称为student_details，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);
现在让我们使用 Filter 运算符来获取属于 Chennai 市的学生的详细信息。
filter_data = FILTER student_details BY city == 'Chennai';
确认
使用DUMP运算符验证关系filter_data，如下所示。
grunt> Dump filter_data;
输出
它将产生以下输出，显示关系filter_data的内容如下。
(6,Archana,Mishra,23,9848022335,Chennai) (8,Bharathi,Nambiayar,24,9848022333,Chennai)
Apache Pig – 独特的运营商
该DISTINCT运算符用于从关系去除冗余（一式两份）的元组。
句法
下面给出的是DISTINCT运算符的语法。
grunt> Relation_name2 = DISTINCT Relatin_name1;
例子
假设我们在 HDFS 目录/pig_data/ 中有一个名为student_details.txt的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,9848022337,Hyderabad 002,siddarth,Battacharya,9848022338,Kolkata 002,siddarth,Battacharya,9848022338,Kolkata 003,Rajesh,Khanna,9848022339,Delhi 003,Rajesh,Khanna,9848022339,Delhi 004,Preethi,Agarwal,9848022330,Pune 005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar 006,Archana,Mishra,9848022335,Chennai 006,Archana,Mishra,9848022335,Chennai
我们已经将此文件加载到 Pig 中，关系名称为student_details，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);
现在让我们使用DISTINCT运算符从名为student_details的关系中删除冗余（重复）元组，并将其存储为另一个名为distinct_data 的关系，如下所示。
grunt> distinct_data = DISTINCT student_details;
确认
使用DUMP运算符验证关系distinct_data，如下所示。
grunt> Dump distinct_data;
输出
它将产生以下输出，显示关系distinct_data的内容如下。
(1,Rajiv,Reddy,9848022337,Hyderabad) (2,siddarth,Battacharya,9848022338,Kolkata) (3,Rajesh,Khanna,9848022339,Delhi) (4,Preethi,Agarwal,9848022330,Pune) (5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar) (6,Archana,Mishra,9848022335,Chennai)
Apache Pig – Foreach 操作员
所述FOREACH运算符用于基于所述列数据指定的数据转换。
句法
下面给出的是FOREACH运算符的语法。
grunt> Relation_name2 = FOREACH Relatin_name1 GENERATE (required data);
例子
假设我们在 HDFS 目录/pig_data/ 中有一个名为student_details.txt的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad 002,siddarth,Battacharya,22,9848022338,Kolkata 003,Rajesh,Khanna,22,9848022339,Delhi 004,Preethi,Agarwal,21,9848022330,Pune 005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 006,Archana,Mishra,23,9848022335,Chennai 007,Komal,Nayak,24,9848022334,trivendram 008,Bharathi,Nambiayar,24,9848022333,Chennai
我们已经将此文件加载到 Pig 中，关系名称为student_details，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);
现在让我们从关系student_details中获取每个学生的 id、age 和 city 值，并使用foreach运算符将其存储到另一个名为foreach_data 的关系中，如下所示。
grunt> foreach_data = FOREACH student_details GENERATE id,age,city;
确认
使用DUMP运算符验证foreach_data关系，如下所示。
grunt> Dump foreach_data;
输出
它将产生以下输出，显示关系foreach_data的内容。
(1,21,Hyderabad) (2,22,Kolkata) (3,22,Delhi) (4,21,Pune) (5,23,Bhuwaneshwar) (6,23,Chennai) (7,24,trivendram) (8,24,Chennai)
Apache Pig – 订购方式
的ORDER BY运算符用于基于一个或多个字段的排序顺序来显示关系的内容。
句法
下面给出的是ORDER BY运算符的语法。
grunt> Relation_name2 = ORDER Relatin_name1 BY (ASC|DESC);
例子
假设我们在 HDFS 目录/pig_data/ 中有一个名为student_details.txt的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad 002,siddarth,Battacharya,22,9848022338,Kolkata 003,Rajesh,Khanna,22,9848022339,Delhi 004,Preethi,Agarwal,21,9848022330,Pune 005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 006,Archana,Mishra,23,9848022335,Chennai 007,Komal,Nayak,24,9848022334,trivendram 008,Bharathi,Nambiayar,24,9848022333,Chennai
我们已经将此文件加载到 Pig 中，关系名称为student_details，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);
现在让我们根据学生的年龄按降序对关系进行排序，并使用ORDER BY运算符将其存储到另一个名为order_by_data 的关系中，如下所示。
grunt> order_by_data = ORDER student_details BY age DESC;
确认
使用DUMP运算符验证关系order_by_data，如下所示。
grunt> Dump order_by_data;
输出
它将产生以下输出，显示关系order_by_data的内容。
(8,Bharathi,Nambiayar,24,9848022333,Chennai) (7,Komal,Nayak,24,9848022334,trivendram) (6,Archana,Mishra,23,9848022335,Chennai) (5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar) (3,Rajesh,Khanna,22,9848022339,Delhi) (2,siddarth,Battacharya,22,9848022338,Kolkata) (4,Preethi,Agarwal,21,9848022330,Pune) (1,Rajiv,Reddy,21,9848022337,Hyderabad)
Apache Pig – 限制运算符
该LIMIT运算符用于从关系中获得的元组的数量有限。
句法
下面给出了LIMIT运算符的语法。
grunt> Result = LIMIT Relation_name required number of tuples;
例子
假设我们在 HDFS 目录/pig_data/ 中有一个名为student_details.txt的文件，如下所示。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad 002,siddarth,Battacharya,22,9848022338,Kolkata 003,Rajesh,Khanna,22,9848022339,Delhi 004,Preethi,Agarwal,21,9848022330,Pune 005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 006,Archana,Mishra,23,9848022335,Chennai 007,Komal,Nayak,24,9848022334,trivendram 008,Bharathi,Nambiayar,24,9848022333,Chennai
我们已经将此文件加载到 Pig 中，关系名称为student_details，如下所示。
grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);
现在，让我们根据学生的年龄按降序对关系进行排序，并使用ORDER BY运算符将其存储到另一个名为limit_data 的关系中，如下所示。
grunt> limit_data = LIMIT student_details 4;
确认
使用DUMP运算符验证关系limit_data，如下所示。
grunt> Dump limit_data;
输出
它将产生以下输出，显示关系limit_data的内容如下。
(1,Rajiv,Reddy,21,9848022337,Hyderabad) (2,siddarth,Battacharya,22,9848022338,Kolkata) (3,Rajesh,Khanna,22,9848022339,Delhi) (4,Preethi,Agarwal,21,9848022330,Pune)
Apache Pig – 评估函数
Apache Pig 提供了各种内置函数，即eval、load、store、math、string、bag和tuple函数。
评估函数
下面给出了 Apache Pig 提供的eval函数列表。
| S.N. | 功能说明 |
|---|---|
| 1 | AVG()
计算袋子内数值的平均值。 |
| 2 | BagToString()
将包的元素连接成一个字符串。在连接时，我们可以在这些值之间放置一个分隔符（可选）。 |
| 3 | CONCAT()
连接两个或多个相同类型的表达式。 |
| 4 | COUNT()
获取包中元素的数量，同时计算包中元组的数量。 |
| 5 | COUNT_STAR()
它类似于COUNT()函数。它用于获取包中元素的数量。 |
| 6 | DIFF()
比较元组中的两个包（字段）。 |
| 7 | IsEmpty()
检查包或地图是否为空。 |
| 8 | MAX()
计算单列包中某列（数值或字符数组）的最高值。 |
| 9 | MIN()
获取单列包中某个列的最小（最低）值（数字或字符数组）。 |
| 10 | PluckTuple()
使用 Pig Latin PluckTuple()函数，我们可以定义字符串 Prefix 并过滤以给定前缀开头的关系中的列。 |
| 11 | SIZE()
根据任何 Pig 数据类型计算元素数。 |
| 12 | SUBTRACT()
减去两袋。它需要两个包作为输入并返回一个包，其中包含第一个包中不在第二个包中的元组。 |
| 13 | SUM()
获取单列包中某列的数值总和。 |
| 14 | TOKENIZE()
在单个元组中拆分字符串（包含一组单词）并返回一个包含拆分操作输出的包。 |
Apache Pig – 加载和存储函数
Apache Pig 中的Load和Store函数用于确定数据如何从 Pig 中流出。这些函数与加载和存储操作符一起使用。下面给出了 Pig 中可用的加载和存储函数列表。
| S.N. | 功能说明 |
|---|---|
| 1 | PigStorage()
加载和存储结构化文件。 |
| 2 | TextLoader()
将非结构化数据加载到 Pig。 |
| 3 | BinStorage()
使用机器可读格式将数据加载和存储到 Pig。 |
| 4 | Handling Compression
在 Pig Latin 中，我们可以加载和存储压缩数据。 |
Apache Pig – 包和元组函数
下面给出了 Bag 和 Tuple 函数的列表。
| S.N. | 功能说明 |
|---|---|
| 1 | TOBAG()
将两个或多个表达式转换为一个包。 |
| 2 | TOP()
获取关系的前N 个元组。 |
| 3 | TOTUPLE()
将一个或多个表达式转换为一个元组。 |
| 4 | TOMAP()
将键值对转换为 Map。 |
Apache Pig – 字符串函数
我们在 Apache Pig 中有以下字符串函数。
| S.N. | 功能和说明 |
|---|---|
| 1 | ENDSWITH(string, testAgainst)
验证给定的字符串是否以特定的子字符串结尾。 |
| 2 | STARTSWITH(string, substring)
接受两个字符串参数并验证第一个字符串是否以第二个字符串开头。 |
| 3 | SUBSTRING(string, startIndex, stopIndex)
从给定的字符串返回一个子字符串。 |
| 4 | EqualsIgnoreCase(string1, string2)
忽略大小写来比较两个刺。 |
| 5 | INDEXOF(string, ‘character’, startIndex)
返回字符串中第一次出现的字符，从起始索引向前搜索。 |
| 6 | LAST_INDEX_OF(expression)
返回字符串中最后一次出现字符的索引，从起始索引向后搜索。 |
| 7 | LCFIRST(expression)
将字符串中的第一个字符转换为小写。 |
| 8 | UCFIRST(expression)
返回第一个字符转换为大写的字符串。 |
| 9 | UPPER(expression)
UPPER(expression) 返回转换为大写的字符串。 |
| 10 | LOWER(expression)
将字符串中的所有字符转换为小写。 |
| 11 | REPLACE(string, ‘oldChar’, ‘newChar’);
用新字符替换字符串中的现有字符。 |
| 12 | STRSPLIT(string, regex, limit)
围绕给定正则表达式的匹配拆分字符串。 |
| 13 | STRSPLITTOBAG(string, regex, limit)
类似于STRSPLIT()函数，它通过给定的分隔符分割字符串并将结果返回到一个包中。 |
| 14 | TRIM(expression)
返回删除了前导和尾随空格的字符串副本。 |
| 15 | LTRIM(expression)
返回删除前导空格的字符串副本。 |
| 16 | RTRIM(expression)
返回删除了尾随空格的字符串副本。 |
Apache Pig – 日期时间函数
Apache Pig 提供以下日期和时间函数 –
| S.N. | 功能和说明 |
|---|---|
| 1 | ToDate(milliseconds)
这个函数根据给定的参数返回一个日期时间对象。此函数的另一种选择是 ToDate(iosstring)、ToDate(userstring、format)、ToDate(userstring、format、timezone) |
| 2 | CurrentTime()
返回当前时间的日期时间对象。 |
| 3 | GetDay(datetime)
从日期时间对象返回一个月中的第几天。 |
| 4 | GetHour(datetime)
从日期时间对象返回一天中的小时。 |
| 5 | GetMilliSecond(datetime)
从日期时间对象返回一秒的毫秒数。 |
| 6 | GetMinute(datetime)
从日期时间对象返回一小时的分钟数。 |
| 7 | GetMonth(datetime)
从日期时间对象返回一年中的月份。 |
| 8 | GetSecond(datetime)
从日期时间对象返回一分钟的秒数。 |
| 9 | GetWeek(datetime)
从日期时间对象返回一年中的第几周。 |
| 10 | GetWeekYear(datetime)
从日期时间对象返回周年。 |
| 11 | GetYear(datetime)
从日期时间对象返回年份。 |
| 12 | AddDuration(datetime, duration)
返回日期时间对象的结果以及持续时间对象。 |
| 13 | SubtractDuration(datetime, duration)
从 Date-Time 对象中减去 Duration 对象并返回结果。 |
| 14 | DaysBetween(datetime1, datetime2)
返回两个日期时间对象之间的天数。 |
| 15 | HoursBetween(datetime1, datetime2)
返回两个日期时间对象之间的小时数。 |
| 16 | MilliSecondsBetween(datetime1, datetime2)
返回两个日期时间对象之间的毫秒数。 |
| 17 | MinutesBetween(datetime1, datetime2)
返回两个日期时间对象之间的分钟数。 |
| 18 | MonthsBetween(datetime1, datetime2)
返回两个日期时间对象之间的月数。 |
| 19 | SecondsBetween(datetime1, datetime2)
返回两个日期时间对象之间的秒数。 |
| 20 | WeeksBetween(datetime1, datetime2)
返回两个日期时间对象之间的周数。 |
| 21 | YearsBetween(datetime1, datetime2)
返回两个日期时间对象之间的年数。 |
Apache Pig – 数学函数
我们在 Apache Pig 中有以下数学函数 –
| S.N. | 功能和说明 |
|---|---|
| 1 | ABS(expression)
获取表达式的绝对值。 |
| 2 | ACOS(expression)
获取表达式的反余弦值。 |
| 3 | ASIN(expression)
获取表达式的反正弦。 |
| 4 | ATAN(expression)
此函数用于获取表达式的反正切。 |
| 5 | CBRT(expression)
此函数用于获取表达式的立方根。 |
| 6 | CEIL(expression)
此函数用于获取四舍五入到最接近的整数的表达式的值。 |
| 7 | COS(expression)
此函数用于获取表达式的三角余弦。 |
| 8 | COSH(expression)
此函数用于获取表达式的双曲余弦值。 |
| 9 | EXP(expression)
该函数用于得到欧拉数 e 的 x 次方。 |
| 10 | FLOOR(expression)
获取四舍五入到最接近的整数的表达式的值。 |
| 11 | LOG(expression)
获取表达式的自然对数（以 e 为底）。 |
| 12 | LOG10(expression)
获取以 10 为底的表达式的对数。 |
| 13 | RANDOM( )
获取大于或等于 0.0 且小于 1.0 的伪随机数（双精度型）。 |
| 14 | ROUND(expression)
获取四舍五入为整数（如果结果类型为浮点数）或四舍五入为长整数（如果结果类型为双精度）的表达式的值。 |
| 15 | SIN(expression)
获取表达式的正弦值。 |
| 16 | SINH(expression)
获取表达式的双曲正弦值。 |
| 17 | SQRT(expression)
得到一个表达式的正平方根。 |
| 18 | TAN(expression)
得到一个角的三角正切。 |
| 19 | TANH(expression)
获取表达式的双曲正切值。 |
Apache Pig – 用户定义的函数
除了内置的功能，Apache的猪提供了广泛的支持ü SER d efined ˚F unctions（UDF的）。使用这些 UDF，我们可以定义我们自己的函数并使用它们。UDF 支持以六种编程语言提供，即 Java、Jython、Python、JavaScript、Ruby 和 Groovy。
对于编写 UDF，Java 提供了完整的支持，所有其余语言提供了有限的支持。使用 Java，您可以编写涉及处理的所有部分（如数据加载/存储、列转换和聚合）的 UDF。由于 Apache Pig 是用 Java 编写的，因此与其他语言相比，使用 Java 语言编写的 UDF 工作效率更高。
在 Apache Pig 中，我们还有一个名为Piggybank 的UDF 的 Java 存储库。使用 Piggybank，我们可以访问其他用户编写的 Java UDF，并贡献我们自己的 UDF。
Java 中 UDF 的类型
在使用 Java 编写 UDF 时，我们可以创建和使用以下三种类型的函数 –
-
过滤器函数– 过滤器函数用作过滤器语句中的条件。这些函数接受一个 Pig 值作为输入并返回一个布尔值。
-
Eval 函数– Eval 函数用于 FOREACH-GENERATE 语句。这些函数接受一个 Pig 值作为输入并返回一个 Pig 结果。
-
代数函数– 代数函数作用于 FOREACHGENERATE 语句中的内袋。这些函数用于对内袋执行完整的 MapReduce 操作。
使用 Java 编写 UDF
要使用 Java 编写 UDF，我们必须集成 jar 文件Pig-0.15.0.jar。在本节中，我们将讨论如何使用 Eclipse 编写示例 UDF。在继续之前，请确保您已经在系统中安装了 Eclipse 和 Maven。
按照下面给出的步骤编写 UDF 函数 –
-
打开 Eclipse 并创建一个新项目（比如myproject）。
-
将新创建的项目转换为 Maven 项目。
-
将以下内容复制到 pom.xml 中。此文件包含 Apache Pig 和 Hadoop 核心 jar 文件的 Maven 依赖项。
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0http://maven.apache .org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>Pig_Udf</groupId>
<artifactId>Pig_Udf</artifactId>
<version>0.0.1-SNAPSHOT</version>
<build>
<sourceDirectory>src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.3</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.pig</groupId>
<artifactId>pig</artifactId>
<version>0.15.0</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-core</artifactId>
<version>0.20.2</version>
</dependency>
</dependencies>
</project>
-
保存文件并刷新它。在Maven Dependencies部分，您可以找到下载的 jar 文件。
-
创建一个名为Sample_Eval的新类文件，并将以下内容复制到其中。
import java.io.IOException;
import org.apache.pig.EvalFunc;
import org.apache.pig.data.Tuple;
import java.io.IOException;
import org.apache.pig.EvalFunc;
import org.apache.pig.data.Tuple;
public class Sample_Eval extends EvalFunc<String>{
public String exec(Tuple input) throws IOException {
if (input == null || input.size() == 0)
return null;
String str = (String)input.get(0);
return str.toUpperCase();
}
}
在编写 UDF 时，必须继承 EvalFunc 类并为exec()函数提供实现。在此函数中，编写了 UDF 所需的代码。在上面的示例中，我们返回了将给定列的内容转换为大写的代码。
-
编译类没有错误后，右键单击 Sample_Eval.java 文件。它给你一个菜单。选择导出，如下面的屏幕截图所示。
-
单击export，您将看到以下窗口。单击JAR 文件。
-
单击Next>按钮继续。您将获得另一个窗口，您需要在其中输入本地文件系统中的路径，您需要在其中存储 jar 文件。
-
最后点击完成按钮。在指定的文件夹中，会创建一个 Jar 文件sample_udf.jar。这个 jar 文件包含用 Java 编写的 UDF。
使用 UDF
编写 UDF 并生成 Jar 文件后，请按照以下步骤操作 –
第一步：注册Jar文件
在编写 UDF（在 Java 中）之后，我们必须使用 Register 运算符注册包含 UDF 的 Jar 文件。通过注册 Jar 文件，用户可以将 UDF 的位置告知 Apache Pig。
句法
下面给出了 Register 运算符的语法。
REGISTER path;
例子
作为示例，让我们注册本章前面创建的 sample_udf.jar。
在本地模式下启动Apache Pig并注册jar文件sample_udf.jar，如下所示。
$cd PIG_HOME/bin $./pig –x local REGISTER '/$PIG_HOME/sample_udf.jar'
注意– 假设路径中的 Jar 文件 – /$PIG_HOME/sample_udf.jar
步骤 2：定义别名
注册 UDF 后，我们可以使用Define运算符为其定义别名。
句法
下面给出了定义运算符的语法。
DEFINE alias {function | [`command` [input] [output] [ship] [cache] [stderr] ] };
例子
定义 sample_eval 的别名，如下所示。
DEFINE sample_eval sample_eval();
第 3 步：使用 UDF
定义别名后，您可以使用与内置函数相同的 UDF。假设HDFS /Pig_Data/目录下有一个名为emp_data的文件，内容如下。
001,Robin,22,newyork 002,BOB,23,Kolkata 003,Maya,23,Tokyo 004,Sara,25,London 005,David,23,Bhuwaneshwar 006,Maggy,22,Chennai 007,Robert,22,newyork 008,Syam,23,Kolkata 009,Mary,25,Tokyo 010,Saran,25,London 011,Stacy,25,Bhuwaneshwar 012,Kelly,22,Chennai
假设我们已经将这个文件加载到 Pig 中，如下所示。
grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp1.txt' USING PigStorage(',')
as (id:int, name:chararray, age:int, city:chararray);
现在让我们使用 UDF sample_eval将员工姓名转换为大写。
grunt> Upper_case = FOREACH emp_data GENERATE sample_eval(name);
验证关系Upper_case的内容，如下所示。
grunt> Dump Upper_case; (ROBIN) (BOB) (MAYA) (SARA) (DAVID) (MAGGY) (ROBERT) (SYAM) (MARY) (SARAN) (STACY) (KELLY)
Apache Pig – 运行脚本
在本章中，我们将看到如何以批处理模式运行 Apache Pig 脚本。
Pig Script中的评论
在文件中编写脚本时，我们可以在其中包含注释，如下所示。
多行注释
我们将以’/*’开始多行注释，以’*/’结束它们。
/* These are the multi-line comments In the pig script */
单行注释
我们将以“–”开始单行注释。
--we can write single line comments like this.
在批处理模式下执行 Pig 脚本
在批处理模式下执行 Apache Pig 语句时，请按照以下步骤操作。
步骤1
在单个文件中写入所有必需的 Pig Latin 语句。我们可以在一个文件中编写所有 Pig Latin 语句和命令，并将其保存为.pig文件。
第2步
执行 Apache Pig 脚本。您可以从 shell (Linux) 执行 Pig 脚本，如下所示。
| Local mode | MapReduce 模式 |
|---|---|
| $ pig -x local Sample_script.pig | $ pig -x mapreduce Sample_script.pig |
您也可以使用 exec 命令从 Grunt shell 执行它，如下所示。
grunt> exec /sample_script.pig
从 HDFS 执行 Pig 脚本
我们还可以执行驻留在 HDFS 中的 Pig 脚本。假设在名为/pig_data/的 HDFS 目录中有一个名为Sample_script.pig的 Pig 脚本。我们可以执行它，如下所示。
$ pig -x mapreduce hdfs://localhost:9000/pig_data/Sample_script.pig
例子
假设我们在 HDFS 中有一个文件student_details.txt，其内容如下。
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad 002,siddarth,Battacharya,22,9848022338,Kolkata 003,Rajesh,Khanna,22,9848022339,Delhi 004,Preethi,Agarwal,21,9848022330,Pune 005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 006,Archana,Mishra,23,9848022335,Chennai 007,Komal,Nayak,24,9848022334,trivendram 008,Bharathi,Nambiayar,24,9848022333,Chennai
我们还有一个名为sample_script.pig的示例脚本，位于同一个 HDFS 目录中。该文件包含对学生关系执行操作和转换的语句，如下所示。
student = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);
student_order = ORDER student BY age DESC;
student_limit = LIMIT student_order 4;
Dump student_limit;
-
该脚本的第一条语句将加载名为student_details.txt的文件中的数据作为名为student的关系。
-
脚本的第二条语句将根据年龄按降序排列关系的元组，并将其存储为student_order。
-
脚本的第三条语句将student_order的前 4 个元组存储为student_limit。
-
最后，第四条语句将转储关系student_limit的内容。
现在让我们执行sample_script.pig，如下所示。
$./pig -x mapreduce hdfs://localhost:9000/pig_data/sample_script.pig
Apache Pig 被执行并为您提供包含以下内容的输出。
(7,Komal,Nayak,24,9848022334,trivendram) (8,Bharathi,Nambiayar,24,9848022333,Chennai) (5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar) (6,Archana,Mishra,23,9848022335,Chennai) 2015-10-19 10:31:27,446 [main] INFO org.apache.pig.Main - Pig script completed in 12 minutes, 32 seconds and 751 milliseconds (752751 ms)
