ApachePig-クイックガイド

Apache Pigとは何ですか？

Apache Pigは、MapReduceを抽象化したものです。これは、データフローとしてそれらを表すより大きなデータセットを分析するために使用されるツール/プラットフォームです。豚は一般的にHadoop; Apache Pigを使用して、Hadoopですべてのデータ操作操作を実行できます。

データ分析プログラムを作成するために、Pigは次のような高級言語を提供しています。 Pig Latin。この言語は、プログラマーがデータの読み取り、書き込み、および処理のための独自の関数を開発できるさまざまな演算子を提供します。

を使用してデータを分析するには Apache Pig、プログラマーはピッグラテン語を使用してスクリプトを書く必要があります。これらのスクリプトはすべて、内部でMapタスクとReduceタスクに変換されます。Apache Pigには、Pig Engine これは、Pig Latinスクリプトを入力として受け入れ、それらのスクリプトをMapReduceジョブに変換します。

なぜApachePigが必要なのですか？

Javaがあまり得意ではないプログラマーは、通常、特にMapReduceタスクを実行しているときに、Hadoopでの作業に苦労していました。Apache Pigは、そのようなすべてのプログラマーにとって恩恵です。

使用する Pig Latin、プログラマーは、Javaで複雑なコードを入力しなくても、MapReduceタスクを簡単に実行できます。
ApachePigは multi-query approach、それによってコードの長さを短縮します。たとえば、Javaで200行のコード（LoC）を入力する必要がある操作は、ApachePigでわずか10LoCと入力するだけで簡単に実行できます。最終的に、ApachePigは開発時間をほぼ16分の1に短縮します。
ピッグラテンは SQL-like language また、SQLに精通していれば、ApachePigを簡単に学ぶことができます。
Apache Pigは、結合、フィルター、順序付けなどのデータ操作をサポートするための多くの組み込み演算子を提供します。さらに、MapReduceにないタプル、バッグ、マップなどのネストされたデータ型も提供します。

豚の特徴

Apache Pigには、次の機能があります-

Rich set of operators −結合、ソート、ファイラーなどの操作を実行するための多くの演算子を提供します。
Ease of programming − Pig LatinはSQLに似ており、SQLが得意であれば、Pigスクリプトを簡単に作成できます。
Optimization opportunities − Apache Pigのタスクは実行を自動的に最適化するため、プログラマーは言語のセマンティクスのみに集中する必要があります。
Extensibility −既存の演算子を使用して、ユーザーはデータの読み取り、処理、および書き込みを行う独自の関数を開発できます。
UDF’s − Pigは、作成する機能を提供します User-defined Functions Javaなどの他のプログラミング言語で、それらを呼び出したり、Pigスクリプトに埋め込んだりします。
Handles all kinds of data− Apache Pigは、構造化および非構造化の両方のあらゆる種類のデータを分析します。結果をHDFSに保存します。

ApachePigとMapReduce

以下にリストされているのは、ApachePigとMapReduceの主な違いです。

アパッチピッグ	MapReduce
ApachePigはデータフロー言語です。	MapReduceは、データ処理パラダイムです。
それは高級言語です。	MapReduceは低レベルで、堅固です。
ApachePigで結合操作を実行するのは非常に簡単です。	MapReduceでは、データセット間で結合操作を実行することは非常に困難です。
SQLの基本的な知識を持っている初心者プログラマーなら誰でも、ApachePigを簡単に使用できます。	Javaへの露出は、MapReduceと連携する必要があります。
Apache Pigはマルチクエリアプローチを使用しているため、コードの長さが大幅に短縮されます。	MapReduceは、同じタスクを実行するためにほぼ20倍の行数を必要とします。
コンパイルする必要はありません。実行時に、すべてのApachePigオペレーターは内部でMapReduceジョブに変換されます。	MapReduceジョブには長いコンパイルプロセスがあります。

ApachePigとSQL

以下にリストされているのは、ApachePigとSQLの主な違いです。

豚	SQL
ピッグラテンは procedural 言語。	SQLは declarative 言語。
Apache Pigでは、 schemaオプションです。スキーマを設計せずにデータを保存できます（値は次のように保存されます）$01, $02など）	SQLではスキーマは必須です。
ApachePigのデータモデルは nested relational。	SQLで使用されるデータモデル is flat relational。
Apache Pigは、 Query optimization。	SQLではクエリを最適化する機会が増えます。

上記の違いに加えて、Apache Pig Latin −

パイプラインでの分割を許可します。
開発者がパイプラインのどこにでもデータを保存できるようにします。
実行計画を宣言します。
ETL（抽出、変換、およびロード）機能を実行するための演算子を提供します。

ApachePigとHive

Apache PigとHiveの両方を使用して、MapReduceジョブを作成します。また、場合によっては、HiveはApachePigと同様の方法でHDFS上で動作します。次の表に、ApachePigをHiveと区別するいくつかの重要なポイントを示します。

アパッチピッグ	ハイブ
Apache Pigは、 Pig Latin。もともとはで作成されましたYahoo。	Hiveはと呼ばれる言語を使用します HiveQL。もともとはで作成されましたFacebook。
PigLatinはデータフロー言語です。	HiveQLはクエリ処理言語です。
Pig Latinは手続き型言語であり、パイプラインパラダイムに適合します。	HiveQLは宣言型言語です。
Apache Pigは、構造化データ、非構造化データ、および半構造化データを処理できます。	Hiveは主に構造化データ用です。

ApachePigのアプリケーション

Apache Pigは通常、アドホック処理とラピッドプロトタイピングを含むタスクを実行するためにデータサイエンティストによって使用されます。ApachePigが使用されています-

Webログなどの巨大なデータソースを処理するため。
検索プラットフォームのデータ処理を実行します。
時間に敏感なデータのロードを処理します。

Apache Pig –歴史

に 2006、Apache Pigは、特にすべてのデータセットでMapReduceジョブを作成および実行するために、Yahooの研究プロジェクトとして開発されました。に2007、ApachePigはApacheインキュベーターを介してオープンソース化されました。に2008、ApachePigの最初のリリースが出ました。に2010、ApachePigはApacheトップレベルプロジェクトとして卒業しました。

Pigを使用してHadoopのデータを分析するために使用される言語は、 Pig Latin。これは、データに対してさまざまな操作を実行するための豊富なデータ型と演算子のセットを提供する高レベルのデータ処理言語です。

Pigを使用するプログラマーが特定のタスクを実行するには、プログラマーはPig Latin言語を使用してPigスクリプトを記述し、実行メカニズム（Grunt Shell、UDF、Embedded）のいずれかを使用してそれらを実行する必要があります。実行後、これらのスクリプトは、Pig Frameworkによって適用される一連の変換を経て、目的の出力を生成します。

内部的には、Apache Pigはこれらのスクリプトを一連のMapReduceジョブに変換するため、プログラマーの作業が簡単になります。ApachePigのアーキテクチャを以下に示します。

ApachePigコンポーネント

図に示すように、ApachePigフレームワークにはさまざまなコンポーネントがあります。主要なコンポーネントを見てみましょう。

パーサー

当初、Pigスクリプトはパーサーによって処理されます。スクリプトの構文をチェックし、型チェックやその他のその他のチェックを行います。パーサーの出力はDAG（有向非巡回グラフ）になります。これは、PigLatinステートメントと論理演算子を表します。

DAGでは、スクリプトの論理演算子はノードとして表され、データフローはエッジとして表されます。

オプティマイザ

論理計画（DAG）は、論理オプティマイザーに渡されます。論理オプティマイザーは、プロジェクションやプッシュダウンなどの論理最適化を実行します。

コンパイラ

コンパイラーは、最適化された論理プランを一連のMapReduceジョブにコンパイルします。

実行エンジン

最後に、MapReduceジョブがソートされた順序でHadoopに送信されます。最後に、これらのMapReduceジョブがHadoopで実行され、目的の結果が生成されます。

ピッグラテンデータモデル

Pig Latinのデータモデルは完全にネストされており、次のような複雑な非アトミックデータ型を使用できます。 map そして tuple。以下に示すのは、PigLatinのデータモデルの図式表現です。

原子

ピッグラテン語の単一の値は、データに関係なく、タイプはとして知られています。 Atom。文字列として保存され、文字列と数値として使用できます。int、long、float、double、chararray、およびbytearrayは、Pigのアトミック値です。データの一部または単純なアトミック値は、field。

Example −「ラジャ」または「30」

タプル

順序付けられたフィールドのセットによって形成されるレコードはタプルと呼ばれ、フィールドは任意のタイプにすることができます。タプルは、RDBMSのテーブルの行に似ています。

Example −（ラジャ、30）

バッグ

バッグは、順序付けられていないタプルのセットです。言い換えると、タプルのコレクション（一意ではない）はバッグとして知られています。各タプルは、任意の数のフィールド（柔軟なスキーマ）を持つことができます。バッグは「{}」で表されます。これはRDBMSのテーブルに似ていますが、RDBMSのテーブルとは異なり、すべてのタプルに同じ数のフィールドが含まれている必要はなく、同じ位置（列）のフィールドが同じタイプである必要もありません。

Example − {（ラジャ、30）、（モハマド、45）}

バッグは関係のフィールドになることができます。その文脈では、それはとして知られていますinner bag。

Example− {Raja、30、{9848022338、raja @ gmail.com、} }

地図

マップ（またはデータマップ）は、キーと値のペアのセットです。ザ・keychararray型である必要があり、一意である必要があります。ザ・valueどんなタイプでもかまいません。'[]'で表されます

Example − [名前＃ラジャ、年齢＃30]

関係

関係はタプルのバッグです。Pig Latinの関係は順序付けられていません（タプルが特定の順序で処理される保証はありません）。

この章では、ダウンロード、インストール、およびセットアップの方法について説明します Apache Pig あなたのシステムで。

前提条件

Apache Pigを使用する前に、システムにHadoopとJavaがインストールされていることが重要です。したがって、Apache Pigをインストールする前に、次のリンクに記載されている手順に従ってHadoopとJavaをインストールしてください。

http://www.tutorialspoint.com/hadoop/hadoop_enviornment_setup.htm

ApachePigをダウンロードする

まず、次のWebサイトからApachePigの最新バージョンをダウンロードします- https://pig.apache.org/

ステップ1

Apache PigWebサイトのホームページを開きます。セクションの下News, リンクをクリックしてください release page 次のスナップショットに示すように。

ステップ2

指定されたリンクをクリックすると、にリダイレクトされます Apache Pig Releasesページ。このページのDownload セクションには、2つのリンクがあります。 Pig 0.8 and later そして Pig 0.7 and before。リンクをクリックしてくださいPig 0.8 and later、次に、ミラーのセットがあるページにリダイレクトされます。

ステップ3

以下に示すように、これらのミラーのいずれかを選択してクリックします。

ステップ4

これらの鏡はあなたを Pig Releasesページ。このページには、さまざまなバージョンのApachePigが含まれています。その中から最新バージョンをクリックしてください。

ステップ5

これらのフォルダー内には、さまざまなディストリビューションのApachePigのソースファイルとバイナリファイルがあります。Apache Pig0.15のソースファイルとバイナリファイルのtarファイルをダウンロードします。pig0.15.0-src.tar.gz そして pig-0.15.0.tar.gz.

ApachePigをインストールします

Apache Pigソフトウェアをダウンロードしたら、以下の手順に従ってLinux環境にインストールします。

ステップ1

のインストールディレクトリと同じディレクトリにPigという名前のディレクトリを作成します。 Hadoop, Java,およびその他のソフトウェアがインストールされました。（このチュートリアルでは、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/

ApachePigを構成する

Apache Pigをインストールした後、構成する必要があります。設定するには、2つのファイルを編集する必要があります-bashrc and pig.properties。

.bashrcファイル

の中に .bashrc file, set the following variables −

PIG_HOME folder to the Apache Pig’s installation folder,
PATH environment variable to the bin folder, and
PIG_CLASSPATH environment variable to the etc (configuration) folder of your Hadoop installations (the directory that contains the core-site.xml, hdfs-site.xml and mapred-site.xml files).

export PIG_HOME = /home/Hadoop/Pig
export PATH  = $PATH:/home/Hadoop/pig/bin
export PIG_CLASSPATH = $HADOOP_HOME/conf

pig.properties file

In the conf folder of Pig, we have a file named pig.properties. In the pig.properties file, you can set various parameters as given below.

pig -h properties

The following properties are supported −

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.

Verifying the Installation

Verify the installation of Apache Pig by typing the version command. If the installation is successful, you will get the version of Apache Pig as shown below.

$ pig –version 
 
Apache Pig version 0.15.0 (r1682971)  
compiled Jun 01 2015, 11:44:35

In the previous chapter, we explained how to install Apache Pig. In this chapter, we will discuss how to execute Apache Pig.

Apache Pig Execution Modes

You can run Apache Pig in two modes, namely, Local Mode and HDFS mode.

Local Mode

In this mode, all the files are installed and run from your local host and local file system. There is no need of Hadoop or HDFS. This mode is generally used for testing purpose.

MapReduce Mode

MapReduce mode is where we load or process the data that exists in the Hadoop File System (HDFS) using Apache Pig. In this mode, whenever we execute the Pig Latin statements to process the data, a MapReduce job is invoked in the back-end to perform a particular operation on the data that exists in the HDFS.

Apache Pig Execution Mechanisms

Apache Pig scripts can be executed in three ways, namely, interactive mode, batch mode, and embedded mode.

Interactive Mode (Grunt shell) − You can run Apache Pig in interactive mode using the Grunt shell. In this shell, you can enter the Pig Latin statements and get the output (using Dump operator).
Batch Mode (Script) − You can run Apache Pig in Batch mode by writing the Pig Latin script in a single file with .pig extension.
Embedded Mode (UDF) − Apache Pig provides the provision of defining our own functions (User Defined Functions) in programming languages such as Java, and using them in our script.

Invoking the Grunt Shell

You can invoke the Grunt shell in a desired mode (local/MapReduce) using the −x option as shown below.

Local mode	MapReduce mode
Command − $ ./pig –x local	Command − $ ./pig -x mapreduce
Output −	Output −

Either of these commands gives you the Grunt shell prompt as shown below.

grunt>

You can exit the Grunt shell using ‘ctrl + d’.

After invoking the Grunt shell, you can execute a Pig script by directly entering the Pig Latin statements in it.

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

Executing Apache Pig in Batch Mode

You can write an entire Pig Latin script in a file and execute it using the –x command. Let us suppose we have a Pig script in a file named sample_script.pig as shown below.

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING
   PigStorage(',') as (id:int,name:chararray,city:chararray);
  
Dump student;

Now, you can execute the script in the above file as shown below.

Local mode	MapReduce mode
$ pig -x local Sample_script.pig	$ pig -x mapreduce Sample_script.pig

Note − We will discuss in detail how to run a Pig script in Bach mode and in embedded mode in subsequent chapters.

After invoking the Grunt shell, you can run your Pig scripts in the shell. In addition to that, there are certain useful shell and utility commands provided by the Grunt shell. This chapter explains the shell and utility commands provided by the Grunt shell.

Note − In some portions of this chapter, the commands like Load and Store are used. Refer the respective chapters to get in-detail information on them.

Shell Commands

The Grunt shell of Apache Pig is mainly used to write Pig Latin scripts. Prior to that, we can invoke any shell commands using sh and fs.

sh Command

Using sh command, we can invoke any shell commands from the Grunt shell. Using sh command from the Grunt shell, we cannot execute the commands that are a part of the shell environment (ex − cd).

Syntax

Given below is the syntax of sh command.

grunt> sh shell command parameters

Example

We can invoke the ls command of Linux shell from the Grunt shell using the sh option as shown below. In this example, it lists out the files in the /pig/bin/ directory.

grunt> sh ls
   
pig 
pig_1444799121955.log 
pig.cmd 
pig.py

fs Command

Using the fs command, we can invoke any FsShell commands from the Grunt shell.

Syntax

Given below is the syntax of fs command.

grunt> sh File System command parameters

Example

We can invoke the ls command of HDFS from the Grunt shell using fs command. In the following example, it lists the files in the HDFS root directory.

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

In the same way, we can invoke all the other file system shell commands from the Grunt shell using the fs command.

Utility Commands

The Grunt shell provides a set of utility commands. These include utility commands such as clear, help, history, quit, and set; and commands such as exec, kill, and run to control Pig from the Grunt shell. Given below is the description of the utility commands provided by the Grunt shell.

clear Command

The clear command is used to clear the screen of the Grunt shell.

Syntax

You can clear the screen of the grunt shell using the clear command as shown below.

grunt> clear

help Command

The help command gives you a list of Pig commands or Pig properties.

Usage

You can get a list of Pig commands using the help command as shown below.

grunt> help

Commands: <pig latin statement>; - See the PigLatin manual for details:
http://hadoop.apache.org/pig
  
File system commands:fs <fs arguments> - Equivalent to Hadoop dfs  command:
http://hadoop.apache.org/common/docs/current/hdfs_shell.html
	 
Diagnostic Commands:describe <alias>[::<alias] - Show the schema for the alias.
Inner aliases can be described as A::B.
    explain [-script <pigscript>] [-out <path>] [-brief] [-dot|-xml] 
       [-param <param_name>=<pCram_value>]
       [-param_file <file_name>] [<alias>] - 
       Show the execution plan to compute the alias or for entire script.
       -script - Explain the entire script.
       -out - Store the output into directory rather than print to stdout.
       -brief - Don't expand nested plans (presenting a smaller graph for overview).
       -dot - Generate the output in .dot format. Default is text format.
       -xml - Generate the output in .xml format. Default is text format.
       -param <param_name - See parameter substitution for details.
       -param_file <file_name> - See parameter substitution for details.
       alias - Alias to explain.
       dump <alias> - Compute the alias and writes the results to stdout.

Utility Commands: exec [-param <param_name>=param_value] [-param_file <file_name>] <script> -
       Execute the script with access to grunt environment including aliases.
       -param <param_name - See parameter substitution for details.
       -param_file <file_name> - See parameter substitution for details.
       script - Script to be executed.
    run [-param <param_name>=param_value] [-param_file <file_name>] <script> -
       Execute the script with access to grunt environment.
		 -param <param_name - See parameter substitution for details.         
       -param_file <file_name> - See parameter substitution for details.
       script - Script to be executed.
    sh  <shell command> - Invoke a shell command.
    kill <job_id> - Kill the hadoop job specified by the hadoop job id.
    set <key> <value> - Provide execution parameters to Pig. Keys and values are case sensitive.
       The following keys are supported:
       default_parallel - Script-level reduce parallelism. Basic input size heuristics used 
       by default.
       debug - Set debug on or off. Default is off.
       job.name - Single-quoted name for jobs. Default is PigLatin:<script name>     
       job.priority - Priority for jobs. Values: very_low, low, normal, high, very_high.
       Default is normal stream.skippath - String that contains the path.
       This is used by streaming any hadoop property.
    help - Display this message.
    history [-n] - Display the list statements in cache.
       -n Hide line numbers.
    quit - Quit the grunt shell.

history Command

This command displays a list of statements executed / used so far since the Grunt sell is invoked.

Usage

Assume we have executed three statements since opening the 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(',');

Then, using the history command will produce the following output.

grunt> history

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

set Command

The set command is used to show/assign values to keys used in Pig.

Usage

Using this command, you can set values to the following keys.

Key	Description and values
default_parallel	You can set the number of reducers for a map job by passing any whole number as a value to this key.
debug	You can turn off or turn on the debugging freature in Pig by passing on/off to this key.
job.name	You can set the Job name to the required job by passing a string value to this key.
job.priority	You can set the job priority to a job by passing one of the following values to this key − very_low low normal high very_high
stream.skippath	For streaming, you can set the path from where the data is not to be transferred, by passing the desired path in the form of a string to this key.

quit Command

You can quit from the Grunt shell using this command.

Usage

Quit from the Grunt shell as shown below.

grunt> quit

Let us now take a look at the commands using which you can control Apache Pig from the Grunt shell.

exec Command

Using the exec command, we can execute Pig scripts from the Grunt shell.

Syntax

Given below is the syntax of the utility command exec.

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

Example

Let us assume there is a file named student.txt in the /pig_data/ directory of HDFS with the following content.

Student.txt

001,Rajiv,Hyderabad
002,siddarth,Kolkata
003,Rajesh,Delhi

And, assume we have a script file named sample_script.pig in the /pig_data/ directory of HDFS with the following content.

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',') 
   as (id:int,name:chararray,city:chararray);
  
Dump student;

Now, let us execute the above script from the Grunt shell using the exec command as shown below.

grunt> exec /sample_script.pig

Output

The exec command executes the script in the sample_script.pig. As directed in the script, it loads the student.txt file into Pig and gives you the result of the Dump operator displaying the following content.

(1,Rajiv,Hyderabad)
(2,siddarth,Kolkata)
(3,Rajesh,Delhi)

kill Command

You can kill a job from the Grunt shell using this command.

Syntax

Given below is the syntax of the kill command.

grunt> kill JobId

Example

Suppose there is a running Pig job having id Id_0055, you can kill it from the Grunt shell using the kill command, as shown below.

grunt> kill Id_0055

run Command

You can run a Pig script from the Grunt shell using the run command

Syntax

Given below is the syntax of the run command.

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

Example

Let us assume there is a file named student.txt in the /pig_data/ directory of HDFS with the following content.

Student.txt

001,Rajiv,Hyderabad
002,siddarth,Kolkata
003,Rajesh,Delhi

And, assume we have a script file named sample_script.pig in the local filesystem with the following content.

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING
   PigStorage(',') as (id:int,name:chararray,city:chararray);

Now, let us run the above script from the Grunt shell using the run command as shown below.

grunt> run /sample_script.pig

You can see the output of the script using the Dump operator as shown below.

grunt> Dump;

(1,Rajiv,Hyderabad)
(2,siddarth,Kolkata)
(3,Rajesh,Delhi)

Note − The difference between exec and the run command is that if we use run, the statements from the script are available in the command history.

Pig Latin is the language used to analyze data in Hadoop using Apache Pig. In this chapter, we are going to discuss the basics of Pig Latin such as Pig Latin statements, data types, general and relational operators, and Pig Latin UDF’s.

Pig Latin – Data Model

As discussed in the previous chapters, the data model of Pig is fully nested. A Relation is the outermost structure of the Pig Latin data model. And it is a bag where −

A bag is a collection of tuples.
A tuple is an ordered set of fields.
A field is a piece of data.

Pig Latin – Statemets

While processing data using Pig Latin, statements are the basic constructs.

These statements work with relations. They include expressions and schemas.
Every statement ends with a semicolon (;).
We will perform various operations using operators provided by Pig Latin, through statements.
Except LOAD and STORE, while performing all other operations, Pig Latin statements take a relation as input and produce another relation as output.
As soon as you enter a Load statement in the Grunt shell, its semantic checking will be carried out. To see the contents of the schema, you need to use the Dump operator. Only after performing the dump operation, the MapReduce job for loading the data into the file system will be carried out.

Example

Given below is a Pig Latin statement, which loads data to Apache Pig.

grunt> Student_data = LOAD 'student_data.txt' USING PigStorage(',')as 
   ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

Pig Latin – Data types

Given below table describes the Pig Latin data types.

S.N.	Data Type	Description & Example
1	int	Represents a signed 32-bit integer. Example : 8
2	long	Represents a signed 64-bit integer. Example : 5L
3	float	Represents a signed 32-bit floating point. Example : 5.5F
4	double	Represents a 64-bit floating point. Example : 10.5
5	chararray	Represents a character array (string) in Unicode UTF-8 format. Example : ‘tutorials point’
6	Bytearray	Represents a Byte array (blob).
7	Boolean	Represents a Boolean value. Example : true/ false.
8	Datetime	Represents a date-time. Example : 1970-01-01T00:00:00.000+00:00
9	Biginteger	Represents a Java BigInteger. Example : 60708090709
10	Bigdecimal	Represents a Java BigDecimal Example : 185.98376256272893883
Complex Types
11	Tuple	A tuple is an ordered set of fields. Example : (raja, 30)
12	Bag	A bag is a collection of tuples. Example : {(raju,30),(Mohhammad,45)}
13	Map	A Map is a set of key-value pairs. Example : [ ‘name’#’Raju’, ‘age’#30]

Null Values

Values for all the above data types can be NULL. Apache Pig treats null values in a similar way as SQL does.

A null can be an unknown value or a non-existent value. It is used as a placeholder for optional values. These nulls can occur naturally or can be the result of an operation.

Pig Latin – Arithmetic Operators

The following table describes the arithmetic operators of Pig Latin. Suppose a = 10 and b = 20.

Operator	Description	Example
+	Addition − Adds values on either side of the operator	a + b will give 30
−	Subtraction − Subtracts right hand operand from left hand operand	a − b will give −10
*	Multiplication − Multiplies values on either side of the operator	a * b will give 200
/	Division − Divides left hand operand by right hand operand	b / a will give 2
%	Modulus − Divides left hand operand by right hand operand and returns remainder	b % a will give 0
? :	Bincond − Evaluates the Boolean operators. It has three operands as shown below. variable x = (expression) ? value1 if true : value2 if false.	b = (a == 1)? 20: 30; if a=1 the value of b is 20. if a!=1 the value of b is 30.
CASE WHEN THEN ELSE END	Case − The case operator is equivalent to nested bincond operator.	CASE f2 % 2 WHEN 0 THEN 'even' WHEN 1 THEN 'odd' END

Pig Latin – Comparison Operators

The following table describes the comparison operators of Pig Latin.

Operator	Description	Example
==	Equal − Checks if the values of two operands are equal or not; if yes, then the condition becomes true.	(a = b) is not true
!=	Not Equal − Checks if the values of two operands are equal or not. If the values are not equal, then condition becomes true.	(a != b) is true.
>	Greater than − Checks if the value of the left operand is greater than the value of the right operand. If yes, then the condition becomes true.	(a > b) is not true.
<	Less than − Checks if the value of the left operand is less than the value of the right operand. If yes, then the condition becomes true.	(a < b) is true.
>=	Greater than or equal to − Checks if the value of the left operand is greater than or equal to the value of the right operand. If yes, then the condition becomes true.	(a >= b) is not true.
<=	Less than or equal to − Checks if the value of the left operand is less than or equal to the value of the right operand. If yes, then the condition becomes true.	(a <= b) is true.
matches	Pattern matching − Checks whether the string in the left-hand side matches with the constant in the right-hand side.	f1 matches '.tutorial.'

Pig Latin – Type Construction Operators

The following table describes the Type construction operators of Pig Latin.

Operator	Description	Example
()	Tuple constructor operator − This operator is used to construct a tuple.	(Raju, 30)
{}	Bag constructor operator − This operator is used to construct a bag.	{(Raju, 30), (Mohammad, 45)}
[]	Map constructor operator − This operator is used to construct a tuple.	[name#Raja, age#30]

Pig Latin – Relational Operations

The following table describes the relational operators of Pig Latin.

Operator	Description
Loading and Storing
LOAD	To Load the data from the file system (local/HDFS) into a relation.
STORE	To save a relation to the file system (local/HDFS).
Filtering
FILTER	To remove unwanted rows from a relation.
DISTINCT	To remove duplicate rows from a relation.
FOREACH, GENERATE	To generate data transformations based on columns of data.
STREAM	To transform a relation using an external program.
Grouping and Joining
JOIN	To join two or more relations.
COGROUP	To group the data in two or more relations.
GROUP	To group the data in a single relation.
CROSS	To create the cross product of two or more relations.
Sorting
ORDER	To arrange a relation in a sorted order based on one or more fields (ascending or descending).
LIMIT	To get a limited number of tuples from a relation.
Combining and Splitting
UNION	To combine two or more relations into a single relation.
SPLIT	To split a single relation into two or more relations.
Diagnostic Operators
DUMP	To print the contents of a relation on the console.
DESCRIBE	To describe the schema of a relation.
EXPLAIN	To view the logical, physical, or MapReduce execution plans to compute a relation.
ILLUSTRATE	To view the step-by-step execution of a series of statements.

In general, Apache Pig works on top of Hadoop. It is an analytical tool that analyzes large datasets that exist in the Hadoop File System. To analyze data using Apache Pig, we have to initially load the data into Apache Pig. This chapter explains how to load data to Apache Pig from HDFS.

Preparing HDFS

In MapReduce mode, Pig reads (loads) data from HDFS and stores the results back in HDFS. Therefore, let us start HDFS and create the following sample data in HDFS.

Student ID	First Name	Last Name	Phone	City
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

The above dataset contains personal details like id, first name, last name, phone number and city, of six students.

Step 1: Verifying Hadoop

First of all, verify the installation using Hadoop version command, as shown below.

$ hadoop version

If your system contains Hadoop, and if you have set the PATH variable, then you will get the following output −

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

Step 2: Starting HDFS

Browse through the sbin directory of Hadoop and start yarn and Hadoop dfs (distributed file system) as shown below.

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

Step 3: Create a Directory in HDFS

In Hadoop DFS, you can create directories using the command mkdir. Create a new directory in HDFS with the name Pig_Data in the required path as shown below.

$cd /$Hadoop_Home/bin/ 
$ hdfs dfs -mkdir hdfs://localhost:9000/Pig_Data

Step 4: Placing the data in HDFS

The input file of Pig contains each tuple/record in individual lines. And the entities of the record are separated by a delimiter (In our example we used “,”).

In the local file system, create an input file student_data.txt containing data as shown below.

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.

Now, move the file from the local file system to HDFS using put command as shown below. (You can use copyFromLocal command as well.)

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

Verifying the file

You can use the cat command to verify whether the file has been moved into the HDFS, as shown below.

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

Output

You can see the content of the file as shown below.

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

The Load Operator

You can load data into Apache Pig from the file system (HDFS/ Local) using LOAD operator of Pig Latin.

Syntax

The load statement consists of two parts divided by the “=” operator. On the left-hand side, we need to mention the name of the relation where we want to store the data, and on the right-hand side, we have to define how we store the data. Given below is the syntax of the Load operator.

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

Where,

relation_name − We have to mention the relation in which we want to store the data.
Input file path − We have to mention the HDFS directory where the file is stored. (In MapReduce mode)
function − We have to choose a function from the set of load functions provided by Apache Pig (BinStorage, JsonLoader, PigStorage, TextLoader).
Schema − We have to define the schema of the data. We can define the required schema as follows −

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

Note − We load the data without specifying the schema. In that case, the columns will be addressed as $01, $02, etc… (check).

Example

As an example, let us load the data in student_data.txt in Pig under the schema named Student using the LOAD command.

Start the Pig Grunt Shell

First of all, open the Linux terminal. Start the Pig Grunt shell in MapReduce mode as shown below.

$ Pig –x mapreduce

It will start the Pig Grunt shell as shown below.

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>

Loadステートメントを実行します

次に、ファイルからデータをロードします student_data.txt Gruntシェルで次のPigLatinステートメントを実行して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 );

以下は、上記のステートメントの説明です。

関係名

データをスキーマに保存しました student。

入力ファイルパス

ファイルからデータを読み取っています student_data.txt, これは、HDFSの/ pig_data /ディレクトリにあります。

ストレージ機能

私たちは使用しました PigStorage()関数。データを構造化テキストファイルとしてロードおよび保存します。タプルの各エンティティを区切る区切り文字をパラメータとして使用します。デフォルトでは、パラメータとして「\ t」を取ります。

スキーマ

以下のスキーマを使用してデータを保存しました。

カラム	id	ファーストネーム	苗字	電話	市
データ・タイプ	int	char配列	char配列	char配列	char配列

Note − loadステートメントは、Pigで指定されたリレーションにデータをロードするだけです。の実行を確認するにはLoad ステートメント、あなたは使用する必要があります Diagnostic Operators これについては、次の章で説明します。

前の章では、ApachePigにデータをロードする方法を学びました。ロードされたデータは、を使用してファイルシステムに保存できます。storeオペレーター。この章では、を使用してApachePigにデータを保存する方法について説明します。Store オペレーター。

構文

以下に、Storeステートメントの構文を示します。

STORE Relation_name INTO ' required_directory_path ' [USING function];

例

ファイルがあると仮定します student_data.txt 次のコンテンツを含むHDFSで。

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 以下に示すように、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

まず、という名前のディレクトリ内のファイルを一覧表示します pig_output を使用して ls 以下に示すコマンド。

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

を実行した後、2つのファイルが作成されたことがわかります。 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

ザ・ loadステートメントは、ApachePigで指定されたリレーションにデータをロードするだけです。の実行を確認するにはLoad ステートメント、あなたは使用する必要があります Diagnostic Operators。Pig Latinは、4つの異なるタイプの診断演算子を提供します-

ダンプオペレーター
演算子の説明
説明演算子
イラストオペレーター

この章では、PigLatinのダンプ演算子について説明します。

ダンプオペレーター

ザ・ Dump演算子は、Pig Latinステートメントを実行し、結果を画面に表示するために使用されます。これは通常、デバッグ目的で使用されます。

構文

以下に示すのは、 Dump オペレーター。

grunt> Dump Relation_Name

例

ファイルがあると仮定します student_data.txt 次のコンテンツを含むHDFSで。

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 以下に示すように、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 operator 以下に示すように。

grunt> Dump student

上記を実行したら Pig Latinステートメントでは、HDFSからデータを読み取るためにMapReduceジョブを開始します。次の出力が生成されます。

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)

ザ・ describe 演算子は、リレーションのスキーマを表示するために使用されます。

構文

の構文 describe 演算子は次のとおりです-

grunt> Describe Relation_name

例

ファイルがあると仮定します student_data.txt 次のコンテンツを含むHDFSで。

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 以下に示すように、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 }

ザ・ explain 演算子は、リレーションの論理、物理、およびMapReduce実行プランを表示するために使用されます。

構文

以下に示すのは、 explain オペレーター。

grunt> explain Relation_name;

例

ファイルがあると仮定します student_data.txt 次のコンテンツを含むHDFSで。

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 以下に示すように、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という名前の関係を使用して説明しましょう。 explain 以下に示す演算子。

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
 ----------------

ザ・ illustrate 演算子を使用すると、一連のステートメントを段階的に実行できます。

構文

以下に示すのは、 illustrate オペレーター。

grunt> illustrate Relation_name;

例

ファイルがあると仮定します student_data.txt 次のコンテンツを含むHDFSで。

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 以下に示すように、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        |
---------------------------------------------------------------------------------------------

ザ・ GROUP演算子は、データを1つ以上のリレーションにグループ化するために使用されます。同じキーを持つデータを収集します。

構文

以下に示すのは、 group オペレーター。

grunt> Group_data = GROUP Relation_name BY age;

例

名前の付いたファイルがあると仮定します student_details.txt HDFSディレクトリ内 /pig_data/ 以下に示すように。

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' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

ここで、以下に示すように、レコード/タプルを年齢別にグループ化します。

grunt> group_data = GROUP student_details by age;

検証

関係を確認する group_data を使用して DUMP 以下に示す演算子。

grunt> Dump group_data;

出力

次に、という名前のリレーションの内容を表示する出力が表示されます group_data以下に示すように。ここで、結果のスキーマに2つの列があることがわかります-

1つは age、それによって関係をグループ化しました。
もう1つは bag、タプルのグループ、それぞれの年齢の学生レコードが含まれています。

(21,{(4,Preethi,Agarwal,21,9848022330,Pune),(1,Rajiv,Reddy,21,9848022337,Hydera bad)})
(22,{(3,Rajesh,Khanna,22,9848022339,Delhi),(2,siddarth,Battacharya,22,984802233 8,Kolkata)})
(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)})
(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)})

を使用してデータをグループ化すると、テーブルのスキーマを確認できます。 describe 以下に示すコマンド。

grunt> Describe group_data;
  
group_data: {group: int,student_details: {(id: int,firstname: chararray,
               lastname: chararray,age: int,phone: chararray,city: chararray)}}

同様に、を使用してスキーマのサンプル図を取得できます。 illustrate 以下に示すコマンド。

$ Illustrate group_data;

次の出力が生成されます-

------------------------------------------------------------------------------------------------- 
|group_data|  group:int | student_details:bag{:tuple(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray)}|
------------------------------------------------------------------------------------------------- 
|          |     21     | { 4, Preethi, Agarwal, 21, 9848022330, Pune), (1, Rajiv, Reddy, 21, 9848022337, Hyderabad)}| 
|          |     2      | {(2,siddarth,Battacharya,22,9848022338,Kolkata),(003,Rajesh,Khanna,22,9848022339,Delhi)}| 
-------------------------------------------------------------------------------------------------

複数の列によるグループ化

以下に示すように、年齢と都市で関係をグループ化しましょう。

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

名前の付いたリレーションの内容を確認できます 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)})

ザ・ COGROUP演算子は、GROUP演算子とほぼ同じように機能します。2つの演算子の唯一の違いは、group 演算子は通常、1つの関係で使用されますが、 cogroup 演算子は、2つ以上の関係を含むステートメントで使用されます。

Cogroupを使用して2つの関係をグループ化する

つまり、2つのファイルがあると仮定します。 student_details.txt そして employee_details.txt HDFSディレクトリ内 /pig_data/ 以下に示すように。

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai

employee_details.txt

001,Robin,22,newyork 
002,BOB,23,Kolkata 
003,Maya,23,Tokyo 
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai

そして、これらのファイルをリレーション名でPigにロードしました student_details そして employee_details それぞれ、以下に示すように。

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray); 
  
grunt> employee_details = LOAD 'hdfs://localhost:9000/pig_data/employee_details.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);

それでは、関係のレコード/タプルをグループ化しましょう student_details そして employee_details 以下に示すように、キー年齢で。

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

検証

関係を確認する cogroup_data を使用して DUMP 以下に示す演算子。

grunt> Dump cogroup_data;

出力

次の出力が生成され、という名前のリレーションの内容が表示されます。 cogroup_data 以下に示すように。

(21,{(4,Preethi,Agarwal,21,9848022330,Pune), (1,Rajiv,Reddy,21,9848022337,Hyderabad)}, 
   {    })  
(22,{ (3,Rajesh,Khanna,22,9848022339,Delhi), (2,siddarth,Battacharya,22,9848022338,Kolkata) },  
   { (6,Maggy,22,Chennai),(1,Robin,22,newyork) })  
(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)}, 
   {(5,David,23,Bhuwaneshwar),(3,Maya,23,Tokyo),(2,BOB,23,Kolkata)}) 
(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)}, 
   { })  
(25,{   }, 
   {(4,Sara,25,London)})

ザ・ cogroup 演算子は、各関係のタプルを年齢に従ってグループ化します。各グループは特定の年齢値を示します。

たとえば、結果の最初のタプルを検討すると、21歳でグループ化されます。2つのバッグが含まれています-

最初のバッグは、最初の関係からのすべてのタプルを保持します（student_details in this case) having age 21, and
the second bag contains all the tuples from the second relation (employee_details in this case) having age 21.

In case a relation doesn’t have tuples having the age value 21, it returns an empty bag.

The JOIN operator is used to combine records from two or more relations. While performing a join operation, we declare one (or a group of) tuple(s) from each relation, as keys. When these keys match, the two particular tuples are matched, else the records are dropped. Joins can be of the following types −

Self-join
Inner-join
Outer-join − left join, right join, and full join

This chapter explains with examples how to use the join operator in Pig Latin. Assume that we have two files namely customers.txt and orders.txt in the /pig_data/ directory of HDFS as shown below.

customers.txt

1,Ramesh,32,Ahmedabad,2000.00
2,Khilan,25,Delhi,1500.00
3,kaushik,23,Kota,2000.00
4,Chaitali,25,Mumbai,6500.00 
5,Hardik,27,Bhopal,8500.00
6,Komal,22,MP,4500.00
7,Muffy,24,Indore,10000.00

orders.txt

102,2009-10-08 00:00:00,3,3000
100,2009-10-08 00:00:00,3,1500
101,2009-11-20 00:00:00,2,1560
103,2008-05-20 00:00:00,4,2060

And we have loaded these two files into Pig with the relations customers and orders as shown below.

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);

Let us now perform various Join operations on these two relations.

Self - join

Self-join is used to join a table with itself as if the table were two relations, temporarily renaming at least one relation.

Generally, in Apache Pig, to perform self-join, we will load the same data multiple times, under different aliases (names). Therefore let us load the contents of the file customers.txt as two tables as shown below.

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);

Syntax

Given below is the syntax of performing self-join operation using the JOIN operator.

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

Example

Let us perform self-join operation on the relation customers, by joining the two relations customers1 and customers2 as shown below.

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

Verification

Verify the relation customers3 using the DUMP operator as shown below.

grunt> Dump customers3;

Output

It will produce the following output, displaying the contents of the relation customers.

(1,Ramesh,32,Ahmedabad,2000,1,Ramesh,32,Ahmedabad,2000)
(2,Khilan,25,Delhi,1500,2,Khilan,25,Delhi,1500)
(3,kaushik,23,Kota,2000,3,kaushik,23,Kota,2000)
(4,Chaitali,25,Mumbai,6500,4,Chaitali,25,Mumbai,6500)
(5,Hardik,27,Bhopal,8500,5,Hardik,27,Bhopal,8500)
(6,Komal,22,MP,4500,6,Komal,22,MP,4500)
(7,Muffy,24,Indore,10000,7,Muffy,24,Indore,10000)

Inner Join

Inner Join is used quite frequently; it is also referred to as equijoin. An inner join returns rows when there is a match in both tables.

It creates a new relation by combining column values of two relations (say A and B) based upon the join-predicate. The query compares each row of A with each row of B to find all pairs of rows which satisfy the join-predicate. When the join-predicate is satisfied, the column values for each matched pair of rows of A and B are combined into a result row.

Syntax

Here is the syntax of performing inner join operation using the JOIN operator.

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

Example

Let us perform inner join operation on the two relations customers and orders as shown below.

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

Verification

Verify the relation coustomer_orders using the DUMP operator as shown below.

grunt> Dump coustomer_orders;

Output

You will get the following output that will the contents of the relation named 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)

Note −

Outer Join: Unlike inner join, outer join returns all the rows from at least one of the relations. An outer join operation is carried out in three ways −

Left outer join
Right outer join
Full outer join

Left Outer Join

The left outer Join operation returns all rows from the left table, even if there are no matches in the right relation.

Syntax

Given below is the syntax of performing left outer join operation using the JOIN operator.

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

Example

Let us perform left outer join operation on the two relations customers and orders as shown below.

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

Verification

Verify the relation outer_left using the DUMP operator as shown below.

grunt> Dump outer_left;

Output

It will produce the following output, displaying the contents of the relation outer_left.

(1,Ramesh,32,Ahmedabad,2000,,,,)
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
(5,Hardik,27,Bhopal,8500,,,,)
(6,Komal,22,MP,4500,,,,)
(7,Muffy,24,Indore,10000,,,,)

Right Outer Join

The right outer join operation returns all rows from the right table, even if there are no matches in the left table.

Syntax

Given below is the syntax of performing right outer join operation using the JOIN operator.

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

Example

Let us perform right outer join operation on the two relations customers and orders as shown below.

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

Verification

Verify the relation outer_right using the DUMP operator as shown below.

grunt> Dump outer_right

Output

It will produce the following output, displaying the contents of the relation outer_right.

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

Full Outer Join

The full outer join operation returns rows when there is a match in one of the relations.

Syntax

Given below is the syntax of performing full outer join using the JOIN operator.

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

Example

Let us perform full outer join operation on the two relations customers and orders as shown below.

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

Verification

Verify the relation outer_full using the DUMP operator as shown below.

grun> Dump outer_full;

Output

It will produce the following output, displaying the contents of the relation 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,,,,)

Using Multiple Keys

We can perform JOIN operation using multiple keys.

Syntax

Here is how you can perform a JOIN operation on two tables using multiple keys.

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

Assume that we have two files namely employee.txt and employee_contact.txt in the /pig_data/ directory of HDFS as shown below.

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,[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

And we have loaded these two files into Pig with relations employee and employee_contact as shown below.

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);

Now, let us join the contents of these two relations using the JOIN operator as shown below.

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

Verification

Verify the relation emp using the DUMP operator as shown below.

grunt> Dump emp;

Output

It will produce the following output, displaying the contents of the relation named emp as shown below.

(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)

The CROSS operator computes the cross-product of two or more relations. This chapter explains with example how to use the cross operator in Pig Latin.

Syntax

Given below is the syntax of the CROSS operator.

grunt> Relation3_name = CROSS Relation1_name, Relation2_name;

Example

Assume that we have two files namely customers.txt and orders.txt in the /pig_data/ directory of HDFS as shown below.

customers.txt

1,Ramesh,32,Ahmedabad,2000.00
2,Khilan,25,Delhi,1500.00
3,kaushik,23,Kota,2000.00
4,Chaitali,25,Mumbai,6500.00
5,Hardik,27,Bhopal,8500.00
6,Komal,22,MP,4500.00
7,Muffy,24,Indore,10000.00

orders.txt

102,2009-10-08 00:00:00,3,3000
100,2009-10-08 00:00:00,3,1500
101,2009-11-20 00:00:00,2,1560
103,2008-05-20 00:00:00,4,2060

And we have loaded these two files into Pig with the relations customers and orders as shown below.

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);

Let us now get the cross-product of these two relations using the cross operator on these two relations as shown below.

grunt> cross_data = CROSS customers, orders;

Verification

Verify the relation cross_data using the DUMP operator as shown below.

grunt> Dump cross_data;

Output

It will produce the following output, displaying the contents of the relation 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)

The UNION operator of Pig Latin is used to merge the content of two relations. To perform UNION operation on two relations, their columns and domains must be identical.

Syntax

Given below is the syntax of the UNION operator.

grunt> Relation_name3 = UNION Relation_name1, Relation_name2;

Example

Assume that we have two files namely student_data1.txt and student_data2.txt in the /pig_data/ directory of HDFS as shown below.

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.

And we have loaded these two files into Pig with the relations student1 and student2 as shown below.

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);

Let us now merge the contents of these two relations using the UNION operator as shown below.

grunt> student = UNION student1, student2;

Verification

Verify the relation student using the DUMP operator as shown below.

grunt> Dump student;

Output

It will display the following output, displaying the contents of the relation 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)

The SPLIT operator is used to split a relation into two or more relations.

Syntax

Given below is the syntax of the SPLIT operator.

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

例

名前の付いたファイルがあると仮定します student_details.txt HDFSディレクトリ内 /pig_data/ 以下に示すように。

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);

ここで、関係を2つに分割します。1つは23歳未満の従業員をリストし、もう1つは22〜25歳の従業員をリストします。

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

検証

関係を確認する student_details1 そして student_details2 を使用して DUMP 以下に示す演算子。

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)

ザ・ FILTER 演算子は、条件に基づいてリレーションから必要なタプルを選択するために使用されます。

構文

以下に示すのは、 FILTER オペレーター。

grunt> Relation2_name = FILTER Relation1_name BY (condition);

例

名前の付いたファイルがあると仮定します student_details.txt HDFSディレクトリ内 /pig_data/ 以下に示すように。

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_data = FILTER student_details BY city == 'Chennai';

検証

関係を確認する filter_data を使用して DUMP 以下に示す演算子。

grunt> Dump filter_data;

出力

リレーションの内容を表示して、次の出力を生成します filter_data 次のように。

(6,Archana,Mishra,23,9848022335,Chennai)
(8,Bharathi,Nambiayar,24,9848022333,Chennai)

ザ・ DISTINCT 演算子は、リレーションから冗長な（重複した）タプルを削除するために使用されます。

構文

以下に示すのは、 DISTINCT オペレーター。

grunt> Relation_name2 = DISTINCT Relatin_name1;

例

名前の付いたファイルがあると仮定します student_details.txt HDFSディレクトリ内 /pig_data/ 以下に示すように。

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);

名前の付いたリレーションから冗長な（重複した）タプルを削除しましょう student_details を使用して DISTINCT 演算子、およびという名前の別のリレーションとして保存します distinct_data 以下に示すように。

grunt> distinct_data = DISTINCT student_details;

検証

関係を確認する distinct_data を使用して DUMP 以下に示す演算子。

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)

ザ・ FOREACH 演算子は、列データに基づいて指定されたデータ変換を生成するために使用されます。

構文

以下に示すのは、 FOREACH オペレーター。

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

例

名前の付いたファイルがあると仮定します student_details.txt HDFSディレクトリ内 /pig_data/ 以下に示すように。

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);

関係から各学生のID、年齢、都市の値を取得しましょう student_details 名前の付いた別のリレーションに保存します foreach_data を使用して foreach 以下に示す演算子。

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

検証

関係を確認する foreach_data を使用して DUMP 以下に示す演算子。

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)

ザ・ ORDER BY 演算子は、1つ以上のフィールドに基づいてソートされた順序でリレーションの内容を表示するために使用されます。

構文

以下に示すのは、 ORDER BY オペレーター。

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

例

名前の付いたファイルがあると仮定します student_details.txt HDFSディレクトリ内 /pig_data/ 以下に示すように。

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_data を使用して ORDER BY 以下に示す演算子。

grunt> order_by_data = ORDER student_details BY age DESC;

検証

関係を確認する order_by_data を使用して DUMP 以下に示す演算子。

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)

ザ・ LIMIT 演算子は、リレーションから限られた数のタプルを取得するために使用されます。

構文

以下に示すのは、 LIMIT オペレーター。

grunt> Result = LIMIT Relation_name required number of tuples;

例

名前の付いたファイルがあると仮定します student_details.txt HDFSディレクトリ内 /pig_data/ 以下に示すように。

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);

それでは、学生の年齢に基づいて関係を降順で並べ替えて、という名前の別の関係に格納しましょう。 limit_data を使用して ORDER BY 以下に示す演算子。

grunt> limit_data = LIMIT student_details 4;

検証

関係を確認する limit_data を使用して DUMP 以下に示す演算子。

grunt> Dump limit_data;

出力

リレーションの内容を表示して、次の出力を生成します limit_data 次のように。

(1,Rajiv,Reddy,21,9848022337,Hyderabad) 
(2,siddarth,Battacharya,22,9848022338,Kolkata) 
(3,Rajesh,Khanna,22,9848022339,Delhi) 
(4,Preethi,Agarwal,21,9848022330,Pune)

Apache Pigは、さまざまな組み込み関数を提供します。 eval, load, store, math, string, bag そして tuple 関数。

評価関数

以下はのリストです eval ApachePigが提供する機能。

SN	機能と説明
1	AVG（）バッグ内の数値の平均を計算します。
2	BagToString（）バッグの要素を文字列に連結します。連結中に、これらの値の間に区切り文字を配置できます（オプション）。
3	CONCAT（）同じタイプの2つ以上の式を連結します。
4	カウント（）バッグ内のタプルの数を数えながら、バッグ内の要素の数を取得します。
5	COUNT_STAR（）それはに似ています COUNT()関数。バッグ内の要素の数を取得するために使用されます。
6	DIFF（）タプル内の2つのバッグ（フィールド）を比較します。
7	IsEmpty（）バッグまたはマップが空かどうかを確認します。
8	MAX（）単一列バッグ内の列の最大値（数値または文字配列）を計算します。
9	MIN（）単一列バッグ内の特定の列の最小（最小）値（数値または文字配列）を取得します。
10	PluckTuple（）ピッグラテン語の使用 PluckTuple() 関数では、文字列プレフィックスを定義し、指定されたプレフィックスで始まるリレーションの列をフィルタリングできます。
11	サイズ（） Pigデータ型に基づいて要素の数を計算します。
12	SUBTRACT（） 2つのバッグを差し引く。入力として2つのバッグを受け取り、2番目のバッグにない最初のバッグのタプルを含むバッグを返します。
13	和（）単一列バッグ内の列の数値の合計を取得します。
14	TOKENIZE（）文字列（単語のグループを含む）を単一のタプルに分割し、分割操作の出力を含むバッグを返すこと。

ザ・ Load そして StoreApache Pigの関数は、データがどのようにPigから出力されるかを決定するために使用されます。これらの関数は、ロードおよびストア演算子で使用されます。以下に、Pigで使用可能なロードおよびストア機能のリストを示します。

SN	機能と説明
1	PigStorage（）構造化ファイルをロードして保存します。
2	TextLoader（）非構造化データをPigにロードします。
3	BinStorage（）機械可読形式を使用してデータをPigにロードおよび保存します。
4	圧縮の処理 Pig Latinでは、圧縮データをロードして保存できます。

以下に、バッグとタプルの機能のリストを示します。

SN	機能と説明
1	TOBAG（） 2つ以上の式をバッグに変換します。
2	上（）トップを獲得するには N 関係のタプル。
3	TOTUPLE（） 1つ以上の式をタプルに変換します。
4	TOMAP（）キーと値のペアをマップに変換します。

ApachePigには次の文字列関数があります。

SN	機能と説明
1	ENDSWITH（文字列、testAgainst）特定の文字列が特定の部分文字列で終わっているかどうかを確認します。
2	STARTSWITH（文字列、部分文字列） 2つの文字列パラメータを受け入れ、最初の文字列が2番目の文字列で始まるかどうかを確認します。
3	SUBSTRING（文字列、startIndex、stopIndex）指定された文字列から部分文字列を返します。
4	EqualsIgnoreCase（string1、string2）ケースを無視して2つの刺し傷を比較します。
5	INDEXOF（文字列、 '文字'、startIndex）文字列内で最初に出現する文字を返し、開始インデックスから前方に検索します。
6	LAST_INDEX_OF（式）文字列内で最後に出現する文字のインデックスを返し、開始インデックスから逆方向に検索します。
7	LCFIRST（式）文字列の最初の文字を小文字に変換します。
8	UCFIRST（式）最初の文字が大文字に変換された文字列を返します。
9	UPPER（式） UPPER（expression）大文字に変換された文字列を返します。
10	LOWER（式）文字列内のすべての文字を小文字に変換します。
11	REPLACE（string、 'oldChar'、 'newChar'）; 文字列内の既存の文字を新しい文字に置き換えること。
12	STRSPLIT（文字列、正規表現、制限）特定の正規表現の一致を中心に文字列を分割します。
13	STRSPLITTOBAG（文字列、正規表現、制限）に似ています STRSPLIT() 関数では、指定された区切り文字で文字列を分割し、結果をバッグに返します。
14	TRIM（式）先頭と末尾の空白が削除された文字列のコピーを返します。
15	LTRIM（式）先頭の空白が削除された文字列のコピーを返します。
16	RTRIM（式）末尾の空白が削除された文字列のコピーを返します。

Apache Pigは、次の日付と時刻の関数を提供します-

SN	機能と説明
1	ToDate（ミリ秒）この関数は、指定されたパラメーターに従って日時オブジェクトを返します。この関数の他の選択肢は、ToDate（iosstring）、ToDate（userstring、format）、ToDate（userstring、format、timezone）です。
2	現在の時刻（）現在の時刻の日時オブジェクトを返します。
3	GetDay（日時）日時オブジェクトから月の日を返します。
4	GetHour（日時）日時オブジェクトから時刻を返します。
5	GetMilliSecond（datetime）日時オブジェクトからミリ秒を返します。
6	GetMinute（datetime）日時オブジェクトから1時間の分を返します。
7	GetMonth（日時）日時オブジェクトから月を返します。
8	GetSecond（日時）日時オブジェクトから1分の秒を返します。
9	GetWeek（日時）日時オブジェクトから年の週を返します。
10	GetWeekYear（日時）日時オブジェクトから週年を返します。
11	GetYear（日時）日時オブジェクトから年を返します。
12	AddDuration（datetime、duration）日時オブジェクトの結果を期間オブジェクトとともに返します。
13	SubtractDuration（日時、期間） Date-TimeオブジェクトからDurationオブジェクトを減算し、結果を返します。
14	DaysBetween（datetime1、datetime2） 2つの日時オブジェクト間の日数を返します。
15	HoursBetween（datetime1、datetime2） 2つの日時オブジェクト間の時間数を返します。
16	MilliSecondsBetween（datetime1、datetime2） 2つの日時オブジェクト間のミリ秒数を返します。
17	MinutesBetween（datetime1、datetime2） 2つの日時オブジェクト間の分数を返します。
18	MonthsBetween（datetime1、datetime2） 2つの日時オブジェクト間の月数を返します。
19	SecondsBetween（datetime1、datetime2） 2つの日時オブジェクト間の秒数を返します。
20	WeeksBetween（datetime1、datetime2） 2つの日時オブジェクト間の週数を返します。
21	YearsBetween（datetime1、datetime2） 2つの日時オブジェクト間の年数を返します。

ApachePigには次の数学関数があります-

SN	機能と説明
1	ABS（式）式の絶対値を取得します。
2	ACOS（式）式のアークコサインを取得します。
3	ASIN（式）式のアークサインを取得します。
4	ATAN（式）この関数は、式のアークタンジェントを取得するために使用されます。
5	CBRT（式）この関数は、式の立方根を取得するために使用されます。
6	CEIL（式）この関数は、最も近い整数に切り上げられた式の値を取得するために使用されます。
7	COS（式）この関数は、式の三角コサインを取得するために使用されます。
8	COSH（式）この関数は、式の双曲線余弦を取得するために使用されます。
9	EXP（式）この関数は、オイラーの数eをxの累乗にするために使用されます。
10	FLOOR（式）最も近い整数に切り捨てられた式の値を取得します。
11	LOG（式）式の自然対数（基数e）を取得します。
12	LOG10（式）式の常用対数を取得します。
13	ランダム（） 0.0以上1.0未満の疑似乱数（double型）を取得します。
14	ROUND（式）整数に丸められた式（結果タイプがfloatの場合）またはlongに丸められた式（結果タイプがdoubleの場合）の値を取得します。
15	SIN（式）式のサインを取得します。
16	SINH（発現）式の双曲線正弦を取得します。
17	SQRT（式）式の正の平方根を取得します。
18	TAN（式）角度の三角関数のタンジェントを取得します。
19	TANH（式）式の双曲線タンジェントを取得します。

組み込み関数に加えて、ApachePigは User D洗練された F機能（UDF）。これらのUDFを使用して、独自の関数を定義して使用できます。UDFサポートは、Java、Jython、Python、JavaScript、Ruby、Groovyの6つのプログラミング言語で提供されます。

UDFを作成するために、Javaで完全なサポートが提供され、残りのすべての言語で限定的なサポートが提供されます。Javaを使用すると、データのロード/ストア、列変換、集計など、処理のすべての部分を含むUDFを作成できます。Apache PigはJavaで記述されているため、Java言語を使用して記述されたUDFは、他の言語と比較して効率的に機能します。

Apache Pigには、UDFの名前付きのJavaリポジトリもあります。 Piggybank。Piggybankを使用すると、他のユーザーが作成したJava UDFにアクセスして、独自のUDFを提供できます。

JavaでのUDFの種類

Javaを使用してUDFを記述している間、次の3種類の関数を作成して使用できます。

Filter Functions−フィルタ関数は、フィルタステートメントの条件として使用されます。これらの関数は、入力としてPig値を受け入れ、ブール値を返します。
Eval Functions− Eval関数は、FOREACH-GENERATEステートメントで使用されます。これらの関数は、入力としてPig値を受け入れ、Pig結果を返します。
Algebraic Functions−代数関数は、FOREACHGENERATEステートメントの内側のバッグに作用します。これらの関数は、インナーバッグに対して完全なMapReduce操作を実行するために使用されます。

Javaを使用してUDFを作成する

Javaを使用してUDFを作成するには、jarファイルを統合する必要があります Pig-0.15.0.jar。このセクションでは、Eclipseを使用してサンプルUDFを作成する方法について説明します。先に進む前に、システムにEclipseとMavenがインストールされていることを確認してください。

以下の手順に従って、UDF関数を記述します-

Eclipseを開き、新しいプロジェクトを作成します（たとえば myproject）。
新しく作成したプロジェクトをMavenプロジェクトに変換します。
次のコンテンツをpom.xmlにコピーします。このファイルには、ApachePigおよび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 次のスクリーンショットに示すように。

クリックすると export、次のウィンドウが表示されます。クリックJAR file。

クリックしてさらに進みます Next>ボタン。ローカルファイルシステムにパスを入力する必要がある別のウィンドウが表示されます。ここに、jarファイルを保存する必要があります。

最後にクリックします Finishボタン。指定されたフォルダー内のJarファイルsample_udf.jar創造された。このjarファイルには、Javaで記述されたUDFが含まれています。

UDFの使用

UDFを書き込んでJarファイルを生成した後、以下の手順に従います。

ステップ1：Jarファイルを登録する

UDFを（Javaで）書き込んだ後、Register演算子を使用してUDFを含むJarファイルを登録する必要があります。Jarファイルを登録することにより、ユーザーはUDFの場所をApachePigに知らせることができます。

Syntax

以下に、Register演算子の構文を示します。

REGISTER path;

Example

例として、この章の前半で作成したsample_udf.jarを登録しましょう。

ローカルモードでApachePigを起動し、以下に示すようにjarファイルsample_udf.jarを登録します。

$cd PIG_HOME/bin $./pig –x local 

REGISTER '/$PIG_HOME/sample_udf.jar'

Note −パスにJarファイルがあると想定します− /$PIG_HOME/sample_udf.jar

ステップ2：エイリアスを定義する

UDFを登録した後、UDFを使用してUDFのエイリアスを定義できます。 Define オペレーター。

Syntax

以下に、Define演算子の構文を示します。

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

Example

以下に示すように、sample_evalのエイリアスを定義します。

DEFINE sample_eval sample_eval();

ステップ3：UDFを使用する

エイリアスを定義した後、組み込み関数と同じようにUDFを使用できます。HDFSにemp_dataという名前のファイルがあるとします。/Pig_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)

この章では、ApachePigスクリプトをバッチモードで実行する方法を説明します。

Pigスクリプトのコメント

ファイルにスクリプトを記述しているときに、以下に示すようにコメントを含めることができます。

複数行コメント

複数行コメントは「/ *」で始まり、「* /」で終わります。

/* These are the multi-line comments 
  In the pig script */

単一行コメント

単一行コメントは「-」で始まります。

--we can write single line comments like this.

バッチモードでのPigスクリプトの実行

Apache Pigステートメントをバッチモードで実行している間は、以下の手順に従ってください。

ステップ1

必要なすべてのPigLatinステートメントを1つのファイルに書き込みます。すべてのPigLatinステートメントとコマンドを1つのファイルに記述して、次のように保存できます。.pig ファイル。

ステップ2

ApachePigスクリプトを実行します。以下に示すように、シェル（Linux）からPigスクリプトを実行できます。

ローカルモード	MapReduceモード
$ pig -x local Sample_script.pig	$ pig -x mapreduce Sample_script.pig

以下に示すように、execコマンドを使用してGruntシェルからも実行できます。

grunt> exec /sample_script.pig

HDFSからのPigスクリプトの実行

HDFSにあるPigスクリプトを実行することもできます。名前が付いたPigスクリプトがあるとします。Sample_script.pig 名前の付いたHDFSディレクトリ内 /pig_data/。以下のように実行できます。

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

例

ファイルがあると仮定します student_details.txt 次のコンテンツを含むHDFSで。

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 以下に示すように、関係。

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。
スクリプトの2番目のステートメントは、関係のタプルを年齢に基づいて降順で配置し、次のように格納します。 student_order。
スクリプトの3番目のステートメントは、の最初の4つのタプルを格納します。 student_order なので student_limit。
最後に、4番目のステートメントは関係の内容をダンプします 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)

SN	機能と説明
1	AVG（）バッグ内の数値の平均を計算します。
2	BagToString（）バッグの要素を文字列に連結します。連結中に、これらの値の間に区切り文字を配置できます（オプション）。
3	CONCAT（）同じタイプの2つ以上の式を連結します。
4	カウント（）バッグ内のタプルの数を数えながら、バッグ内の要素の数を取得します。
5	COUNT_STAR（）それはに似ています COUNT()関数。バッグ内の要素の数を取得するために使用されます。
6	DIFF（）タプル内の2つのバッグ（フィールド）を比較します。
7	IsEmpty（）バッグまたはマップが空かどうかを確認します。
8	MAX（）単一列バッグ内の列の最大値（数値または文字配列）を計算します。
9	MIN（）単一列バッグ内の特定の列の最小（最小）値（数値または文字配列）を取得します。
10	PluckTuple（）ピッグラテン語の使用 PluckTuple() 関数では、文字列プレフィックスを定義し、指定されたプレフィックスで始まるリレーションの列をフィルタリングできます。
11	サイズ（） Pigデータ型に基づいて要素の数を計算します。
12	SUBTRACT（） 2つのバッグを差し引く。入力として2つのバッグを受け取り、2番目のバッグにない最初のバッグのタプルを含むバッグを返します。
13	和（）単一列バッグ内の列の数値の合計を取得します。
14	TOKENIZE（）文字列（単語のグループを含む）を単一のタプルに分割し、分割操作の出力を含むバッグを返すこと。

SN	機能と説明
1	ENDSWITH（文字列、testAgainst）特定の文字列が特定の部分文字列で終わっているかどうかを確認します。
2	STARTSWITH（文字列、部分文字列） 2つの文字列パラメータを受け入れ、最初の文字列が2番目の文字列で始まるかどうかを確認します。
3	SUBSTRING（文字列、startIndex、stopIndex）指定された文字列から部分文字列を返します。
4	EqualsIgnoreCase（string1、string2）ケースを無視して2つの刺し傷を比較します。
5	INDEXOF（文字列、 '文字'、startIndex）文字列内で最初に出現する文字を返し、開始インデックスから前方に検索します。
6	LAST_INDEX_OF（式）文字列内で最後に出現する文字のインデックスを返し、開始インデックスから逆方向に検索します。
7	LCFIRST（式）文字列の最初の文字を小文字に変換します。
8	UCFIRST（式）最初の文字が大文字に変換された文字列を返します。
9	UPPER（式） UPPER（expression）大文字に変換された文字列を返します。
10	LOWER（式）文字列内のすべての文字を小文字に変換します。
11	REPLACE（string、 'oldChar'、 'newChar'）; 文字列内の既存の文字を新しい文字に置き換えること。
12	STRSPLIT（文字列、正規表現、制限）特定の正規表現の一致を中心に文字列を分割します。
13	STRSPLITTOBAG（文字列、正規表現、制限）に似ています STRSPLIT() 関数では、指定された区切り文字で文字列を分割し、結果をバッグに返します。
14	TRIM（式）先頭と末尾の空白が削除された文字列のコピーを返します。
15	LTRIM（式）先頭の空白が削除された文字列のコピーを返します。
16	RTRIM（式）末尾の空白が削除された文字列のコピーを返します。

SN	機能と説明
1	ABS（式）式の絶対値を取得します。
2	ACOS（式）式のアークコサインを取得します。
3	ASIN（式）式のアークサインを取得します。
4	ATAN（式）この関数は、式のアークタンジェントを取得するために使用されます。
5	CBRT（式）この関数は、式の立方根を取得するために使用されます。
6	CEIL（式）この関数は、最も近い整数に切り上げられた式の値を取得するために使用されます。
7	COS（式）この関数は、式の三角コサインを取得するために使用されます。
8	COSH（式）この関数は、式の双曲線余弦を取得するために使用されます。
9	EXP（式）この関数は、オイラーの数eをxの累乗にするために使用されます。
10	FLOOR（式）最も近い整数に切り捨てられた式の値を取得します。
11	LOG（式）式の自然対数（基数e）を取得します。
12	LOG10（式）式の常用対数を取得します。
13	ランダム（） 0.0以上1.0未満の疑似乱数（double型）を取得します。
14	ROUND（式）整数に丸められた式（結果タイプがfloatの場合）またはlongに丸められた式（結果タイプがdoubleの場合）の値を取得します。
15	SIN（式）式のサインを取得します。
16	SINH（発現）式の双曲線正弦を取得します。
17	SQRT（式）式の正の平方根を取得します。
18	TAN（式）角度の三角関数のタンジェントを取得します。
19	TANH（式）式の双曲線タンジェントを取得します。