Apache Pig-概要

Apache Pigとは何ですか？

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

データ分析プログラムを作成するために、Pigは Pig Latin と呼ばれる高水準言語を提供します。この言語は、プログラマーがデータの読み取り、書き込み、および処理のための独自の機能を開発できるさまざまな演算子を提供します。

*Apache Pig* を使用してデータを分析するには、プログラマはPig Latin言語を使用してスクリプトを記述する必要があります。 これらのスクリプトはすべて、内部的にMapおよびReduceタスクに変換されます。 Apache Pigには、Pig Latinスクリプトを入力として受け入れ、それらのスクリプトをMapReduceジョブに変換する *Pig Engine* というコンポーネントがあります。

Apache Pigが必要な理由

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

Pig Latin を使用すると、プログラマはJavaで複雑なコードを入力することなくMapReduceタスクを簡単に実行できます。
Apache Pigは*マルチクエリアプローチ*を使用しているため、コードの長さが短縮されます。たとえば、Javaで200行のコード（LoC）を入力する必要がある操作は、Apache Pigでわずか10 LoCと入力するだけで簡単に実行できます。最終的に、Apache Pigは開発時間をほぼ16倍短縮します。
Pig Latinは* SQLに似た言語*であり、SQLに精通していればApache Pigを簡単に習得できます。
Apache Pigは、結合、フィルター、順序付けなどのデータ操作をサポートする多くの組み込み演算子を提供します。さらに、MapReduceにないタプル、バッグ、マップなどのネストされたデータ型も提供します。

豚の特徴

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

豊富な演算子セット-結合、ソート、ファイラーなどの操作を実行するための多くの演算子を提供します。
プログラミングの容易さ-Pig LatinはSQLに似ており、SQLが得意であれば、Pigスクリプトを簡単に記述できます。
最適化の機会-Apache Pigのタスクは実行を自動的に最適化するため、プログラマは言語のセマンティクスのみに集中する必要があります。
拡張性-ユーザーは既存の演算子を使用して、データの読み取り、処理、書き込みを行う独自の機能を開発できます。
* UDF’s-Pigは、Javaなどの他のプログラミング言語で*ユーザー定義関数*を作成し、それらをPigスクリプトに呼び出したり、埋め込む機能を提供します。
すべての種類のデータを処理-Apache Pigは、構造化および非構造化の両方のあらゆる種類のデータを分析します。結果をHDFSに保存します。

Apache Pig対MapReduce

以下は、Apache PigとMapReduceの主な違いです。

Apache Pig	MapReduce
Apache Pig is a data flow language.	MapReduce is a data processing paradigm.
It is a high level language.	MapReduce is low level and rigid.
Performing a Join operation in Apache Pig is pretty simple.	It is quite difficult in MapReduce to perform a Join operation between datasets.
Any novice programmer with a basic knowledge of SQL can work conveniently with Apache Pig.	Exposure to Java is must to work with MapReduce.
Apache Pig uses multi-query approach, thereby reducing the length of the codes to a great extent.	MapReduce will require almost 20 times more the number of lines to perform the same task.
There is no need for compilation. On execution, every Apache Pig operator is converted internally into a MapReduce job.	MapReduce jobs have a long compilation process.

Apache Pig対SQL

Apache PigとSQLの主な違いを以下にリストします。

Pig	SQL
Pig Latin is a procedural language.	SQL is a* declarative *language.
In Apache Pig,* schema *is optional. We can store data without designing a schema (values are stored as $01, $02 etc.)	Schema is mandatory in SQL.
The data model in Apache Pig is* nested relational*.	The data model used in SQL is flat relational.
Apache Pig provides limited opportunity for Query optimization.	There is more opportunity for query optimization in SQL.

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

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

Apache Pig Vs Hive

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

Apache Pig	Hive
Apache Pig uses a language called* Pig Latin. It was originally created at Yahoo*.	Hive uses a language called HiveQL. It was originally created at Facebook.
Pig Latin is a data flow language.	HiveQL is a query processing language.
Pig Latin is a procedural language and it fits in pipeline paradigm.	HiveQL is a declarative language.
Apache Pig can handle structured, unstructured, and semi-structured data.	Hive is mostly for structured data.

Apache Pigのアプリケーション

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

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

Apache Pig –歴史

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

Apache Pig-アーキテクチャ

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

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

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

Apache Pig Architecture

Apache Pigコンポーネント

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

パーサ

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

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

オプティマイザ

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

コンパイラ

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

実行エンジン

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

豚ラテンデータモデル

Pig Latinのデータモデルは完全にネストされており、 map や tuple などの複雑な非原子データ型を使用できます。以下に示すのは、Pig Latinのデータモデルの図表示です。

データモデル

Atom

データに関係なく、Pig Latinの単一の値は、 Atom として知られています。文字列として保存され、文字列と数値として使用できます。 int、long、float、double、chararray、およびbytearrayは、Pigのアトミック値です。データの一部または単純なアトミック値は、*フィールド*と呼ばれます。

例-「raja」または「30」

タプル

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

例-（ラジャ、30）

Bag

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

例-\ {（Raja、30）、（Mohammad、45）}

バッグはリレーションのフィールドになることができます。その文脈では、*インナーバッグ*として知られています。

例-\ {Raja、30、 \ {9848022338、[email protected]、} }

Map

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

例-[name＃Raja、age＃30]

関係

リレーションはタプルの袋です。 Pig Latinの関係は順序付けられていません（タプルが特定の順序で処理されるという保証はありません）。

Apache Pig-インストール

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

前提条件

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

http://www.finddevguides.com/hadoop/hadoop_enviornment_setup

Apache Pigをダウンロードする

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

ステップ1

Apache Pig Webサイトのホームページを開きます。次のスナップショットに示すように、[*ニュース] *セクションの下にある[リリースページ]リンクをクリックします。

ホームページ

ステップ2

指定されたリンクをクリックすると、* Apache Pigリリース*ページにリダイレクトされます。このページの[ダウンロード]セクションには、* Pig 0.8以降*および* Pig 0.7以前*の2つのリンクがあります。 * Pig 0.8以降*のリンクをクリックすると、ミラーのセットがあるページにリダイレクトされます。

Apache Pigリリース

ステップ3

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

ミラーをクリック

ステップ4

これらのミラーは、 Pig Releases ページに移動します。このページには、Apache Pigのさまざまなバージョンが含まれています。それらの中で最新バージョンをクリックします。

豚リリース

ステップ5

これらのフォルダー内には、Apache Pigのソースファイルとバイナリファイルがさまざまなディストリビューションで含まれています。 Apache Pig 0.15、 pig0.15.0-src.tar.gz 、および* pig-0.15.0.tar.gz。*のソースファイルとバイナリファイルのtarファイルをダウンロードします。

インデックス

Apache Pigをインストールする

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

ステップ1

Hadoop、Java、およびその他のソフトウェアのインストールディレクトリがインストールされたのと同じディレクトリに、Pigという名前のディレクトリを作成します。（チュートリアルでは、Hadoopという名前のユーザーにPigディレクトリを作成しました）。

$ mkdir Pig

ステップ2

以下に示すように、ダウンロードしたtarファイルを解凍します。

$ cd Downloads/
$ tar zxvf pig-0.15.0-src.tar.gz
$ tar zxvf pig-0.15.0.tar.gz

ステップ3

以下に示すように、 pig-0.15.0-src.tar.gz ファイルの内容を以前に作成した Pig ディレクトリに移動します。

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

Apache Pigを構成する

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

.bashrcファイル

*.bashrc* ファイルで、次の変数を設定します-

PIG_HOME フォルダーをApache Pigのインストールフォルダーに、
PATH 環境変数からbinフォルダー、および
PIG_CLASSPATH 環境変数をHadoopインストールのetc（設定）フォルダー（core-site.xml、hdfs-site.xml、mapred-site.xmlファイルを含むディレクトリ）に。

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

pig.propertiesファイル

Pigの conf フォルダーには、 pig.properties という名前のファイルがあります。 pig.propertiesファイルでは、以下に示すようにさまざまなパラメーターを設定できます。

pig -h properties

次のプロパティがサポートされています-

Logging: verbose = true|false; default is false. This property is the same as -v
       switch brief=true|false; default is false. This property is the same
       as -b switch debug=OFF|ERROR|WARN|INFO|DEBUG; default is INFO.
       This property is the same as -d switch aggregate.warning = true|false; default is true.
       If true, prints count of warnings of each type rather than logging each warning.

Performance tuning: pig.cachedbag.memusage=<mem fraction>; default is 0.2 (20% of all memory).
       Note that this memory is shared across all large bags used by the application.
       pig.skewedjoin.reduce.memusagea=<mem fraction>; default is 0.3 (30% of all memory).
       Specifies the fraction of heap available for the reducer to perform the join.
       pig.exec.nocombiner = true|false; default is false.
           Only disable combiner as a temporary workaround for problems.
       opt.multiquery = true|false; multiquery is on by default.
           Only disable multiquery as a temporary workaround for problems.
       opt.fetch=true|false; fetch is on by default.
           Scripts containing Filter, Foreach, Limit, Stream, and Union can be dumped without MR jobs.
       pig.tmpfilecompression = true|false; compression is off by default.
           Determines whether output of intermediate jobs is compressed.
       pig.tmpfilecompression.codec = lzo|gzip; default is gzip.
           Used in conjunction with pig.tmpfilecompression. Defines compression type.
       pig.noSplitCombination = true|false. Split combination is on by default.
           Determines if multiple small files are combined into a single map.

       pig.exec.mapPartAgg = true|false. Default is false.
           Determines if partial aggregation is done within map phase, before records are sent to combiner.
       pig.exec.mapPartAgg.minReduction=<min aggregation factor>. Default is 10.
           If the in-map partial aggregation does not reduce the output num records by this factor, it gets disabled.

Miscellaneous: exectype = mapreduce|tez|local; default is mapreduce. This property is the same as -x switch
       pig.additional.jars.uris=<comma seperated list of jars>. Used in place of register command.
       udf.import.list=<comma seperated list of imports>. Used to avoid package names in UDF.
       stop.on.failure = true|false; default is false. Set to true to terminate on the first error.
       pig.datetime.default.tz=<UTC time offset>. e.g. +08:00. Default is the default timezone of the host.
           Determines the timezone used to handle datetime datatype and UDFs.
Additionally, any Hadoop property can be specified.

インストールの検証

versionコマンドを入力して、Apache Pigのインストールを確認します。インストールが成功すると、以下に示すバージョンのApache Pigが取得されます。

$ pig –version

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

Apache Pig-実行

前の章では、Apache Pigのインストール方法について説明しました。この章では、Apache Pigの実行方法について説明します。

Apache Pig実行モード

Apache Pigは、ローカルモード*および HDFSモード*の2つのモードで実行できます。

ローカルモード

このモードでは、すべてのファイルがインストールされ、ローカルホストとローカルファイルシステムから実行されます。 HadoopやHDFSは必要ありません。通常、このモードはテスト目的で使用されます。

MapReduceモード

MapReduceモードは、Apache Pigを使用してHadoopファイルシステム（HDFS）に存在するデータをロードまたは処理するモードです。このモードでは、Pig Latinステートメントを実行してデータを処理するたびに、MapReduceジョブがバックエンドで呼び出され、HDFSに存在するデータに対して特定の操作を実行します。

Apache Pig実行メカニズム

Apache Pigスクリプトは、インタラクティブモード、バッチモード、埋め込みモードの3つの方法で実行できます。

インタラクティブモード（Gruntシェル）-Gruntシェルを使用して、Apache Pigをインタラクティブモードで実行できます。このシェルでは、Pig Latinステートメントを入力して出力を取得できます（ダンプ演算子を使用）。
バッチモード（スクリプト）-拡張子が .pig の単一ファイルにPig Latinスクリプトを記述することにより、Apache Pigをバッチモードで実行できます。
Embedded Mode （UDF）-Apache Pigは、Javaなどのプログラミング言語で独自の関数（* U ser D efined F * unctions）を定義し、スクリプト。

Grunt Shellの呼び出し

以下に示すように、*-x *オプションを使用して、希望のモード（local/MapReduce）でGruntシェルを呼び出すことができます。

Local mode

MapReduce mode

Command −

$ ./pig –x local

a

コマンド- *

$ ./pig -x mapreduce

a

出力*-

ローカルモード出力

a

出力-

MapReduceモード出力

これらのコマンドのいずれかを使用すると、次に示すようにGruntシェルプロンプトが表示されます。

grunt>

’ctrl＆plus;を使用してGruntシェルを終了できます。 d ’。*

Gruntシェルを呼び出した後、Pig Latinステートメントを直接入力してPigスクリプトを実行できます。

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

バッチモードでのApache Pigの実行

ファイルにPig Latinスクリプト全体を記述し、* – xコマンド*を使用して実行できます。以下に示すように、 sample_script.pig という名前のファイルにPigスクリプトがあるとします。

Sample_script.pig

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

Dump student;

これで、以下に示すように、上記のファイルでスクリプトを実行できます。

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

注-*バッハモード*および*埋め込みモード*でPigスクリプトを実行する方法については、以降の章で詳しく説明します。

Apache Pig-Grunt Shell

Gruntシェルを呼び出した後、シェルでPigスクリプトを実行できます。それに加えて、Gruntシェルによって提供される特定の有用なシェルおよびユーティリティコマンドがあります。この章では、Gruntシェルが提供するシェルおよびユーティリティコマンドについて説明します。

注-この章の一部では、 Load や Store などのコマンドが使用されます。詳細については、それぞれの章を参照してください。

シェルコマンド

Apache PigのGruntシェルは、主にPig Latinスクリプトを作成するために使用されます。それ以前は、 sh および fs を使用して、任意のシェルコマンドを呼び出すことができます。

shコマンド

*sh* コマンドを使用して、Gruntシェルからシェルコマンドを呼び出すことができます。 Gruntシェルから *sh* コマンドを使用すると、シェル環境の一部であるコマンドを実行できません（ *ex* -cd）。

構文

以下に、 sh コマンドの構文を示します。

grunt> sh shell command parameters

例

以下に示すように、 sh オプションを使用して、GruntシェルからLinuxシェルの ls コマンドを呼び出すことができます。この例では、 /pig/bin/ ディレクトリ内のファイルをリストします。

grunt> sh ls

pig
pig_1444799121955.log
pig.cmd
pig.py

fsコマンド

*fs* コマンドを使用して、GruntシェルからFsShellコマンドを呼び出すことができます。

構文

以下に fs コマンドの構文を示します。

grunt> sh File System command parameters

例

fsコマンドを使用して、GruntシェルからHDFSのlsコマンドを呼び出すことができます。次の例では、HDFSルートディレクトリ内のファイルを一覧表示します。

grunt> fs –ls

Found 3 items
drwxrwxrwx   - Hadoop supergroup          0 2015-09-08 14:13 Hbase
drwxr-xr-x   - Hadoop supergroup          0 2015-09-09 14:52 seqgen_data
drwxr-xr-x   - Hadoop supergroup          0 2015-09-08 11:30 twitter_data

同様に、 fs コマンドを使用して、Gruntシェルから他のすべてのファイルシステムシェルコマンドを呼び出すことができます。

ユーティリティコマンド

Gruntシェルは、一連のユーティリティコマンドを提供します。これらには、* clear、help、history、quit、、 *set などのユーティリティコマンドが含まれます。そして、GruntシェルからPigを制御するための* exec、kill、、 *run などのコマンド。以下は、Gruntシェルが提供するユーティリティコマンドの説明です。

クリアコマンド

*clear* コマンドは、Gruntシェルの画面をクリアするために使用されます。

構文

以下に示すように、 clear コマンドを使用して、Grunt Shellの画面をクリアできます。

grunt> clear

helpコマンド

*help* コマンドは、PigコマンドまたはPigプロパティのリストを提供します。

使用法

以下に示すように help コマンドを使用して、Pigコマンドのリストを取得できます。

grunt> help

Commands: <pig latin statement>; - See the PigLatin manual for details:
http://hadoop.apache.org/pig

File system commands:fs <fs arguments> - Equivalent to Hadoop dfs  command:
http://hadoop.apache.org/common/docs/current/hdfs_shelll

Diagnostic Commands:describe <alias>[::<alias] - Show the schema for the alias.
Inner aliases can be described as A::B.
    explain [-script <pigscript>] [-out <path>] [-brief] [-dot|-xml]
       [-param <param_name>=<pCram_value>]
       [-param_file <file_name>] [<alias>] -
       Show the execution plan to compute the alias or for entire script.
       -script - Explain the entire script.
       -out - Store the output into directory rather than print to stdout.
       -brief - Don't expand nested plans (presenting a smaller graph for overview).
       -dot - Generate the output in .dot format. Default is text format.
       -xml - Generate the output in .xml format. Default is text format.
       -param <param_name - See parameter substitution for details.
       -param_file <file_name> - See parameter substitution for details.
       alias - Alias to explain.
       dump <alias> - Compute the alias and writes the results to stdout.

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

historyコマンド

このコマンドは、Grunt sellが呼び出されてから現在までに実行/使用されたステートメントのリストを表示します。

使用法

Gruntシェルを開いてから3つのステートメントを実行したと仮定します。

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

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

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

次に、 history コマンドを使用すると、次の出力が生成されます。

grunt> history

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

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

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

setコマンド

*set* コマンドは、Pigで使用されるキーに値を表示/割り当てるために使用されます。

使用法

このコマンドを使用すると、次のキーに値を設定できます。

Key	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 − とても低い low 普通の 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.

終了コマンド

このコマンドを使用して、Gruntシェルを終了できます。

使用法

以下に示すように、Gruntシェルを終了します。

grunt> quit

GruntシェルからApache Pigを制御できるコマンドを見てみましょう。

execコマンド

*exec* コマンドを使用して、GruntシェルからPigスクリプトを実行できます。

構文

以下は、ユーティリティコマンド exec の構文です。

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

例

HDFSの /pig_data/ ディレクトリに student.txt という名前のファイルがあり、次のコンテンツがあると仮定します。

*Student.txt*

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

また、HDFSの /pig_data/ ディレクトリに sample_script.pig という名前のスクリプトファイルがあり、次の内容があるとします。

*Sample_script.pig*

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

Dump student;

次に、以下に示すように exec コマンドを使用して、Gruntシェルから上記のスクリプトを実行します。

grunt> exec/sample_script.pig

出力

*exec* コマンドは、 *sample_script.pig* 内のスクリプトを実行します。 スクリプトで指示されているように、 *student.txt* ファイルをPigにロードし、次の内容を表示するDumpオペレーターの結果を提供します。

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

killコマンド

このコマンドを使用して、Gruntシェルからジョブを強制終了できます。

構文

以下は、 kill コマンドの構文です。

grunt> kill JobId

例

IDが Id_0055 の実行中のPigジョブがあるとします。以下に示すように、 kill コマンドを使用してGruntシェルからそれを強制終了できます。

grunt> kill Id_0055

コマンドを実行

*run* コマンドを使用して、GruntシェルからPigスクリプトを実行できます。

構文

以下に示すのは、 run コマンドの構文です。

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

例

HDFSの /pig_data/ ディレクトリに student.txt という名前のファイルがあり、次のコンテンツがあると仮定します。

*Student.txt*

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

そして、次の内容のローカルファイルシステムに sample_script.pig という名前のスクリプトファイルがあると仮定します。

*Sample_script.pig*

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

次に、以下に示すようにrunコマンドを使用してGruntシェルから上記のスクリプトを実行します。

grunt> run/sample_script.pig

以下に示すように、 Dump operator を使用して、スクリプトの出力を確認できます。

grunt> Dump;

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

注- exec と run コマンドの違いは、 run を使用すると、スクリプトのステートメントがコマンド履歴で利用できることです。

豚のラテン語-基本

Pig Latinは、Apache Pigを使用してHadoopのデータを分析するために使用される言語です。この章では、Pig Latinステートメント、データ型、一般演算子と関係演算子、Pig Latin UDFなど、Pig Latinの基本について説明します。

豚ラテン–データモデル

前の章で説明したように、Pigのデータモデルは完全にネストされています。 Relation は、Pig Latinデータモデルの最も外側の構造です。そして、それは*バッグ*です-

バッグはタプルのコレクションです。
タプルは、順序付けられたフィールドのセットです。
フィールドはデータの一部です。

豚のラテン語-ステートメッツ

Pig Latinを使用してデータを処理する際、*ステートメント*は基本的な構成要素です。

これらのステートメントは relations で機能します。 *式*と*スキーマ*が含まれます。
すべてのステートメントはセミコロン（;）で終わります。
ステートメントを通じて、Pig Latinが提供する演算子を使用してさまざまな操作を実行します。
LOADとSTOREを除いて、他のすべての操作を実行している間、Pig Latinステートメントはリレーションを入力として受け取り、別のリレーションを出力として生成します。
Gruntシェルで Load ステートメントを入力するとすぐに、そのセマンティックチェックが実行されます。スキーマの内容を表示するには、 Dump 演算子を使用する必要があります。 dump 操作を実行した後にのみ、データをファイルシステムにロードするMapReduceジョブが実行されます。

例

以下に、Apache PigにデータをロードするPig Latinステートメントを示します。

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

豚のラテン語-データ型

下の表は、Pig Latinデータ型を示しています。

S.N.

データ・タイプ

説明と例

1

int

符号付き32ビット整数を表します。

例：8

2

long

符号付き64ビット整数を表します。

例：5L

3

浮く

符号付き32ビット浮動小数点を表します。

例：5.5F

4

ダブル

64ビットの浮動小数点を表します。

例：10.5

5

文字配列

Unicode UTF-8形式の文字配列（文字列）を表します。

例：「チュートリアルポイント」

6

バイト配列

バイト配列（blob）を表します。

7

ブール値

ブール値を表します。

例：true/false。

8

日付時刻

日時を表します。

例：1970-01-01T00：00：00.000 + 00：00

9

Biginteger

Java BigIntegerを表します。

例：60708090709

10

十進法

Java BigDecimalを表します

例：185.98376256272893883

複合型

11

タプル

タプルは、順序付けられたフィールドのセットです。

例：（raja、30）

12

Bag

バッグはタプルのコレクションです。

例：\ {（raju、30）、（Mohhammad、45）}

13

Map

マップは、キーと値のペアのセットです。

例：[「name」＃「Raju」、「age」＃30]

ヌル値

上記のすべてのデータ型の値はNULLにできます。 Apache Pigは、SQLと同様の方法でnull値を処理します。

nullは、不明な値または存在しない値です。オプションの値のプレースホルダーとして使用されます。これらのヌルは自然に発生する場合と、操作の結果である場合があります。

豚のラテン語-算術演算子

次の表に、Pig Latinの算術演算子を示します。 a = 10およびb = 20と仮定します。

Operator	Description	Example
PLUS	Addition − Adds values on either side of the operator	a PLUS 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. 変数 x =（式）？ value1 if true： value2 if false。 a	b =（a == 1）？ 20：30; a = 1の場合、bの値は20です。 a！= 1の場合、bの値は30です。 a
場合 WHEN THEN 他の終わり	Case − The case operator is equivalent to nested bincond operator.	CASE f2 % 2 0で「偶数」の場合 1 THEN 'ODD’の場合 END

豚ラテン–比較演算子

次の表に、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構成演算子を示します。

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の関係演算子を示します。

オペレーター

説明

読み込みと保存

LOAD

データをファイルシステム（ローカル/HDFS）からリレーションにロードするには。

格納

ファイルシステム（ローカル/HDFS）への関係を保存します。

フィルタリング

フィルタ

リレーションから不要な行を削除します。

DISTINCT

リレーションから重複行を削除します。

FOREACH、GENERATE

データの列に基づいてデータ変換を生成します。

ストリーム

外部プログラムを使用して関係を変換します。

グループ化と参加

JOIN

2つ以上の関係を結合します。

コグループ

データを2つ以上の関係にグループ化する。

グループ

データを単一の関係にグループ化する。

クロス

2つ以上の関係の外積を作成します。

ソート

注文

1つまたは複数のフィールド（昇順または降順）に基づいてソートされた順序でリレーションを配置します。

限定

リレーションから限られた数のタプルを取得します。

結合と分割

連合

2つ以上の関係を単一の関係に結合すること。

スプリット

単一のリレーションを2つ以上のリレーションに分割します。

診断オペレーター

DUMP

コンソールでリレーションの内容を印刷します。

DESCRIBE

関係のスキーマを記述するため。

説明する

論理、物理、またはMapReduce実行プランを表示して、関係を計算します。

イラスト

一連のステートメントのステップごとの実行を表示します。

Apache Pig-データの読み取り

一般的に、Apache PigはHadoopの上で動作します。これは、* H adoop F ile S *システムに存在する大規模なデータセットを分析する分析ツールです。 Apache Pigを使用してデータを分析するには、最初にデータをApache Pigにロードする必要があります。この章では、HDFSからApache Pigにデータをロードする方法について説明します。

HDFSの準備

MapReduceモードでは、PigはHDFSからデータを読み取り（ロード）、HDFSに結果を保存します。したがって、HDFSを起動し、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

上記のデータセットには、6人の学生のID、名、姓、電話番号、市などの個人情報が含まれています。

ステップ1：Hadoopの検証

まず、以下に示すように、Hadoop versionコマンドを使用してインストールを確認します。

$ hadoop version

システムにHadoopが含まれていて、PATH変数を設定している場合、次の出力が得られます-

Hadoop 2.6.0
Subversion https://git-wip-us.apache.org/repos/asf/hadoop.git -r
e3496499ecb8d220fba99dc5ed4c99c8f9e33bb1
Compiled by jenkins on 2014-11-13T21:10Z
Compiled with protoc 2.5.0
From source with checksum 18e43357c8f927c0695f1e9522859d6a
This command was run using/home/Hadoop/hadoop/share/hadoop/common/hadoop
common-2.6.0.jar

ステップ2：HDFSの開始

以下に示すように、Hadoopの sbin ディレクトリを参照し、 yarn およびHadoop dfs（分散ファイルシステム）を起動します。

cd/$Hadoop_Home/sbin/
$ start-dfs.sh
localhost: starting namenode, logging to/home/Hadoop/hadoop/logs/hadoopHadoop-namenode-localhost.localdomain.out
localhost: starting datanode, logging to/home/Hadoop/hadoop/logs/hadoopHadoop-datanode-localhost.localdomain.out
Starting secondary namenodes [0.0.0.0]
starting secondarynamenode, logging to/home/Hadoop/hadoop/logs/hadoop-Hadoopsecondarynamenode-localhost.localdomain.out

$ start-yarn.sh
starting yarn daemons
starting resourcemanager, logging to/home/Hadoop/hadoop/logs/yarn-Hadoopresourcemanager-localhost.localdomain.out
localhost: starting nodemanager, logging to/home/Hadoop/hadoop/logs/yarnHadoop-nodemanager-localhost.localdomain.out

ステップ3：HDFSでディレクトリを作成する

Hadoop DFSでは、 mkdir コマンドを使用してディレクトリを作成できます。以下に示すように、必要なパスに Pig_Data という名前でHDFSに新しいディレクトリを作成します。

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

ステップ4：データをHDFSに配置する

Pigの入力ファイルには、個々の行に各タプル/レコードが含まれています。また、レコードのエンティティは区切り文字で区切られています（この例では*“、” *を使用しました）。

ローカルファイルシステムで、以下に示すデータを含む入力ファイル student_data.txt を作成します。

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

次に、以下に示すように put コマンドを使用して、ローカルファイルシステムからHDFSにファイルを移動します。（ copyFromLocal コマンドも使用できます。）

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

ファイルを検証する

以下に示すように、 cat コマンドを使用して、ファイルがHDFSに移動されたかどうかを確認できます。

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

出力

以下に示すように、ファイルの内容を確認できます。

15/10/01 12:16:55 WARN util.NativeCodeLoader: Unable to load native-hadoop
library for your platform... using builtin-java classes where applicable

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai

ロードオペレーター

*Pig Latin* の *LOAD* 演算子を使用して、ファイルシステム（HDFS/ローカル）からApache Pigにデータをロードできます。

構文

ロードステートメントは、「=」演算子で分割された2つの部分で構成されます。左側では、データを保存するリレーションの名前（ where ）を指定する必要があり、右側では、データを保存する*方法*を定義する必要があります。以下に、 Load 演算子の構文を示します。

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

どこで、

relation_name -データを保存するリレーションについて言及する必要があります。
入力ファイルのパス-ファイルが保存されているHDFSディレクトリに言及する必要があります。（MapReduceモードの場合）
関数-Apache Pigが提供する一連のロード関数（ BinStorage、JsonLoader、PigStorage、TextLoader ）から関数を選択する必要があります。
スキーマ-データのスキーマを定義する必要があります。次のように必要なスキーマを定義できます-

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

注意-スキーマを指定せずにデータをロードします。その場合、列は$ 01、$ 02などとしてアドレス指定されます（チェック）。

例

例として、 LOAD コマンドを使用して、 Student という名前のスキーマの下にあるPigの student_data.txt のデータをロードします。

Pig Grunt Shellを開始します

まず、Linuxターミナルを開きます。以下に示すように、MapReduceモードでPig Gruntシェルを開始します。

$ Pig –x mapreduce

以下に示すように、Pig Gruntシェルが起動します。

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ステートメントを実行する

Gruntシェルで次のPig Latinステートメントを実行して、ファイル student_data.txt からPigにデータをロードします。

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

以下は、上記の説明の説明です。

Relation name	We have stored the data in the schema student.
Input file path	We are reading data from the file student_data.txt, which is in the/pig_data/directory of HDFS.
Storage function	We have used the* PigStorage()* function. It loads and stores data as structured text files. It takes a delimiter using which each entity of a tuple is separated, as a parameter. By default, it takes ‘\t’ as a parameter.
schema	We have stored the data using the following schema.

注- load ステートメントは、Pigで指定されたリレーションにデータを単にロードします。 Load ステートメントの実行を検証するには、次の章で説明する Diagnostic Operators を使用する必要があります。

Apache Pig-データの保存

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

構文

以下に、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.

そして、以下に示すように、LOAD演算子を使用して関係*学生*に読み込みました。

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

次に、以下に示すように、HDFSディレクトリ*“/pig_Output/” *にリレーションを保存します。

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

出力

*store* ステートメントを実行すると、次の出力が得られます。 指定した名前でディレクトリが作成され、データがそこに保存されます。

2015-10-05 13:05:05,429 [main] INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.
MapReduceLau ncher - 100% complete
2015-10-05 13:05:05,429 [main] INFO  org.apache.pig.tools.pigstats.mapreduce.SimplePigStats -
Script Statistics:

HadoopVersion    PigVersion    UserId    StartedAt             FinishedAt             Features
2.6.0            0.15.0        Hadoop    2015-10-0 13:03:03    2015-10-05 13:05:05    UNKNOWN
Success!
Job Stats (time in seconds):
JobId          Maps    Reduces    MaxMapTime    MinMapTime    AvgMapTime    MedianMapTime
job_14459_06    1        0           n/a           n/a           n/a           n/a
MaxReduceTime    MinReduceTime    AvgReduceTime    MedianReducetime    Alias    Feature
     0                 0                0                0             student  MAP_ONLY
OutPut folder
hdfs://localhost:9000/pig_Output/

Input(s): Successfully read 0 records from: "hdfs://localhost:9000/pig_data/student_data.txt"
Output(s): Successfully stored 0 records in: "hdfs://localhost:9000/pig_Output"
Counters:
Total records written : 0
Total bytes written : 0
Spillable Memory Manager spill count : 0
Total bags proactively spilled: 0
Total records proactively spilled: 0

Job DAG: job_1443519499159_0006

2015-10-05 13:06:06,192 [main] INFO  org.apache.pig.backend.hadoop.executionengine
.mapReduceLayer.MapReduceLau ncher - Success!

検証

以下に示すように、保存されたデータを確認できます。

ステップ1

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

hdfs dfs -ls 'hdfs://localhost:9000/pig_Output/'
Found 2 items
rw-r--r-   1 Hadoop supergroup          0 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/_SUCCESS
rw-r--r-   1 Hadoop supergroup        224 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/part-m-00000

*store* ステートメントの実行後に2つのファイルが作成されたことを確認できます。

ステップ2

*cat* コマンドを使用して、以下に示すように *part-m-00000* という名前のファイルの内容をリストします。

$ hdfs dfs -cat 'hdfs://localhost:9000/pig_Output/part-m-00000'
1,Rajiv,Reddy,9848022337,Hyderabad
2,siddarth,Battacharya,9848022338,Kolkata
3,Rajesh,Khanna,9848022339,Delhi
4,Preethi,Agarwal,9848022330,Pune
5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
6,Archana,Mishra,9848022335,Chennai

Apache Pig-診断オペレーター

*load* ステートメントは、Apache Pigの指定された関係にデータを単にロードします。 *Load* ステートメントの実行を確認するには、 *Diagnostic Operators* を使用する必要があります。 豚のラテン語は、診断演算子の4つの異なるタイプを提供します-

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

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

ダンプオペレーター

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

そして、以下に示すように、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 ステートメントを実行すると、MapReduceジョブが開始され、HDFSからデータが読み取られます。次の出力が生成されます。

2015-10-01 15:05:27,642 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLauncher -
100% complete
2015-10-01 15:05:27,652 [main]
INFO  org.apache.pig.tools.pigstats.mapreduce.SimplePigStats - Script Statistics:
HadoopVersion  PigVersion  UserId    StartedAt             FinishedAt       Features
2.6.0          0.15.0      Hadoop  2015-10-01 15:03:11  2015-10-01 05:27     UNKNOWN

Success!
Job Stats (time in seconds):

JobId           job_14459_0004
Maps                 1
Reduces              0
MaxMapTime          n/a
MinMapTime          n/a
AvgMapTime          n/a
MedianMapTime       n/a
MaxReduceTime        0
MinReduceTime        0
AvgReduceTime        0
MedianReducetime     0
Alias             student
Feature           MAP_ONLY
Outputs           hdfs://localhost:9000/tmp/temp580182027/tmp757878456,

Input(s): Successfully read 0 records from: "hdfs://localhost:9000/pig_data/
student_data.txt"

Output(s): Successfully stored 0 records in: "hdfs://localhost:9000/tmp/temp580182027/
tmp757878456"

Counters: Total records written : 0 Total bytes written : 0 Spillable Memory Manager
spill count : 0Total bags proactively spilled: 0 Total records proactively spilled: 0

Job DAG: job_1443519499159_0004

2015-10-01 15:06:28,403 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLau ncher - Success!
2015-10-01 15:06:28,441 [main] INFO  org.apache.pig.data.SchemaTupleBackend -
Key [pig.schematuple] was not set... will not generate code.
2015-10-01 15:06:28,485 [main]
INFO  org.apache.hadoop.mapreduce.lib.input.FileInputFormat - Total input paths
to process : 1
2015-10-01 15:06:28,485 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.util.MapRedUtil - Total input paths
to process : 1

(1,Rajiv,Reddy,9848022337,Hyderabad)
(2,siddarth,Battacharya,9848022338,Kolkata)
(3,Rajesh,Khanna,9848022339,Delhi)
(4,Preethi,Agarwal,9848022330,Pune)
(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,9848022335,Chennai)

Apache Pig-オペレーターの説明

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

そして、以下に示すように、LOAD演算子を使用して関係*学生*に読み込みました。

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

ここで、 student という名前の関係について説明し、以下に示すようにスキーマを検証します。

grunt> describe student;

出力

上記の Pig Latin ステートメントを実行すると、次の出力が生成されます。

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

Apache Pig-Explainオペレーター

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

そして、以下に示すように、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 );

次に、以下に示すように explain 演算子を使用して、studentという名前の関係を説明します。

grunt> explain student;

出力

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

$ explain student;

2015-10-05 11:32:43,660 [main]
2015-10-05 11:32:43,660 [main] INFO  org.apache.pig.newplan.logical.optimizer
.LogicalPlanOptimizer -
{RULES_ENABLED=[AddForEach, ColumnMapKeyPrune, ConstantCalculator,
GroupByConstParallelSetter, LimitOptimizer, LoadTypeCastInserter, MergeFilter,
MergeForEach, PartitionFilterOptimizer, PredicatePushdownOptimizer,
PushDownForEachFlatten, PushUpFilter, SplitFilter, StreamTypeCastInserter]}
#-----------------------------------------------
# New Logical Plan:
#-----------------------------------------------
student: (Name: LOStore Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)
|
|---student: (Name: LOForEach Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)
    |   |
    |   (Name: LOGenerate[false,false,false,false,false] Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)ColumnPrune:InputUids=[34, 35, 32, 33,
31]ColumnPrune:OutputUids=[34, 35, 32, 33, 31]
    |   |   |
    |   |   (Name: Cast Type: int Uid: 31)
    |   |   |     |   |   |---id:(Name: Project Type: bytearray Uid: 31 Input: 0 Column: (*))
    |   |   |
    |   |   (Name: Cast Type: chararray Uid: 32)
    |   |   |
    |   |   |---firstname:(Name: Project Type: bytearray Uid: 32 Input: 1
Column: (*))
    |   |   |
    |   |   (Name: Cast Type: chararray Uid: 33)
    |   |   |
    |   |   |---lastname:(Name: Project Type: bytearray Uid: 33 Input: 2
     Column: (*))
    |   |   |
    |   |   (Name: Cast Type: chararray Uid: 34)
    |   |   |
    |   |   |---phone:(Name: Project Type: bytearray Uid: 34 Input: 3 Column:
(*))
    |   |   |
    |   |   (Name: Cast Type: chararray Uid: 35)
    |   |   |
    |   |   |---city:(Name: Project Type: bytearray Uid: 35 Input: 4 Column:
(*))
    |   |
    |   |---(Name: LOInnerLoad[0] Schema: id#31:bytearray)
    |   |
    |   |---(Name: LOInnerLoad[1] Schema: firstname#32:bytearray)
    |   |
    |   |---(Name: LOInnerLoad[2] Schema: lastname#33:bytearray)
    |   |
    |   |---(Name: LOInnerLoad[3] Schema: phone#34:bytearray)
    |   |
    |   |---(Name: LOInnerLoad[4] Schema: city#35:bytearray)
    |
    |---student: (Name: LOLoad Schema:
id#31:bytearray,firstname#32:bytearray,lastname#33:bytearray,phone#34:bytearray
,city#35:bytearray)RequiredFields:null
#-----------------------------------------------
# Physical Plan: #-----------------------------------------------
student: Store(fakefile:org.apache.pig.builtin.PigStorage) - scope-36
|
|---student: New For Each(false,false,false,false,false)[bag] - scope-35
    |   |
    |   Cast[int] - scope-21
    |   |
    |   |---Project[bytearray][0] - scope-20
    |   |
    |   Cast[chararray] - scope-24
    |   |
    |   |---Project[bytearray][1] - scope-23
    |   |
    |   Cast[chararray] - scope-27
    |   |
    |   |---Project[bytearray][2] - scope-26
    |   |
    |   Cast[chararray] - scope-30
    |   |
    |   |---Project[bytearray][3] - scope-29
    |   |
    |   Cast[chararray] - scope-33
    |   |
    |   |---Project[bytearray][4] - scope-32
    |
    |---student: Load(hdfs://localhost:9000/pig_data/student_data.txt:PigStorage(',')) - scope19
2015-10-05 11:32:43,682 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MRCompiler -
File concatenation threshold: 100 optimistic? false
2015-10-05 11:32:43,684 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MultiQueryOp timizer -
MR plan size before optimization: 1 2015-10-05 11:32:43,685 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.
MultiQueryOp timizer - MR plan size after optimization: 1
#--------------------------------------------------
# Map Reduce Plan
#--------------------------------------------------
MapReduce node scope-37
Map Plan
student: Store(fakefile:org.apache.pig.builtin.PigStorage) - scope-36
|
|---student: New For Each(false,false,false,false,false)[bag] - scope-35
    |   |
    |   Cast[int] - scope-21
    |   |
    |   |---Project[bytearray][0] - scope-20
    |   |
    |   Cast[chararray] - scope-24
    |   |
    |   |---Project[bytearray][1] - scope-23
    |   |
    |   Cast[chararray] - scope-27
    |   |
    |   |---Project[bytearray][2] - scope-26
    |   |
    |   Cast[chararray] - scope-30
    |   |
    |   |---Project[bytearray][3] - scope-29
    |   |
    |   Cast[chararray] - scope-33
    |   |
    |   |---Project[bytearray][4] - scope-32
    |
    |---student:
Load(hdfs://localhost:9000/pig_data/student_data.txt:PigStorage(',')) - scope
19-------- Global sort: false
 ----------------

Apache Pig-イラストレーター

*illustrate* 演算子を使用すると、一連のステートメントをステップごとに実行できます。

構文

以下に示すのは、 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.

そして、以下に示すように、LOAD演算子を使用して関係*学生*に読み込みました。

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

次に、以下に示すように、studentという名前の関係を説明します。

grunt> illustrate student;

出力

上記のステートメントを実行すると、次の出力が得られます。

grunt> illustrate student;

INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.PigMapOnly$M ap - Aliases
being processed per job phase (AliasName[line,offset]): M: student[1,10] C:  R:
---------------------------------------------------------------------------------------------
|student | id:int | firstname:chararray | lastname:chararray | phone:chararray | city:chararray |
---------------------------------------------------------------------------------------------
|        | 002    | siddarth            | Battacharya        | 9848022338      | Kolkata        |
---------------------------------------------------------------------------------------------

Apache Pig-グループオペレーター

*GROUP* 演算子は、1つ以上の関係でデータをグループ化するために使用されます。 同じキーを持つデータを収集します。

構文

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

grunt> Group_data = GROUP Relation_name BY age;

例

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

*student_details.txt*

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

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

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

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

grunt> group_data = GROUP student_details by age;

検証

以下に示すように、 DUMP 演算子を使用してリレーション group_data を確認します。

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

以下に示すように、Dump演算子を使用して、 group_multiple という名前の関係の内容を確認できます。

grunt> Dump group_multiple;

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

すべてをグループ化

以下に示すように、すべての列でリレーションをグループ化できます。

grunt> group_all = GROUP student_details All;

次に、以下に示すように、関係 group_all の内容を確認します。

grunt> Dump group_all;

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

Apache Pig-コグループオペレーター

*COGROUP* 演算子は、リンク：/apache_pig/apache_pig_group_operator [GROUP]演算子とほぼ同じように機能します。 2つの演算子の唯一の違いは、 *group* 演算子は通常1つのリレーションで使用され、 *cogroup* 演算子は2つ以上のリレーションを含むステートメントで使用されることです。

Cogroupを使用した2つの関係のグループ化

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

*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

そして、以下に示すように、これらのファイルをそれぞれ student_details および employee_details という関係名でPigにロードしました。

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

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

次に、以下に示すように、関係 student_details および employee_details のレコード/タプルをキーの年齢でグループ化します。

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

検証

以下に示すように、 DUMP 演算子を使用してリレーション cogroup_data を確認します。

grunt> Dump cogroup_data;

出力

以下の出力が生成され、下に示すように cogroup_data という名前の関係の内容が表示されます。

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

*cogroup* 演算子は、年齢ごとに各リレーションのタプルをグループ化し、各グループは特定の年齢値を表します。

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

最初のバッグには、21歳の最初の関係（この場合は student_details ）からのすべてのタプルが含まれます。
2番目のバッグには、21歳の2番目の関係（この場合は employee_details ）からのすべてのタプルが含まれます。

関係に年齢値が21のタプルがない場合、空のバッグが返されます。

Apache Pig-結合演算子

*JOIN* 演算子は、2つ以上のリレーションのレコードを結合するために使用されます。 結合操作の実行中に、各リレーションから1つ（またはグループ）のタプルをキーとして宣言します。 これらのキーが一致すると、2つの特定のタプルが一致します。一致しない場合、レコードは削除されます。 結合は次のタイプにすることができます-

自己結合
内部結合
外部結合-左結合、右結合、および完全結合

この章では、Pig Latinで結合演算子を使用する方法を例で説明します。以下に示すように、HDFSの /pig_data/ ディレクトリに customers.txt と orders.txt の2つのファイルがあると仮定します。

*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

そして、以下に示すように、これらの2つのファイルを customers および orders の関係でPigにロードしました。

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);

grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')
   as (oid:int, date:chararray, customer_id:int, amount:int);

これら2つのリレーションに対してさまざまなJoin操作を実行してみましょう。

自己参加

*Self-join* は、テーブルが2つのリレーションであるかのようにテーブルをそれ自身と結合するために使用され、少なくとも1つのリレーションを一時的に名前変更します。

一般的に、Apache Pigでは、自己結合を実行するために、異なるエイリアス（名前）で同じデータを複数回ロードします。したがって、ファイル customers.txt の内容を以下に示す2つのテーブルとしてロードします。

grunt> customers1 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);

grunt> customers2 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);

構文

以下に示すのは、 JOIN 演算子を使用して*自己結合*操作を実行する構文です。

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

例

以下に示すように、2つのリレーション customers1 および customers2 を結合することにより、リレーション customers で*自己結合*操作を実行しましょう。

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

検証

以下に示すように、 DUMP 演算子を使用してリレーション customers3 を確認します。

grunt> Dump customers3;

出力

リレーション customers の内容を表示する次の出力を生成します。

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

内部結合

内部結合*は非常に頻繁に使用されます。 *equijoin とも呼ばれます。内部結合は、両方のテーブルに一致する行を返します。

結合述語に基づいて2つのリレーション（AとBなど）の列の値を組み合わせて、新しいリレーションを作成します。クエリは、Aの各行をBの各行と比較して、結合述部を満たす行のすべてのペアを見つけます。 join-predicateが満たされると、AとBの行の各一致ペアの列値が結果行に結合されます。

構文

*JOIN* 演算子を使用して*内部結合*操作を実行する構文を次に示します。

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

例

以下に示すように、 customers と orders の2つのリレーションに対して inner join 操作を実行してみましょう。

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

検証

以下に示すように、 DUMP 演算子を使用してリレーション coustomer_orders を確認します。

grunt> Dump coustomer_orders;

出力

*coustomer_orders* という名前のリレーションの内容を含む次の出力が得られます。

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

注-

Outer Join：内部結合とは異なり、*外部結合*は少なくとも1つのリレーションからすべての行を返します。外部結合操作は3つの方法で実行されます-

左外部結合
右外部結合
完全外部結合

左外部結合

左外部結合*操作は、右のリレーションに一致するものがない場合でも、左のテーブルからすべての行を返します。

構文

以下に示すのは、 JOIN 演算子を使用して*左外部結合*操作を実行する構文です。

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

例

以下に示すように、2つのリレーションの顧客と注文に対して左外部結合操作を実行しましょう。

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

検証

以下に示すように、 DUMP 演算子を使用して、関係 outer_left を確認します。

grunt> Dump outer_left;

出力

リレーション outer_left の内容を表示する次の出力を生成します。

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

右外部結合

右外部結合*操作は、左のテーブルに一致するものがない場合でも、右のテーブルからすべての行を返します。

構文

以下に示すのは、 JOIN 演算子を使用して*右外部結合*操作を実行する構文です。

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

例

以下に示すように、2つのリレーションシップ customers および orders で*右外部結合*操作を実行します。

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

検証

以下に示すように、 DUMP 演算子を使用して、関係 outer_right を確認します。

grunt> Dump outer_right

出力

次の出力が生成され、リレーション outer_right の内容が表示されます。

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

フル外部結合

*full outer join* 操作は、リレーションのいずれかに一致する行を返します。

構文

以下は、 JOIN 演算子を使用して*完全外部結合*を実行する構文です。

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

例

以下に示すように、2つのリレーションシップ customers および orders で*完全外部結合*操作を実行します。

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

検証

以下に示すように、 DUMP 演算子を使用して、関係 outer_full を確認します。

grun> Dump outer_full;

出力

次の出力が生成され、リレーション outer_full の内容が表示されます。

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

複数のキーを使用する

複数のキーを使用してJOIN操作を実行できます。

構文

複数のキーを使用して2つのテーブルでJOIN操作を実行する方法を次に示します。

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

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

*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

そして、以下に示すように、これら2つのファイルを employee および employee_contact の関係でPigにロードしました。

grunt> employee = LOAD 'hdfs://localhost:9000/pig_data/employee.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, designation:chararray, jobid:int);

grunt> employee_contact = LOAD 'hdfs://localhost:9000/pig_data/employee_contact.txt' USING PigStorage(',')
   as (id:int, phone:chararray, email:chararray, city:chararray, jobid:int);

次に、以下に示す JOIN 演算子を使用して、これら2つのリレーションのコンテンツを結合します。

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

検証

以下に示すように、 DUMP 演算子を使用して、リレーション emp を確認します。

grunt> Dump emp;

出力

次の出力が生成され、下に示すように emp という名前の関係の内容が表示されます。

(1,Rajiv,Reddy,21,programmer,113,1,9848022337,[email protected],Hyderabad,113)
(2,siddarth,Battacharya,22,programmer,113,2,9848022338,[email protected],Kolka ta,113)
(3,Rajesh,Khanna,22,programmer,113,3,9848022339,[email protected],Delhi,113)
(4,Preethi,Agarwal,21,programmer,113,4,9848022330,[email protected],Pune,113)
(5,Trupthi,Mohanthy,23,programmer,113,5,9848022336,[email protected],Bhuwaneshw ar,113)
(6,Archana,Mishra,23,programmer,113,6,9848022335,[email protected],Chennai,113)
(7,Komal,Nayak,24,teamlead,112,7,9848022334,[email protected],trivendram,112)
(8,Bharathi,Nambiayar,24,manager,111,8,9848022333,[email protected],Chennai,111)

Apache Pig-クロスオペレーター

*CROSS* 演算子は、2つ以上の関係の外積を計算します。 この章では、Pig Latinでクロス演算子を使用する方法を例で説明します。

構文

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

grunt> Relation3_name = CROSS Relation1_name, Relation2_name;

例

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

*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

そして、以下に示すように、これらの2つのファイルを customers および orders の関係でPigにロードしました。

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);

grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')
   as (oid:int, date:chararray, customer_id:int, amount:int);

以下に示すように、これらの2つのリレーションに対して cross 演算子を使用して、これらの2つのリレーションの外積を取得します。

grunt> cross_data = CROSS customers, orders;

検証

以下に示すように、 DUMP 演算子を使用して、リレーション cross_data を確認します。

grunt> Dump cross_data;

出力

次の出力が生成され、リレーション cross_data の内容が表示されます。

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

Apache Pig-ユニオンオペレーター

Pig Latinの UNION 演算子は、2つのリレーションのコンテンツをマージするために使用されます。 2つのリレーションに対してUNION操作を実行するには、それらの列とドメインが同一である必要があります。

構文

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

grunt> Relation_name3 = UNION Relation_name1, Relation_name2;

例

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

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

そして、以下に示すように、これらの2つのファイルを student1 および student2 の関係でPigにロードしました。

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

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

以下に示すように、 UNION 演算子を使用して、これら2つの関係の内容をマージしましょう。

grunt> student = UNION student1, student2;

検証

以下に示すように、 DUMP 演算子を使用して、関係 student を確認します。

grunt> Dump student;

出力

リレーション student の内容を表示する次の出力を表示します。

(1,Rajiv,Reddy,9848022337,Hyderabad) (2,siddarth,Battacharya,9848022338,Kolkata)
(3,Rajesh,Khanna,9848022339,Delhi)
(4,Preethi,Agarwal,9848022330,Pune)
(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,9848022335,Chennai)
(7,Komal,Nayak,9848022334,trivendram)
(8,Bharathi,Nambiayar,9848022333,Chennai)

Apache Pig-分割オペレーター

*SPLIT* 演算子は、リレーションを2つ以上のリレーションに分割するために使用されます。

構文

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

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

例

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

*student_details.txt*

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

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

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

リレーションを2つに分割します。1つは23歳未満の従業員をリストし、もう1つは22〜25歳の従業員をリストします。

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

検証

以下に示すように、 DUMP 演算子を使用して、関係 student_details1 および student_details2 を確認します。

grunt> Dump student_details1;

grunt> Dump student_details2;

出力

リレーション student_details1 および student_details2 の内容をそれぞれ表示する次の出力を生成します。

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

grunt> Dump student_details2;
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,23,9848022335,Chennai)
(7,Komal,Nayak,24,9848022334,trivendram)
(8,Bharathi,Nambiayar,24,9848022333,Chennai)

Apache Pig-フィルターオペレーター

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

構文

以下に示すのは、 FILTER 演算子の構文です。

grunt> Relation2_name = FILTER Relation1_name BY (condition);

例

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

*student_details.txt*

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

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

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

ここで、フィルター演算子を使用して、チェンナイ市に属する学生の詳細を取得します。

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

検証

以下に示すように、 DUMP 演算子を使用してリレーション filter_data を確認します。

grunt> Dump filter_data;

出力

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

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

Apache Pig-個別のオペレーター

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

構文

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

grunt> Relation_name2 = DISTINCT Relatin_name1;

例

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

*student_details.txt*

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai
006,Archana,Mishra,9848022335,Chennai

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

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

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

grunt> distinct_data = DISTINCT student_details;

検証

以下に示すように、 DUMP 演算子を使用して、リレーション distinct_data を確認します。

grunt> Dump distinct_data;

出力

次の出力が生成され、リレーション distinct_data の内容が次のように表示されます。

(1,Rajiv,Reddy,9848022337,Hyderabad)
(2,siddarth,Battacharya,9848022338,Kolkata)
(3,Rajesh,Khanna,9848022339,Delhi)
(4,Preethi,Agarwal,9848022330,Pune)
(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,9848022335,Chennai)

Apache Pig-Foreachオペレーター

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

構文

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

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

例

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

*student_details.txt*

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

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

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

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

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

検証

以下に示すように、 DUMP 演算子を使用して、リレーション foreach_data を確認します。

grunt> Dump foreach_data;

出力

次の出力が生成され、リレーション foreach_data の内容が表示されます。

(1,21,Hyderabad)
(2,22,Kolkata)
(3,22,Delhi)
(4,21,Pune)
(5,23,Bhuwaneshwar)
(6,23,Chennai)
(7,24,trivendram)
(8,24,Chennai)

Apache Pig-注文者

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

構文

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

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

例

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

*student_details.txt*

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

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

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

次に、生徒の年齢に基づいてリレーションを降順に並べ替え、次に示すように ORDER BY 演算子を使用して order_by_data という名前の別のリレーションに保存します。

grunt> order_by_data = ORDER student_details BY age DESC;

検証

以下に示すように、 DUMP 演算子を使用して、リレーション order_by_data を確認します。

grunt> Dump order_by_data;

出力

リレーション order_by_data の内容を表示する次の出力を生成します。

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

Apache Pig-制限演算子

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

構文

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

grunt> Result = LIMIT Relation_name required number of tuples;

例

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

*student_details.txt*

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

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

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

次に、生徒の年齢に基づいて関係を降順に並べ替え、次に示すように ORDER BY 演算子を使用して limit_data という名前の別の関係に保存します。

grunt> limit_data = LIMIT student_details 4;

検証

以下に示すように、 DUMP 演算子を使用してリレーション limit_data を確認します。

grunt> Dump limit_data;

出力

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

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

Apache Pig-評価関数

Apache Pigには、 eval、load、store、math、string、bag 、 tuple 関数などのさまざまな組み込み関数が用意されています。

評価関数

以下は、Apache Pigが提供する eval 関数のリストです。

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

Apache Pig-ロードおよびストア関数

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

S.N.	Function & Description
1	PigStorage() 構造化ファイルをロードおよび保存します。
2	TextLoader() 非構造化データをPigにロードします。
3	BinStorage() 機械可読形式を使用して、Pigにデータをロードおよび保存します。
4	Handling Compression Pig Latinでは、圧縮データをロードして保存できます。

Apache Pig-バッグ＆タプル関数

以下に、BagおよびTuple関数のリストを示します。

S.N.	Function & Description
1	TOBAG() 2つ以上の式をバッグに変換します。
2	TOP() リレーションの上位 N タプルを取得します。
3	TOTUPLE() 1つ以上の式をタプルに変換します。
4	TOMAP() キーと値のペアをマップに変換します。

Apache Pig-文字列関数

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

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

Apache Pig-日時関数

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

S.N.	Functions & Description
1	ToDate(milliseconds) この関数は、指定されたパラメーターに従って日時オブジェクトを返します。この関数の他の代替手段は、ToDate（iosstring）、ToDate（userstring、format）、ToDate（userstring、format、timezone）です。
2	CurrentTime() 現在時刻の日付時刻オブジェクトを返します。
3	GetDay(datetime) 日時オブジェクトから月の日を返します。
4	GetHour(datetime) 日時オブジェクトから1日の時間を返します。
5	GetMilliSecond(datetime) 日時オブジェクトからミリ秒を返します。
6	GetMinute(datetime) 日時オブジェクトから時の分を返します。
7	GetMonth(datetime) 日時オブジェクトから年の月を返します。
8	GetSecond(datetime) 日時オブジェクトから秒を返します。
9	GetWeek(datetime) 日時オブジェクトから年の週を返します。
10	GetWeekYear(datetime) 日時オブジェクトから週年を返します。
11	GetYear(datetime) 日付時刻オブジェクトから年を返します。
12	AddDuration(datetime, duration) 期間オブジェクトとともに日時オブジェクトの結果を返します。
13	SubtractDuration(datetime, duration) Date-TimeオブジェクトからDurationオブジェクトを減算し、結果を返します。
14	DaysBetween(datetime1, datetime2) 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つの日時オブジェクト間の年数を返します。

Apache Pig-数学関数

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

S.N.	Functions & Description
1	ABS(expression) 式の絶対値を取得します。
2	ACOS(expression) 式の逆余弦を取得します。
3	ASIN(expression) 式の逆正弦を取得します。
4	ATAN(expression) この関数は、式の逆正接を取得するために使用されます。
5	CBRT(expression) この関数は、式のキューブルートを取得するために使用されます。
6	CEIL(expression) この関数は、最も近い整数に切り上げられた式の値を取得するために使用されます。
7	COS(expression) この関数は、式の三角関数のコサインを取得するために使用されます。
8	COSH(expression) この関数は、式の双曲線余弦を取得するために使用されます。
9	EXP(expression) この関数は、オイラーの数値eをxで累乗するために使用されます。
10	FLOOR(expression) 最も近い整数に切り捨てられた式の値を取得します。
11	LOG(expression) 式の自然対数（底e）を取得します。
12	LOG10(expression) 式の10を底とする対数を取得します。
13	RANDOM( ) 0.0以上1.0未満の擬似乱数（double型）を取得します。
14	ROUND(expression) 式の値を整数に丸める（結果の型がfloatの場合）またはlongに丸める（結果の型がdoubleの場合）。
15	SIN(expression) 式のサインを取得します。
16	SINH(expression) 式の双曲線正弦を取得します。
17	SQRT(expression) 式の正の平方根を取得します。
18	TAN(expression) 角度の三角関数タンジェントを取得します。
19	TANH(expression) 式の双曲線正接を取得します。

Apache Pig-ユーザー定義関数

組み込み関数に加えて、Apache Pigは* U ser D efined F * unctions（UDF）の広範なサポートを提供します。これらのUDFを使用して、独自の関数を定義して使用できます。 UDFサポートは、Java、Jython、Python、JavaScript、Ruby、Groovyの6つのプログラミング言語で提供されます。

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

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

JavaのUDFの種類

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

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

Javaを使用してUDFを記述する

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

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

Eclipseを開き、新しいプロジェクト（ myproject など）を作成します。
新しく作成したプロジェクトをMavenプロジェクトに変換します。
pom.xmlの次のコンテンツをコピーします。このファイルには、Apache PigおよびHadoop-core jarファイルのMaven依存関係が含まれています。

<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0http://maven.apache .org/xsd/maven-4.0.0.xsd">

   <modelVersion>4.0.0</modelVersion>
   <groupId>Pig_Udf</groupId>
   <artifactId>Pig_Udf</artifactId>
   <version>0.0.1-SNAPSHOT</version>

   <build>
      <sourceDirectory>src</sourceDirectory>
      <plugins>
         <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.3</version>
            <configuration>
               <source>1.7</source>
               <target>1.7</target>
            </configuration>
         </plugin>
      </plugins>
   </build>

   <dependencies>

      <dependency>
         <groupId>org.apache.pig</groupId>
         <artifactId>pig</artifactId>
         <version>0.15.0</version>
      </dependency>

      <dependency>
         <groupId>org.apache.hadoop</groupId>
         <artifactId>hadoop-core</artifactId>
         <version>0.20.2</version>
      </dependency>

   </dependencies>

</project>

 *ファイルを保存して更新します。* Maven 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ファイル*をクリックします。

エクスポートをクリック

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

jar export

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

UDFを使用する

UDFを書いてJarファイルを生成した後、以下の手順に従ってください-

ステップ1：Jarファイルの登録

（Javaで）UDFを作成した後、Register演算子を使用してUDFを含むJarファイルを登録する必要があります。 Jarファイルを登録することにより、ユーザーはUDFの場所をApache Pigに関連付けることができます。

構文

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

REGISTER path;

例

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

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

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

REGISTER '/$PIG_HOME/sample_udf.jar'

注-パスにあるJarファイルを想定-/$PIG_HOME/sample_udf.jar

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

UDFを登録したら、 Define 演算子を使用してUDFにエイリアスを定義できます。

構文

以下に定義演算子の構文を示します。

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

例 *

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

DEFINE sample_eval sample_eval();

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

エイリアスを定義した後、組み込み関数と同じUDFを使用できます。 HDFS*/Pig_Data/*ディレクトリに次の内容のemp_dataという名前のファイルがあるとします。

001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London
005,David,23,Bhuwaneshwar
006,Maggy,22,Chennai
007,Robert,22,newyork
008,Syam,23,Kolkata
009,Mary,25,Tokyo
010,Saran,25,London
011,Stacy,25,Bhuwaneshwar
012,Kelly,22,Chennai

以下に示すように、このファイルをPigにロードしたと仮定します。

grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp1.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);

UDF sample_eval を使用して、従業員の名前を大文字に変換します。

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

以下に示すように、リレーション Upper_case の内容を確認します。

grunt> Dump Upper_case;

(ROBIN)
(BOB)
(MAYA)
(SARA)
(DAVID)
(MAGGY)
(ROBERT)
(SYAM)
(MARY)
(SARAN)
(STACY)
(KELLY)

Apache Pig-スクリプトの実行

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

Pigスクリプトのコメント

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

複数行コメント

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

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

単一行コメント

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

--we can write single line comments like this.

バッチモードでPigスクリプトを実行する

Apache Pigステートメントをバッチモードで実行しながら、以下の手順に従います。

ステップ1

必要なすべてのPig Latinステートメントを単一のファイルに書き込みます。すべてのPig Latinステートメントとコマンドを単一のファイルに記述し、*。pig *ファイルとして保存できます。

ステップ2

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

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

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

grunt> exec/sample_script.pig

HDFSからPigスクリプトを実行する

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

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

例

次の内容のファイル 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

同じHDFSディレクトリに sample_script.pig という名前のサンプルスクリプトもあります。このファイルには、以下に示すように、 student 関係で操作と変換を実行するステートメントが含まれています。

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

student_order = ORDER student BY age DESC;

student_limit = LIMIT student_order 4;

Dump student_limit;

スクリプトの最初のステートメントは、 student_details.txt という名前のファイルのデータを student という名前の関係としてロードします。
スクリプトの2番目のステートメントは、関係のタプルを年齢に基づいて降順に並べ、 student_order として保存します。
スクリプトの3番目のステートメントは、 student_order の最初の4つのタプルを 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)

Apache-pig-quick-guide

Apache Pig-概要

Apache Pigとは何ですか？

Apache Pigが必要な理由

豚の特徴

Apache Pig対MapReduce

Apache Pig対SQL

Apache Pig Vs Hive

Apache Pigのアプリケーション

Apache Pig –歴史

Apache Pig-アーキテクチャ

Apache Pigコンポーネント

パーサ

オプティマイザ

コンパイラ

実行エンジン

豚ラテンデータモデル

Atom

タプル

Bag

Map

関係

Apache Pig-インストール

前提条件

Apache Pigをダウンロードする

ステップ1

ステップ2

ステップ3

ステップ4

ステップ5

Apache Pigをインストールする

ステップ1

ステップ2

ステップ3

Apache Pigを構成する

.bashrcファイル

pig.propertiesファイル

インストールの検証

Apache Pig-実行

Apache Pig実行モード

ローカルモード

MapReduceモード

Apache Pig実行メカニズム

Grunt Shellの呼び出し

バッチモードでのApache Pigの実行

Sample_script.pig

Apache Pig-Grunt Shell

シェルコマンド

shコマンド

fsコマンド

ユーティリティコマンド

クリアコマンド

helpコマンド

historyコマンド

setコマンド

終了コマンド

execコマンド

killコマンド

コマンドを実行

豚のラテン語-基本

豚ラテン–データモデル

豚のラテン語-ステートメッツ

例

豚のラテン語-データ型

ヌル値

豚のラテン語-算術演算子

豚ラテン–比較演算子

豚のラテン語–型構築演算子

豚のラテン語-リレーショナルオペレーション

Apache Pig-データの読み取り

HDFSの準備

ステップ1：Hadoopの検証

ステップ2：HDFSの開始

ステップ3：HDFSでディレクトリを作成する

ステップ4：データをHDFSに配置する

ファイルを検証する

出力

ロードオペレーター

構文

例