Apache Pig - Kurzanleitung

Was ist Apache Pig?

Apache Pig ist eine Abstraktion über MapReduce. Es ist ein Tool / eine Plattform, mit der größere Datenmengen analysiert werden, die sie als Datenflüsse darstellen. Schwein wird in der Regel mit verwendetHadoop;; Wir können alle Datenmanipulationsvorgänge in Hadoop mit Apache Pig ausführen.

Zum Schreiben von Datenanalyseprogrammen bietet Pig eine Hochsprache namens Pig Latin. Diese Sprache bietet verschiedene Operatoren, mit denen Programmierer ihre eigenen Funktionen zum Lesen, Schreiben und Verarbeiten von Daten entwickeln können.

Daten mit analysieren Apache PigProgrammierer müssen Skripte in der lateinischen Sprache Pig schreiben. Alle diese Skripte werden intern in Map- und Reduce-Aufgaben konvertiert. Apache Pig hat eine Komponente, die als bekannt istPig Engine Dadurch werden die Pig Latin-Skripte als Eingabe akzeptiert und diese Skripte in MapReduce-Jobs konvertiert.

Warum brauchen wir Apache Pig?

Programmierer, die nicht so gut mit Java umgehen können, hatten normalerweise Schwierigkeiten, mit Hadoop zu arbeiten, insbesondere bei der Ausführung von MapReduce-Aufgaben. Apache Pig ist ein Segen für all diese Programmierer.

• Verwenden von Pig LatinProgrammierer können MapReduce-Aufgaben problemlos ausführen, ohne komplexe Codes in Java eingeben zu müssen.

• Apache Pig verwendet multi-query approachwodurch die Länge der Codes verringert wird. Zum Beispiel kann eine Operation, bei der Sie 200 Codezeilen (LoC) in Java eingeben müssen, einfach ausgeführt werden, indem Sie in Apache Pig nur 10 LoC eingeben. Letztendlich reduziert Apache Pig die Entwicklungszeit um fast das 16-fache.

• Schwein Latein ist SQL-like language und es ist einfach, Apache Pig zu lernen, wenn Sie mit SQL vertraut sind.

• Apache Pig bietet viele integrierte Operatoren zur Unterstützung von Datenvorgängen wie Verknüpfungen, Filtern, Ordnungen usw. Darüber hinaus bietet es verschachtelte Datentypen wie Tupel, Taschen und Karten, die in MapReduce fehlen.

Eigenschaften von Schwein

Apache Pig bietet die folgenden Funktionen:

• Rich set of operators - Es bietet vielen Bedienern die Möglichkeit, Vorgänge wie Join, Sortieren, Filer usw. auszuführen.

• Ease of programming - Pig Latin ähnelt SQL und es ist einfach, ein Pig-Skript zu schreiben, wenn Sie gut mit SQL umgehen können.

• Optimization opportunities - Die Aufgaben in Apache Pig optimieren ihre Ausführung automatisch, sodass sich die Programmierer nur auf die Semantik der Sprache konzentrieren müssen.

• Extensibility - Mit den vorhandenen Operatoren können Benutzer ihre eigenen Funktionen zum Lesen, Verarbeiten und Schreiben von Daten entwickeln.

• UDF’s - Schwein bietet die Möglichkeit zu erstellen User-defined Functions in anderen Programmiersprachen wie Java und rufen Sie diese auf oder binden Sie sie in Pig Scripts ein.

• Handles all kinds of data- Apache Pig analysiert alle Arten von Daten, sowohl strukturiert als auch unstrukturiert. Die Ergebnisse werden in HDFS gespeichert.

Apache Pig gegen MapReduce

Nachfolgend sind die Hauptunterschiede zwischen Apache Pig und MapReduce aufgeführt.

Apache Pig	Karte verkleinern
Apache Pig ist eine Datenflusssprache.	MapReduce ist ein Datenverarbeitungsparadigma.
Es ist eine Hochsprache.	MapReduce ist niedrig und starr.
Das Ausführen eines Join-Vorgangs in Apache Pig ist ziemlich einfach.	In MapReduce ist es ziemlich schwierig, eine Verknüpfungsoperation zwischen Datasets auszuführen.
Jeder unerfahrene Programmierer mit Grundkenntnissen in SQL kann bequem mit Apache Pig arbeiten.	Die Verwendung von Java ist ein Muss, um mit MapReduce arbeiten zu können.
Apache Pig verwendet einen Multi-Query-Ansatz, wodurch die Länge der Codes erheblich reduziert wird.	MapReduce benötigt fast 20-mal mehr Zeilen, um dieselbe Aufgabe auszuführen.
Es ist keine Kompilierung erforderlich. Bei der Ausführung wird jeder Apache Pig-Operator intern in einen MapReduce-Job konvertiert.	MapReduce-Jobs haben einen langen Kompilierungsprozess.

Apache Pig gegen SQL

Nachfolgend sind die Hauptunterschiede zwischen Apache Pig und SQL aufgeführt.

Schwein	SQL
Schwein Latein ist ein procedural Sprache.	SQL ist ein declarative Sprache.
In Apache Pig, schemaes ist optional. Wir können Daten speichern, ohne ein Schema zu entwerfen (Werte werden als gespeichert$01, $02 etc.)	Das Schema ist in SQL obligatorisch.
Das Datenmodell in Apache Pig ist nested relational.	Das in SQL verwendete Datenmodell is flat relational.
Apache Pig bietet nur begrenzte Möglichkeiten für Query optimization.	In SQL gibt es mehr Möglichkeiten zur Abfrageoptimierung.

Zusätzlich zu den oben genannten Unterschieden bietet Apache Pig Latin -

• Ermöglicht Splits in der Pipeline.
• Ermöglicht Entwicklern das Speichern von Daten an einer beliebigen Stelle in der Pipeline.
• Erklärt Ausführungspläne.
• Bietet Operatoren zum Ausführen von ETL-Funktionen (Extrahieren, Transformieren und Laden).

Apache Pig Vs Hive

Sowohl Apache Pig als auch Hive werden zum Erstellen von MapReduce-Jobs verwendet. In einigen Fällen arbeitet Hive mit HDFS auf ähnliche Weise wie Apache Pig. In der folgenden Tabelle haben wir einige wichtige Punkte aufgelistet, die Apache Pig von Hive unterscheiden.

Apache Pig	Bienenstock
Apache Pig verwendet eine Sprache namens Pig Latin. Es wurde ursprünglich bei erstelltYahoo.	Hive verwendet eine Sprache namens HiveQL. Es wurde ursprünglich bei erstelltFacebook.
Pig Latin ist eine Datenflusssprache.	HiveQL ist eine Abfrageverarbeitungssprache.
Schweinelatein ist eine prozedurale Sprache und passt in das Pipeline-Paradigma.	HiveQL ist eine deklarative Sprache.
Apache Pig kann strukturierte, unstrukturierte und halbstrukturierte Daten verarbeiten.	Hive ist hauptsächlich für strukturierte Daten.

Anwendungen von Apache Pig

Apache Pig wird im Allgemeinen von Datenwissenschaftlern zur Ausführung von Aufgaben verwendet, die Ad-hoc-Verarbeitung und schnelles Prototyping umfassen. Apache Pig wird verwendet -

• Um große Datenquellen wie Weblogs zu verarbeiten.
• Datenverarbeitung für Suchplattformen durchführen.
• Zeitempfindliche Datenladevorgänge verarbeiten.

Apache Pig - Geschichte

Im 2006, Apache Pig wurde als Forschungsprojekt bei Yahoo entwickelt, insbesondere um MapReduce-Jobs für jeden Datensatz zu erstellen und auszuführen. Im2007Apache Pig wurde über einen Apache-Inkubator aus offenen Quellen bezogen. Im2008kam die erste Veröffentlichung von Apache Pig heraus. Im2010Apache Pig schloss sein Studium als Apache-Top-Level-Projekt ab.

Die Sprache, in der Daten in Hadoop mit Pig analysiert werden, ist bekannt als Pig Latin. Es handelt sich um eine hochrangige Datenverarbeitungssprache, die eine Vielzahl von Datentypen und Operatoren bereitstellt, um verschiedene Operationen an den Daten auszuführen.

Um eine bestimmte Aufgabe auszuführen, müssen Programmierer mit Pig ein Pig-Skript in der lateinischen Sprache Pig schreiben und sie mit einem der Ausführungsmechanismen (Grunt Shell, UDFs, Embedded) ausführen. Nach der Ausführung durchlaufen diese Skripte eine Reihe von Transformationen, die vom Pig Framework angewendet werden, um die gewünschte Ausgabe zu erzielen.

Intern konvertiert Apache Pig diese Skripte in eine Reihe von MapReduce-Jobs und erleichtert so die Arbeit des Programmierers. Die Architektur von Apache Pig ist unten dargestellt.

Apache Pig-Komponenten

Wie in der Abbildung gezeigt, enthält das Apache Pig-Framework verschiedene Komponenten. Werfen wir einen Blick auf die Hauptkomponenten.

Parser

Anfangs werden die Pig-Skripte vom Parser verwaltet. Es überprüft die Syntax des Skripts, führt Typprüfungen und andere verschiedene Prüfungen durch. Die Ausgabe des Parsers ist eine DAG (gerichteter azyklischer Graph), die die Pig Latin-Anweisungen und logischen Operatoren darstellt.

In der DAG werden die logischen Operatoren des Skripts als Knoten und die Datenflüsse als Kanten dargestellt.

Optimierer

Der logische Plan (DAG) wird an den logischen Optimierer übergeben, der die logischen Optimierungen wie Projektion und Pushdown ausführt.

Compiler

Der Compiler kompiliert den optimierten logischen Plan in eine Reihe von MapReduce-Jobs.

Ausführungsmaschine

Schließlich werden die MapReduce-Jobs in sortierter Reihenfolge an Hadoop gesendet. Schließlich werden diese MapReduce-Jobs auf Hadoop ausgeführt, um die gewünschten Ergebnisse zu erzielen.

Pig Latin Datenmodell

Das Datenmodell von Pig Latin ist vollständig verschachtelt und ermöglicht komplexe nichtatomare Datentypen wie z map und tuple. Unten ist die schematische Darstellung des Datenmodells von Pig Latin angegeben.

Atom

Jeder einzelne Wert in Pig Latin, unabhängig von seinen Daten, wird als bezeichnet Atom. Es wird als Zeichenfolge gespeichert und kann als Zeichenfolge und Nummer verwendet werden. int, long, float, double, chararray und bytearray sind die Atomwerte von Pig. Ein Datenelement oder ein einfacher Atomwert wird als a bezeichnetfield.

Example - "Raja" oder "30"

Tupel

Ein Datensatz, der aus einer geordneten Menge von Feldern besteht, wird als Tupel bezeichnet. Die Felder können von einem beliebigen Typ sein. Ein Tupel ähnelt einer Zeile in einer RDBMS-Tabelle.

Example - (Raja, 30)

Tasche

Eine Tasche ist ein ungeordneter Satz von Tupeln. Mit anderen Worten, eine Sammlung von Tupeln (nicht eindeutig) wird als Tasche bezeichnet. Jedes Tupel kann eine beliebige Anzahl von Feldern haben (flexibles Schema). Eine Tasche wird durch '{}' dargestellt. Es ähnelt einer Tabelle in RDBMS, aber im Gegensatz zu einer Tabelle in RDBMS ist es nicht erforderlich, dass jedes Tupel die gleiche Anzahl von Feldern enthält oder dass die Felder an derselben Position (Spalte) denselben Typ haben.

Example - {(Raja, 30), (Mohammad, 45)}

Eine Tasche kann ein Feld in einer Beziehung sein; in diesem Zusammenhang ist es bekannt alsinner bag.

Example- {Raja, 30, {9848022338, [email protected],} }

Karte

Eine Karte (oder Datenkarte) ist eine Menge von Schlüssel-Wert-Paaren. Daskeymuss vom Typ Chararray sein und sollte einzigartig sein. Dasvaluekönnte von jedem Typ sein. Es wird durch '[]' dargestellt

Example - [Name # Raja, Alter # 30]

Beziehung

Eine Beziehung ist eine Tüte Tupel. Die Beziehungen in Pig Latin sind ungeordnet (es gibt keine Garantie dafür, dass Tupel in einer bestimmten Reihenfolge verarbeitet werden).

In diesem Kapitel wird das Herunterladen, Installieren und Einrichten erläutert Apache Pig in Ihrem System.

Voraussetzungen

Es ist wichtig, dass Sie Hadoop und Java auf Ihrem System installiert haben, bevor Sie sich für Apache Pig entscheiden. Installieren Sie daher vor der Installation von Apache Pig Hadoop und Java, indem Sie die unter folgendem Link angegebenen Schritte ausführen:

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

Laden Sie Apache Pig herunter

Laden Sie zunächst die neueste Version von Apache Pig von der folgenden Website herunter: https://pig.apache.org/

Schritt 1

Öffnen Sie die Homepage der Apache Pig-Website. Unter dem AbschnittNews, klick auf den Link release page wie im folgenden Schnappschuss gezeigt.

Schritt 2

Wenn Sie auf den angegebenen Link klicken, werden Sie zum weitergeleitet Apache Pig ReleasesSeite. Auf dieser Seite unterDownload Abschnitt haben Sie zwei Links, nämlich Pig 0.8 and later und Pig 0.7 and before. Klick auf den LinkPig 0.8 and laterDann werden Sie zu der Seite mit einer Reihe von Spiegeln weitergeleitet.

Schritt 3

Wählen Sie einen dieser Spiegel aus und klicken Sie darauf, wie unten gezeigt.

Schritt 4

Diese Spiegel bringen Sie zum Pig ReleasesSeite. Diese Seite enthält verschiedene Versionen von Apache Pig. Klicken Sie auf die neueste Version.

Schritt 5

In diesen Ordnern befinden sich die Quell- und Binärdateien von Apache Pig in verschiedenen Distributionen. Laden Sie die TAR-Dateien der Quell- und Binärdateien von Apache Pig 0.15 herunter.pig0.15.0-src.tar.gz und pig-0.15.0.tar.gz.

Installieren Sie Apache Pig

Installieren Sie die Apache Pig-Software nach dem Herunterladen in Ihrer Linux-Umgebung, indem Sie die folgenden Schritte ausführen.

Schritt 1

Erstellen Sie ein Verzeichnis mit dem Namen Pig in demselben Verzeichnis, in dem sich die Installationsverzeichnisse von befinden Hadoop, Java,und andere Software wurden installiert. (In unserem Tutorial haben wir das Pig-Verzeichnis im Benutzer Hadoop erstellt.)

$ mkdir Pig

Schritt 2

Extrahieren Sie die heruntergeladenen TAR-Dateien wie unten gezeigt.

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

Schritt 3

Verschieben Sie den Inhalt von pig-0.15.0-src.tar.gz Datei an die Pig Verzeichnis wie zuvor gezeigt zuvor erstellt.

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

Konfigurieren Sie Apache Pig

Nach der Installation von Apache Pig müssen wir es konfigurieren. Zum Konfigurieren müssen wir zwei Dateien bearbeiten -bashrc and pig.properties.

.bashrc-Datei

In dem .bashrc Datei, setzen Sie die folgenden Variablen -

• PIG_HOME Ordner zum Installationsordner von Apache Pig,

• PATH Umgebungsvariable zum Ordner bin und

• PIG_CLASSPATH Umgebungsvariable für den Ordner etc (Konfiguration) Ihrer Hadoop-Installationen (das Verzeichnis, das die Dateien core-site.xml, hdfs-site.xml und mapred-site.xml enthält).

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

pig.properties-Datei

In dem conf Ordner von Pig, wir haben eine Datei mit dem Namen pig.properties. In der Datei pig.properties können Sie verschiedene Parameter wie unten angegeben einstellen.

pig -h properties

Die folgenden Eigenschaften werden unterstützt:

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.

Überprüfen der Installation

Überprüfen Sie die Installation von Apache Pig, indem Sie den Befehl version eingeben. Wenn die Installation erfolgreich ist, erhalten Sie die unten gezeigte Version von Apache Pig.

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

Im vorherigen Kapitel haben wir erklärt, wie Apache Pig installiert wird. In diesem Kapitel werden wir diskutieren, wie Apache Pig ausgeführt wird.

Apache Pig-Ausführungsmodi

Sie können Apache Pig in zwei Modi ausführen, nämlich Local Mode und 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>

Führen Sie die Ladeanweisung aus

Laden Sie nun die Daten aus der Datei student_data.txt in Pig durch Ausführen der folgenden Pig Latin-Anweisung in der Grunt-Shell.

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

Es folgt die Beschreibung der obigen Aussage.

Name der Beziehung	Wir haben die Daten im Schema gespeichert student.
Pfad der Eingabedatei	Wir lesen Daten aus der Datei student_data.txt, Das befindet sich im Verzeichnis / pig_data / von HDFS.
Speicherfunktion	Wir haben das benutzt PigStorage()Funktion. Es lädt und speichert Daten als strukturierte Textdateien. Es wird ein Trennzeichen als Parameter verwendet, mit dem jede Entität eines Tupels getrennt wird. Standardmäßig wird '\ t' als Parameter verwendet.
Schema	Wir haben die Daten mit dem folgenden Schema gespeichert. Säule Ich würde Vorname Familienname, Nachname Telefon Stadt Datentyp int char Array char Array char Array char Array

Note - Die loadDie Anweisung lädt die Daten einfach in die angegebene Beziehung in Pig. Um die Ausführung des zu überprüfenLoad Anweisung müssen Sie die verwenden Diagnostic Operators die in den nächsten Kapiteln besprochen werden.

Im vorherigen Kapitel haben wir gelernt, wie Daten in Apache Pig geladen werden. Sie können die geladenen Daten im Dateisystem mit dem speichernstoreOperator. In diesem Kapitel wird erläutert, wie Sie Daten in Apache Pig mithilfe von speichernStore Operator.

Syntax

Im Folgenden ist die Syntax der Store-Anweisung angegeben.

STORE Relation_name INTO ' required_directory_path ' [USING function];

Beispiel

Angenommen, wir haben eine Datei student_data.txt in HDFS mit folgendem Inhalt.

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.

Und wir haben es in eine Beziehung eingelesen student Verwenden Sie den Operator LOAD wie unten gezeigt.

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

Lassen Sie uns nun die Beziehung im HDFS-Verzeichnis speichern “/pig_Output/” Wie nachfolgend dargestellt.

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

Ausgabe

Nach dem Ausführen der storeAnweisung erhalten Sie die folgende Ausgabe. Es wird ein Verzeichnis mit dem angegebenen Namen erstellt und die Daten werden darin gespeichert.

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!

Überprüfung

Sie können die gespeicherten Daten wie unten gezeigt überprüfen.

Schritt 1

Listen Sie zunächst die Dateien im genannten Verzeichnis auf pig_output Verwendung der ls Befehl wie unten gezeigt.

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

Sie können beobachten, dass nach dem Ausführen von zwei Dateien erstellt wurden store Erklärung.

Schritt 2

Verwenden von cat Befehl, liste den Inhalt der benannten Datei auf part-m-00000 Wie nachfolgend dargestellt.

$ 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

Das loadDie Anweisung lädt die Daten einfach in die angegebene Beziehung in Apache Pig. Um die Ausführung des zu überprüfenLoad Anweisung müssen Sie die verwenden Diagnostic Operators. Pig Latin bietet vier verschiedene Arten von Diagnoseoperatoren:

• Dump-Operator
• Operator beschreiben
• Erklärungsoperator
• Illustrationsoperator

In diesem Kapitel werden wir die Dump-Operatoren von Pig Latin diskutieren.

Dump-Operator

Das DumpMit dem Operator werden die Pig Latin-Anweisungen ausgeführt und die Ergebnisse auf dem Bildschirm angezeigt. Es wird im Allgemeinen zum Debuggen verwendet.

Syntax

Unten ist die Syntax von angegeben Dump Operator.

grunt> Dump Relation_Name

Beispiel

Angenommen, wir haben eine Datei student_data.txt in HDFS mit folgendem Inhalt.

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.

Und wir haben es in eine Beziehung eingelesen student Verwenden Sie den Operator LOAD wie unten gezeigt.

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

Lassen Sie uns nun den Inhalt der Beziehung mit dem drucken Dump operator Wie nachfolgend dargestellt.

grunt> Dump student

Sobald Sie das oben genannte ausführen Pig LatinAnweisung wird ein MapReduce-Job gestartet, um Daten aus HDFS zu lesen. Es wird die folgende Ausgabe erzeugt.

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)

Das describe Der Operator wird verwendet, um das Schema einer Beziehung anzuzeigen.

Syntax

Die Syntax der describe Betreiber ist wie folgt -

grunt> Describe Relation_name

Beispiel

Angenommen, wir haben eine Datei student_data.txt in HDFS mit folgendem Inhalt.

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.

Und wir haben es in eine Beziehung eingelesen student Verwenden Sie den Operator LOAD wie unten gezeigt.

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

Beschreiben wir nun die genannte Beziehung student und überprüfen Sie das Schema wie unten gezeigt.

grunt> describe student;

Ausgabe

Sobald Sie das oben genannte ausführen Pig Latin Anweisung wird die folgende Ausgabe erzeugt.

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

Das explain Der Operator wird verwendet, um die logischen, physischen und MapReduce-Ausführungspläne einer Beziehung anzuzeigen.

Syntax

Unten ist die Syntax von angegeben explain Operator.

grunt> explain Relation_name;

Beispiel

Angenommen, wir haben eine Datei student_data.txt in HDFS mit folgendem Inhalt.

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.

Und wir haben es in eine Beziehung eingelesen student Verwenden Sie den Operator LOAD wie unten gezeigt.

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

Lassen Sie uns nun die Beziehung mit dem Namen student mit dem erklären explain Bediener wie unten gezeigt.

grunt> explain student;

Ausgabe

Es wird die folgende Ausgabe erzeugt.

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

Das illustrate Mit operator können Sie eine Folge von Anweisungen schrittweise ausführen.

Syntax

Unten ist die Syntax von angegeben illustrate Operator.

grunt> illustrate Relation_name;

Beispiel

Angenommen, wir haben eine Datei student_data.txt in HDFS mit folgendem Inhalt.

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.

Und wir haben es in eine Beziehung eingelesen student Verwenden Sie den Operator LOAD wie unten gezeigt.

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

Lassen Sie uns nun die Beziehung mit dem Namen student veranschaulichen, wie unten gezeigt.

grunt> illustrate student;

Ausgabe

Wenn Sie die obige Anweisung ausführen, erhalten Sie die folgende Ausgabe.

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

Das GROUPDer Operator wird verwendet, um die Daten in einer oder mehreren Beziehungen zu gruppieren. Es sammelt die Daten mit demselben Schlüssel.

Syntax

Unten ist die Syntax von angegeben group Operator.

grunt> Group_data = GROUP Relation_name BY age;

Beispiel

Angenommen, wir haben eine Datei mit dem Namen student_details.txt im HDFS-Verzeichnis /pig_data/ Wie nachfolgend dargestellt.

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

Und wir haben diese Datei mit dem Beziehungsnamen in Apache Pig geladen student_details Wie nachfolgend dargestellt.

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

Lassen Sie uns nun die Datensätze / Tupel in der Beziehung nach Alter gruppieren, wie unten gezeigt.

grunt> group_data = GROUP student_details by age;

Überprüfung

Überprüfen Sie die Beziehung group_data Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump group_data;

Ausgabe

Anschließend erhalten Sie eine Ausgabe mit dem Inhalt der genannten Beziehung group_dataWie nachfolgend dargestellt. Hier können Sie beobachten, dass das resultierende Schema zwei Spalten hat -

• Eins ist age, nach dem wir die Beziehung gruppiert haben.

• Der andere ist ein bag, die die Gruppe der Tupel enthält, Schüleraufzeichnungen mit dem jeweiligen Alter.

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

Sie können das Schema der Tabelle sehen, nachdem Sie die Daten mit dem gruppiert haben describe Befehl wie unten gezeigt.

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

Auf die gleiche Weise können Sie die Beispielillustration des Schemas mit dem abrufen illustrate Befehl wie unten gezeigt.

$ Illustrate group_data;

Es wird die folgende Ausgabe erzeugt -

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

Gruppierung nach mehreren Spalten

Gruppieren wir die Beziehung nach Alter und Stadt wie unten gezeigt.

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

Sie können den Inhalt der genannten Beziehung überprüfen group_multiple Verwenden Sie den Dump-Operator wie unten gezeigt.

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

Alle gruppieren

Sie können eine Beziehung nach allen Spalten gruppieren, wie unten gezeigt.

grunt> group_all = GROUP student_details All;

Überprüfen Sie nun den Inhalt der Beziehung group_all Wie nachfolgend dargestellt.

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

Das COGROUPDer Operator arbeitet mehr oder weniger auf die gleiche Weise wie der GROUP- Operator. Der einzige Unterschied zwischen den beiden Operatoren besteht darin, dass diegroup Der Operator wird normalerweise mit einer Beziehung verwendet, während der Operator verwendet wird cogroup Der Operator wird in Anweisungen verwendet, die zwei oder mehr Beziehungen betreffen.

Gruppieren von zwei Beziehungen mit Cogroup

Angenommen, wir haben nämlich zwei Dateien student_details.txt und employee_details.txt im HDFS-Verzeichnis /pig_data/ Wie nachfolgend dargestellt.

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

Und wir haben diese Dateien mit den Beziehungsnamen in Pig geladen student_details und employee_details jeweils wie unten gezeigt.

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

Lassen Sie uns nun die Datensätze / Tupel der Beziehungen gruppieren student_details und employee_details mit dem Schlüsselalter, wie unten gezeigt.

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

Überprüfung

Überprüfen Sie die Beziehung cogroup_data Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump cogroup_data;

Ausgabe

Es wird die folgende Ausgabe erzeugt, in der der Inhalt der genannten Beziehung angezeigt wird cogroup_data Wie nachfolgend dargestellt.

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

Das cogroup Der Operator gruppiert die Tupel aus jeder Beziehung nach Alter, wobei jede Gruppe einen bestimmten Alterswert darstellt.

Wenn wir zum Beispiel das erste Tupel des Ergebnisses betrachten, wird es nach Alter 21 gruppiert. Und es enthält zwei Beutel -

• Die erste Tasche enthält alle Tupel aus der ersten Beziehung (student_details in diesem Fall) mit 21 Jahren und

• Der zweite Beutel enthält alle Tupel aus der zweiten Beziehung (employee_details in diesem Fall) mit 21 Jahren.

Falls eine Beziehung keine Tupel mit dem Alterswert 21 enthält, wird ein leerer Beutel zurückgegeben.

Das JOINDer Operator wird verwendet, um Datensätze aus zwei oder mehr Beziehungen zu kombinieren. Während der Ausführung einer Verknüpfungsoperation deklarieren wir ein (oder eine Gruppe von) Tupel (n) aus jeder Beziehung als Schlüssel. Wenn diese Schlüssel übereinstimmen, werden die beiden bestimmten Tupel abgeglichen, andernfalls werden die Datensätze gelöscht. Es gibt folgende Arten von Verknüpfungen:

• Self-join
• Inner-join
• Outer-Join - Links-Join, Rechts-Join und Voll-Join

In diesem Kapitel wird anhand von Beispielen erläutert, wie der Join-Operator in Pig Latin verwendet wird. Angenommen, wir haben nämlich zwei Dateiencustomers.txt und orders.txt in dem /pig_data/ Verzeichnis von HDFS wie unten gezeigt.

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

Und wir haben diese beiden Dateien mit den Beziehungen in Pig geladen customers und orders Wie nachfolgend dargestellt.

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

Lassen Sie uns nun verschiedene Join-Operationen für diese beiden Beziehungen ausführen.

Selbst beitreten

Self-join wird verwendet, um eine Tabelle mit sich selbst zu verbinden, als ob die Tabelle zwei Relationen wäre, wobei vorübergehend mindestens eine Relation umbenannt wird.

Im Allgemeinen laden wir in Apache Pig dieselben Daten mehrmals unter verschiedenen Aliasnamen (Namen), um eine Selbstverbindung durchzuführen. Laden wir deshalb den Inhalt der Dateicustomers.txt als zwei Tabellen wie unten gezeigt.

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

Nachstehend ist die Syntax der Ausführung angegeben self-join Betrieb mit dem JOIN Operator.

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

Beispiel

Lassen Sie uns durchführen self-join Operation auf die Beziehung customersdurch die Verbindung der beiden Beziehungen customers1 und customers2 Wie nachfolgend dargestellt.

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

Überprüfung

Überprüfen Sie die Beziehung customers3 Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump customers3;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt 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 Joinwird ziemlich häufig verwendet; es wird auch als bezeichnetequijoin. Ein innerer Join gibt Zeilen zurück, wenn in beiden Tabellen eine Übereinstimmung vorliegt.

Es erstellt eine neue Beziehung, indem Spaltenwerte von zwei Beziehungen (z. B. A und B) basierend auf dem Join-Prädikat kombiniert werden. Die Abfrage vergleicht jede Zeile von A mit jeder Zeile von B, um alle Zeilenpaare zu finden, die das Join-Prädikat erfüllen. Wenn das Join-Prädikat erfüllt ist, werden die Spaltenwerte für jedes übereinstimmende Zeilenpaar von A und B zu einer Ergebniszeile kombiniert.

Syntax

Hier ist die Syntax der Aufführung inner join Betrieb mit dem JOIN Operator.

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

Beispiel

Lassen Sie uns durchführen inner join Operation auf den beiden Beziehungen customers und orders Wie nachfolgend dargestellt.

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

Überprüfung

Überprüfen Sie die Beziehung coustomer_orders Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump coustomer_orders;

Ausgabe

Sie erhalten die folgende Ausgabe, die den Inhalt der genannten Beziehung enthält 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 - -

Äußere Verbindung : Im Gegensatz zur inneren Verbindung,outer joinGibt alle Zeilen aus mindestens einer der Relationen zurück. Eine äußere Verknüpfungsoperation wird auf drei Arten ausgeführt:

• Linke äußere Verbindung
• Rechte äußere Verbindung
• Vollständige äußere Verbindung

Linke äußere Verbindung

Das left outer Join Die Operation gibt alle Zeilen aus der linken Tabelle zurück, auch wenn die rechte Beziehung keine Übereinstimmungen enthält.

Syntax

Nachstehend ist die Syntax der Ausführung angegeben left outer join Betrieb mit dem JOIN Operator.

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

Beispiel

Lassen Sie uns für die beiden Kunden und Bestellungen der linken Beziehung eine Operation für die linke äußere Verknüpfung ausführen, wie unten gezeigt.

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

Überprüfung

Überprüfen Sie die Beziehung outer_left Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump outer_left;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt 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

Das right outer join Die Operation gibt alle Zeilen aus der rechten Tabelle zurück, auch wenn die linke Tabelle keine Übereinstimmungen enthält.

Syntax

Nachstehend ist die Syntax der Ausführung angegeben right outer join Betrieb mit dem JOIN Operator.

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

Beispiel

Lassen Sie uns durchführen right outer join Operation auf den beiden Beziehungen customers und orders Wie nachfolgend dargestellt.

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

Überprüfung

Überprüfen Sie die Beziehung outer_right Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump outer_right

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt 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)

Volle äußere Verbindung

Das full outer join Die Operation gibt Zeilen zurück, wenn in einer der Beziehungen eine Übereinstimmung vorliegt.

Syntax

Nachstehend ist die Syntax der Ausführung angegeben full outer join Verwendung der JOIN Operator.

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

Beispiel

Lassen Sie uns durchführen full outer join Operation auf den beiden Beziehungen customers und orders Wie nachfolgend dargestellt.

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

Überprüfung

Überprüfen Sie die Beziehung outer_full Verwendung der DUMP Bediener wie unten gezeigt.

grun> Dump outer_full;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt 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,,,,)

Verwenden mehrerer Schlüssel

Wir können die JOIN-Operation mit mehreren Schlüsseln ausführen.

Syntax

So können Sie eine JOIN-Operation für zwei Tabellen mit mehreren Schlüsseln ausführen.

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

Angenommen, wir haben nämlich zwei Dateien employee.txt und employee_contact.txt in dem /pig_data/ Verzeichnis von HDFS wie unten gezeigt.

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

Und wir haben diese beiden Dateien mit Beziehungen in Pig geladen employee und employee_contact Wie nachfolgend dargestellt.

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

Lassen Sie uns nun den Inhalt dieser beiden Beziehungen mit dem verbinden JOIN Bediener wie unten gezeigt.

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

Überprüfung

Überprüfen Sie die Beziehung emp Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump emp;

Ausgabe

Es wird die folgende Ausgabe erzeugt, in der der Inhalt der genannten Beziehung angezeigt wird emp Wie nachfolgend dargestellt.

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

Das CROSSDer Operator berechnet das Kreuzprodukt aus zwei oder mehr Beziehungen. In diesem Kapitel wird anhand eines Beispiels erläutert, wie der Kreuzoperator in Pig Latin verwendet wird.

Syntax

Unten ist die Syntax von angegeben CROSS Operator.

grunt> Relation3_name = CROSS Relation1_name, Relation2_name;

Beispiel

Angenommen, wir haben nämlich zwei Dateien customers.txt und orders.txt in dem /pig_data/ Verzeichnis von HDFS wie unten gezeigt.

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

Und wir haben diese beiden Dateien mit den Beziehungen in Pig geladen customers und orders Wie nachfolgend dargestellt.

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

Lassen Sie uns nun das Kreuzprodukt dieser beiden Beziehungen mit dem cross Operator für diese beiden Beziehungen wie unten gezeigt.

grunt> cross_data = CROSS customers, orders;

Überprüfung

Überprüfen Sie die Beziehung cross_data Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump cross_data;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt 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)

Das UNIONDer Operator von Pig Latin wird verwendet, um den Inhalt zweier Beziehungen zusammenzuführen. Um eine UNION-Operation für zwei Beziehungen auszuführen, müssen deren Spalten und Domänen identisch sein.

Syntax

Unten ist die Syntax von angegeben UNION Operator.

grunt> Relation_name3 = UNION Relation_name1, Relation_name2;

Beispiel

Angenommen, wir haben nämlich zwei Dateien student_data1.txt und student_data2.txt in dem /pig_data/ Verzeichnis von HDFS wie unten gezeigt.

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.

Und wir haben diese beiden Dateien mit den Beziehungen in Pig geladen student1 und student2 Wie nachfolgend dargestellt.

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

Lassen Sie uns nun den Inhalt dieser beiden Beziehungen mit dem zusammenführen UNION Bediener wie unten gezeigt.

grunt> student = UNION student1, student2;

Überprüfung

Überprüfen Sie die Beziehung student Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump student;

Ausgabe

Es wird die folgende Ausgabe angezeigt, die den Inhalt der Beziehung anzeigt 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)

Das SPLIT Der Operator wird verwendet, um eine Beziehung in zwei oder mehr Beziehungen aufzuteilen.

Syntax

Unten ist die Syntax von angegeben SPLIT Operator.

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

Beispiel

Angenommen, wir haben eine Datei mit dem Namen student_details.txt im HDFS-Verzeichnis /pig_data/ Wie nachfolgend dargestellt.

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

Und wir haben diese Datei mit dem Beziehungsnamen in Pig geladen student_details Wie nachfolgend dargestellt.

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

Lassen Sie uns nun die Beziehung in zwei Teile aufteilen, wobei einer die Mitarbeiter unter 23 Jahren und der andere die Mitarbeiter zwischen 22 und 25 Jahren auflistet.

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

Überprüfung

Überprüfen Sie die Beziehungen student_details1 und student_details2 Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump student_details1;  

grunt> Dump student_details2;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehungen anzeigt student_details1 und student_details2 beziehungsweise.

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)

Das FILTER Der Operator wird verwendet, um die erforderlichen Tupel aus einer Beziehung basierend auf einer Bedingung auszuwählen.

Syntax

Unten ist die Syntax von angegeben FILTER Operator.

grunt> Relation2_name = FILTER Relation1_name BY (condition);

Beispiel

Angenommen, wir haben eine Datei mit dem Namen student_details.txt im HDFS-Verzeichnis /pig_data/ Wie nachfolgend dargestellt.

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

Und wir haben diese Datei mit dem Beziehungsnamen in Pig geladen student_details Wie nachfolgend dargestellt.

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

Verwenden wir jetzt den Filteroperator, um die Details der Schüler abzurufen, die zur Stadt Chennai gehören.

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

Überprüfung

Überprüfen Sie die Beziehung filter_data Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump filter_data;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt filter_data wie folgt.

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

Das DISTINCT Der Operator wird verwendet, um redundante (doppelte) Tupel aus einer Beziehung zu entfernen.

Syntax

Unten ist die Syntax von angegeben DISTINCT Operator.

grunt> Relation_name2 = DISTINCT Relatin_name1;

Beispiel

Angenommen, wir haben eine Datei mit dem Namen student_details.txt im HDFS-Verzeichnis /pig_data/ Wie nachfolgend dargestellt.

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

Und wir haben diese Datei mit dem Beziehungsnamen in Pig geladen student_details Wie nachfolgend dargestellt.

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

Entfernen wir nun die redundanten (doppelten) Tupel aus der genannten Beziehung student_details Verwendung der DISTINCT Operator und speichern Sie es als eine andere Beziehung mit dem Namen distinct_data Wie nachfolgend dargestellt.

grunt> distinct_data = DISTINCT student_details;

Überprüfung

Überprüfen Sie die Beziehung distinct_data Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump distinct_data;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt distinct_data wie folgt.

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

Das FOREACH Der Operator wird verwendet, um bestimmte Datentransformationen basierend auf den Spaltendaten zu generieren.

Syntax

Unten ist die Syntax von angegeben FOREACH Operator.

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

Beispiel

Angenommen, wir haben eine Datei mit dem Namen student_details.txt im HDFS-Verzeichnis /pig_data/ Wie nachfolgend dargestellt.

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

Und wir haben diese Datei mit dem Beziehungsnamen in Pig geladen student_details Wie nachfolgend dargestellt.

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

Lassen Sie uns nun die ID, das Alter und die Stadtwerte jedes Schülers aus der Beziehung ermitteln student_details und speichern Sie es in einer anderen Beziehung namens foreach_data Verwendung der foreach Bediener wie unten gezeigt.

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

Überprüfung

Überprüfen Sie die Beziehung foreach_data Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump foreach_data;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt 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)

Das ORDER BY Der Operator wird verwendet, um den Inhalt einer Beziehung in einer sortierten Reihenfolge basierend auf einem oder mehreren Feldern anzuzeigen.

Syntax

Unten ist die Syntax von angegeben ORDER BY Operator.

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

Beispiel

Angenommen, wir haben eine Datei mit dem Namen student_details.txt im HDFS-Verzeichnis /pig_data/ Wie nachfolgend dargestellt.

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

Und wir haben diese Datei mit dem Beziehungsnamen in Pig geladen student_details Wie nachfolgend dargestellt.

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

Sortieren wir nun die Beziehung in absteigender Reihenfolge nach dem Alter des Schülers und speichern sie in einer anderen Beziehung mit dem Namen order_by_data Verwendung der ORDER BY Bediener wie unten gezeigt.

grunt> order_by_data = ORDER student_details BY age DESC;

Überprüfung

Überprüfen Sie die Beziehung order_by_data Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump order_by_data;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt 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)

Das LIMIT Der Operator wird verwendet, um eine begrenzte Anzahl von Tupeln aus einer Beziehung abzurufen.

Syntax

Unten ist die Syntax von angegeben LIMIT Operator.

grunt> Result = LIMIT Relation_name required number of tuples;

Beispiel

Angenommen, wir haben eine Datei mit dem Namen student_details.txt im HDFS-Verzeichnis /pig_data/ Wie nachfolgend dargestellt.

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

Und wir haben diese Datei mit dem Beziehungsnamen in Pig geladen student_details Wie nachfolgend dargestellt.

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

Sortieren wir nun die Beziehung in absteigender Reihenfolge nach dem Alter des Schülers und speichern sie in einer anderen Beziehung mit dem Namen limit_data Verwendung der ORDER BY Bediener wie unten gezeigt.

grunt> limit_data = LIMIT student_details 4;

Überprüfung

Überprüfen Sie die Beziehung limit_data Verwendung der DUMP Bediener wie unten gezeigt.

grunt> Dump limit_data;

Ausgabe

Es wird die folgende Ausgabe erzeugt, die den Inhalt der Beziehung anzeigt limit_data wie folgt.

(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 bietet nämlich verschiedene integrierte Funktionen eval, load, store, math, string, bag und tuple Funktionen.

Eval-Funktionen

Unten ist die Liste von eval Funktionen von Apache Pig.

SN	Bedienungsanleitung
1	AVG () Berechnung des Durchschnitts der numerischen Werte in einem Beutel.
2	BagToString () Verketten der Elemente einer Tasche zu einer Zeichenfolge. Während der Verkettung können wir ein Trennzeichen zwischen diese Werte setzen (optional).
3	CONCAT () Verketten von zwei oder mehr Ausdrücken desselben Typs.
4	ANZAHL() Um die Anzahl der Elemente in einer Tasche zu ermitteln, während die Anzahl der Tupel in einer Tasche gezählt wird.
5	COUNT_STAR () Es ist ähnlich wie beim COUNT()Funktion. Es wird verwendet, um die Anzahl der Elemente in einer Tasche zu ermitteln.
6	DIFF () Zwei Taschen (Felder) in einem Tupel vergleichen.
7	Ist leer() Um zu überprüfen, ob eine Tasche oder Karte leer ist.
8	MAX () So berechnen Sie den höchsten Wert für eine Spalte (numerische Werte oder Chararrays) in einem einspaltigen Beutel.
9	MINDEST() Um den minimalen (niedrigsten) Wert (numerisch oder chararray) für eine bestimmte Spalte in einem einspaltigen Beutel zu erhalten.
10	PluckTuple () Mit dem Pig Latin PluckTuple() Funktion können wir ein String-Präfix definieren und die Spalten in einer Beziehung filtern, die mit dem angegebenen Präfix beginnt.
11	GRÖSSE() Berechnung der Anzahl der Elemente basierend auf einem beliebigen Pig-Datentyp.
12	SUBTRAHIEREN() Zwei Beutel abziehen. Es werden zwei Beutel als Eingabe verwendet und ein Beutel zurückgegeben, der die Tupel des ersten Beutels enthält, die sich nicht im zweiten Beutel befinden.
13	SUMME() Um die Summe der numerischen Werte einer Spalte in einem einspaltigen Beutel abzurufen.
14	TOKENISIEREN () So teilen Sie eine Zeichenfolge (die eine Gruppe von Wörtern enthält) in ein einzelnes Tupel und geben einen Beutel zurück, der die Ausgabe der Teilungsoperation enthält.

Das Load und StoreFunktionen in Apache Pig werden verwendet, um zu bestimmen, wie die Daten von Pig stammen. Diese Funktionen werden mit den Lade- und Speicheroperatoren verwendet. Im Folgenden finden Sie eine Liste der in Pig verfügbaren Lade- und Speicherfunktionen.

SN	Bedienungsanleitung
1	PigStorage () Strukturierte Dateien laden und speichern.
2	TextLoader () So laden Sie unstrukturierte Daten in Pig.
3	BinStorage () Laden und Speichern von Daten in Pig im maschinenlesbaren Format.
4	Umgang mit Komprimierung In Pig Latin können wir komprimierte Daten laden und speichern.

Im Folgenden finden Sie eine Liste der Bag- und Tuple-Funktionen.

SN	Bedienungsanleitung
1	EINTÜTEN() Um zwei oder mehr Ausdrücke in eine Tasche umzuwandeln.
2	OBEN() Um die Spitze zu bekommen N Tupel einer Beziehung.
3	TOTUPLE () Um einen oder mehrere Ausdrücke in ein Tupel umzuwandeln.
4	TOMAP () Konvertieren der Schlüssel-Wert-Paare in eine Karte.

Wir haben die folgenden String-Funktionen in Apache Pig.

SN	Funktionen & Beschreibung
1	ENDSWITH (string, testAgainst) Um zu überprüfen, ob eine bestimmte Zeichenfolge mit einer bestimmten Teilzeichenfolge endet.
2	STARTSWITH (String, Teilzeichenfolge) Akzeptiert zwei Zeichenfolgenparameter und überprüft, ob die erste Zeichenfolge mit der zweiten beginnt.
3	SUBSTRING (Zeichenfolge, startIndex, stopIndex) Gibt eine Teilzeichenfolge aus einer bestimmten Zeichenfolge zurück.
4	EqualsIgnoreCase (string1, string2) Um zwei Stiche zu vergleichen, die den Fall ignorieren.
5	INDEXOF (Zeichenfolge, 'Zeichen', startIndex) Gibt das erste Vorkommen eines Zeichens in einer Zeichenfolge zurück und sucht von einem Startindex aus nach vorne.
6	LAST_INDEX_OF (Ausdruck) Gibt den Index des letzten Vorkommens eines Zeichens in einer Zeichenfolge zurück und sucht von einem Startindex aus rückwärts.
7	LCFIRST (Ausdruck) Konvertiert das erste Zeichen in einer Zeichenfolge in Kleinbuchstaben.
8	UCFIRST (Ausdruck) Gibt eine Zeichenfolge zurück, bei der das erste Zeichen in Großbuchstaben umgewandelt wird.
9	OBER (Ausdruck) UPPER (Ausdruck) Gibt eine Zeichenfolge zurück, die in Großbuchstaben konvertiert wurde.
10	UNTER (Ausdruck) Konvertiert alle Zeichen in einer Zeichenfolge in Kleinbuchstaben.
11	REPLACE (Zeichenfolge, 'oldChar', 'newChar'); Ersetzen vorhandener Zeichen in einer Zeichenfolge durch neue Zeichen.
12	STRSPLIT (String, Regex, Limit) So teilen Sie eine Zeichenfolge um Übereinstimmungen eines bestimmten regulären Ausdrucks.
13	STRSPLITTOBAG (String, Regex, Limit) Ähnlich wie STRSPLIT() Funktion teilt es die Zeichenfolge durch ein gegebenes Trennzeichen und gibt das Ergebnis in einer Tasche zurück.
14	TRIM (Ausdruck) Gibt eine Kopie einer Zeichenfolge zurück, bei der führende und nachfolgende Leerzeichen entfernt wurden.
15	LTRIM (Ausdruck) Gibt eine Kopie einer Zeichenfolge zurück, bei der führende Leerzeichen entfernt wurden.
16	RTRIM (Ausdruck) Gibt eine Kopie einer Zeichenfolge zurück, bei der nachgestellte Leerzeichen entfernt wurden.

Apache Pig bietet die folgenden Datums- und Uhrzeitfunktionen:

SN	Funktionen & Beschreibung
1	ToDate (Millisekunden) Diese Funktion gibt ein Datums- / Uhrzeitobjekt gemäß den angegebenen Parametern zurück. Die andere Alternative für diese Funktion sind ToDate (iosstring), ToDate (userstring, format), ToDate (userstring, format, timezone).
2	Aktuelle Uhrzeit() Gibt das Datums- / Uhrzeitobjekt der aktuellen Uhrzeit zurück.
3	GetDay (Datum / Uhrzeit) Gibt den Tag eines Monats vom Datums- / Uhrzeitobjekt zurück.
4	GetHour (Datum / Uhrzeit) Gibt die Stunde eines Tages vom Datums- / Uhrzeitobjekt zurück.
5	GetMilliSecond (Datum / Uhrzeit) Gibt die Millisekunde einer Sekunde vom Datums- / Uhrzeitobjekt zurück.
6	GetMinute (Datum / Uhrzeit) Gibt die Minute einer Stunde vom Datums- / Uhrzeitobjekt zurück.
7	GetMonth (Datum / Uhrzeit) Gibt den Monat eines Jahres vom Datums- / Uhrzeitobjekt zurück.
8	GetSecond (Datum / Uhrzeit) Gibt die Sekunde einer Minute vom Datums- / Uhrzeitobjekt zurück.
9	GetWeek (Datum / Uhrzeit) Gibt die Woche eines Jahres vom Datums- / Uhrzeitobjekt zurück.
10	GetWeekYear (Datum / Uhrzeit) Gibt das Wochenjahr vom Datums- / Uhrzeitobjekt zurück.
11	GetYear (Datum / Uhrzeit) Gibt das Jahr vom Datums- / Uhrzeitobjekt zurück.
12	AddDuration (Datum / Uhrzeit, Dauer) Gibt das Ergebnis eines Datums- / Uhrzeitobjekts zusammen mit dem Dauerobjekt zurück.
13	SubtractDuration (Datum / Uhrzeit, Dauer) Subtrahiert das Duration-Objekt vom Date-Time-Objekt und gibt das Ergebnis zurück.
14	DaysBetween (datetime1, datetime2) Gibt die Anzahl der Tage zwischen den beiden Datums- / Uhrzeitobjekten zurück.
15	HoursBetween (datetime1, datetime2) Gibt die Anzahl der Stunden zwischen zwei Datums- / Uhrzeitobjekten zurück.
16	MilliSecondsBetween (datetime1, datetime2) Gibt die Anzahl der Millisekunden zwischen zwei Datums- / Uhrzeitobjekten zurück.
17	MinutesBetween (datetime1, datetime2) Gibt die Anzahl der Minuten zwischen zwei Datums- / Uhrzeitobjekten zurück.
18	Monate zwischen (datetime1, datetime2) Gibt die Anzahl der Monate zwischen zwei Datums- / Uhrzeitobjekten zurück.
19	SecondsBetween (datetime1, datetime2) Gibt die Anzahl der Sekunden zwischen zwei Datums- / Uhrzeitobjekten zurück.
20	WeeksBetween (datetime1, datetime2) Gibt die Anzahl der Wochen zwischen zwei Datums- / Uhrzeitobjekten zurück.
21	YearsBetween (datetime1, datetime2) Gibt die Anzahl der Jahre zwischen zwei Datums- / Uhrzeitobjekten zurück.

Wir haben die folgenden mathematischen Funktionen in Apache Pig -

SN	Funktionen & Beschreibung
1	ABS (Ausdruck) Um den absoluten Wert eines Ausdrucks zu erhalten.
2	ACOS (Ausdruck) Um den Bogenkosinus eines Ausdrucks zu erhalten.
3	ASIN (Ausdruck) Um den Bogensinus eines Ausdrucks zu erhalten.
4	ATAN (Ausdruck) Diese Funktion wird verwendet, um den Arcustangens eines Ausdrucks zu erhalten.
5	CBRT (Ausdruck) Diese Funktion wird verwendet, um die Kubikwurzel eines Ausdrucks abzurufen.
6	CEIL (Ausdruck) Diese Funktion wird verwendet, um den Wert eines Ausdrucks auf die nächste Ganzzahl aufgerundet zu erhalten.
7	COS (Ausdruck) Diese Funktion wird verwendet, um den trigonometrischen Kosinus eines Ausdrucks zu erhalten.
8	COSH (Ausdruck) Diese Funktion wird verwendet, um den hyperbolischen Cosinus eines Ausdrucks zu erhalten.
9	EXP (Ausdruck) Diese Funktion wird verwendet, um die Euler-Zahl e auf die Potenz von x zu bringen.
10	BODEN (Ausdruck) Um den Wert eines Ausdrucks auf die nächste Ganzzahl abgerundet zu erhalten.
11	LOG (Ausdruck) Um den natürlichen Logarithmus (Basis e) eines Ausdrucks zu erhalten.
12	LOG10 (Ausdruck) Um den Logarithmus zur Basis 10 eines Ausdrucks zu erhalten.
13	ZUFÄLLIG( ) Um eine Pseudozufallszahl (geben Sie double ein) größer oder gleich 0.0 und kleiner als 1.0 zu erhalten.
14	RUND (Ausdruck) Um den Wert eines Ausdrucks zu erhalten, der auf eine Ganzzahl gerundet ist (wenn der Ergebnistyp float ist) oder auf eine lange gerundet ist (wenn der Ergebnistyp doppelt ist).
15	SÜNDE (Ausdruck) Den Sinus eines Ausdrucks erhalten.
16	SINH (Ausdruck) Um den hyperbolischen Sinus eines Ausdrucks zu erhalten.
17	SQRT (Ausdruck) Um die positive Quadratwurzel eines Ausdrucks zu erhalten.
18	TAN (Ausdruck) Um die trigonometrische Tangente eines Winkels zu erhalten.
19	TANH (Ausdruck) Um den hyperbolischen Tangens eines Ausdrucks zu erhalten.

Zusätzlich zu den integrierten Funktionen bietet Apache Pig umfassende Unterstützung für User Ddefiniert FGewerkschaften (UDFs). Mit diesen UDFs können wir unsere eigenen Funktionen definieren und verwenden. Die UDF-Unterstützung wird in sechs Programmiersprachen bereitgestellt, nämlich Java, Jython, Python, JavaScript, Ruby und Groovy.

Für das Schreiben von UDFs wird in Java vollständige Unterstützung bereitgestellt, und in allen verbleibenden Sprachen wird eine eingeschränkte Unterstützung bereitgestellt. Mit Java können Sie UDFs schreiben, die alle Teile der Verarbeitung betreffen, z. B. Laden / Speichern von Daten, Spaltentransformation und Aggregation. Da Apache Pig in Java geschrieben wurde, arbeiten die mit Java geschriebenen UDFs im Vergleich zu anderen Sprachen effizient.

In Apache Pig haben wir auch ein Java-Repository für UDFs mit dem Namen Piggybank. Mit Piggybank können wir auf Java-UDFs zugreifen, die von anderen Benutzern geschrieben wurden, und unsere eigenen UDFs einbringen.

Arten von UDFs in Java

Beim Schreiben von UDFs mit Java können wir die folgenden drei Arten von Funktionen erstellen und verwenden:

• Filter Functions- Die Filterfunktionen werden als Bedingungen in Filteranweisungen verwendet. Diese Funktionen akzeptieren einen Pig-Wert als Eingabe und geben einen Booleschen Wert zurück.

• Eval Functions- Die Eval-Funktionen werden in FOREACH-GENERATE-Anweisungen verwendet. Diese Funktionen akzeptieren einen Pig-Wert als Eingabe und geben ein Pig-Ergebnis zurück.

• Algebraic Functions- Die algebraischen Funktionen wirken in einer FOREACHGENERATE-Anweisung auf Innentaschen. Diese Funktionen werden verwendet, um vollständige MapReduce-Vorgänge für eine innere Tasche auszuführen.

Schreiben von UDFs mit Java

Um eine UDF mit Java zu schreiben, müssen wir die JAR-Datei integrieren Pig-0.15.0.jar. In diesem Abschnitt wird erläutert, wie Sie eine Beispiel-UDF mit Eclipse schreiben. Bevor Sie fortfahren, stellen Sie sicher, dass Sie Eclipse und Maven in Ihrem System installiert haben.

Führen Sie die folgenden Schritte aus, um eine UDF-Funktion zu schreiben.

• Öffnen Sie Eclipse und erstellen Sie ein neues Projekt (z myproject).

• Konvertieren Sie das neu erstellte Projekt in ein Maven-Projekt.

• Kopieren Sie den folgenden Inhalt in die Datei pom.xml. Diese Datei enthält die Maven-Abhängigkeiten für Apache Pig- und Hadoop-Core-JAR-Dateien.

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

• Speichern Sie die Datei und aktualisieren Sie sie. In demMaven Dependencies Im Abschnitt finden Sie die heruntergeladenen JAR-Dateien.

• Erstellen Sie eine neue Klassendatei mit Namen Sample_Eval und kopieren Sie den folgenden Inhalt hinein.

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

Beim Schreiben von UDFs muss die EvalFunc-Klasse geerbt und die Implementierung bereitgestellt werden exec()Funktion. Innerhalb dieser Funktion wird der für die UDF erforderliche Code geschrieben. Im obigen Beispiel haben wir den Code zurückgegeben, um den Inhalt der angegebenen Spalte in Großbuchstaben umzuwandeln.

• Klicken Sie nach dem fehlerfreien Kompilieren der Klasse mit der rechten Maustaste auf die Datei Sample_Eval.java. Es gibt Ihnen ein Menü. Wählenexport wie im folgenden Screenshot gezeigt.

• Beim Klicken exporterhalten Sie das folgende Fenster. Klicke aufJAR file.

• Fahren Sie fort, indem Sie auf klicken Next>Taste. Sie erhalten ein weiteres Fenster, in dem Sie den Pfad im lokalen Dateisystem eingeben müssen, in dem Sie die JAR-Datei speichern müssen.

• Klicken Sie abschließend auf FinishTaste. Im angegebenen Ordner eine Jar-Dateisample_udf.jargeschaffen. Diese JAR-Datei enthält die in Java geschriebene UDF.

Verwenden der UDF

Führen Sie nach dem Schreiben der UDF und dem Generieren der Jar-Datei die folgenden Schritte aus:

Schritt 1: Registrieren der Jar-Datei

Nach dem Schreiben von UDF (in Java) müssen wir die Jar-Datei, die die UDF enthält, mit dem Register-Operator registrieren. Durch Registrieren der Jar-Datei können Benutzer Apache Pig den Speicherort der UDF mitteilen.

Syntax

Nachstehend ist die Syntax des Registeroperators angegeben.

REGISTER path;

Example

Als Beispiel registrieren wir das Beispiel_udf.jar, das weiter oben in diesem Kapitel erstellt wurde.

Starten Sie Apache Pig im lokalen Modus und registrieren Sie die JAR-Datei sample_udf.jar wie unten gezeigt.

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

REGISTER '/$PIG_HOME/sample_udf.jar'

Note - Nehmen Sie die Jar-Datei im Pfad - /$PIG_HOME/sample_udf.jar an

Schritt 2: Alias ​​definieren

Nach der Registrierung der UDF können wir mit der einen Alias ​​definieren Define Operator.

Syntax

Nachstehend ist die Syntax des Operators "Definieren" angegeben.

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

Example

Definieren Sie den Alias ​​für sample_eval wie unten gezeigt.

DEFINE sample_eval sample_eval();

Schritt 3: Verwenden der UDF

Nach dem Definieren des Alias ​​können Sie die UDF genauso verwenden wie die integrierten Funktionen. Angenommen, das HDFS enthält eine Datei mit dem Namen emp_data/Pig_Data/ Verzeichnis mit folgendem Inhalt.

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

Angenommen, wir haben diese Datei wie unten gezeigt in Pig geladen.

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

Lassen Sie uns nun die Namen der Mitarbeiter mit der UDF in Großbuchstaben umwandeln sample_eval.

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

Überprüfen Sie den Inhalt der Beziehung Upper_case Wie nachfolgend dargestellt.

grunt> Dump Upper_case;
  
(ROBIN)
(BOB)
(MAYA)
(SARA)
(DAVID)
(MAGGY)
(ROBERT)
(SYAM)
(MARY)
(SARAN)
(STACY)
(KELLY)

Hier in diesem Kapitel erfahren Sie, wie Sie Apache Pig-Skripte im Batch-Modus ausführen.

Kommentare in Pig Script

Während Sie ein Skript in eine Datei schreiben, können Sie wie unten gezeigt Kommentare hinzufügen.

Mehrzeilige Kommentare

Wir beginnen die mehrzeiligen Kommentare mit '/ *' und beenden sie mit '* /'.

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

Einzeilige Kommentare

Wir beginnen die einzeiligen Kommentare mit '-'.

--we can write single line comments like this.

Ausführen von Pig Script im Batch-Modus

Führen Sie die folgenden Schritte aus, während Sie Apache Pig-Anweisungen im Batch-Modus ausführen.

Schritt 1

Schreiben Sie alle erforderlichen Pig Latin-Anweisungen in eine einzige Datei. Wir können alle Pig Latin-Anweisungen und -Befehle in eine einzige Datei schreiben und unter speichern.pig Datei.

Schritt 2

Führen Sie das Apache Pig-Skript aus. Sie können das Pig-Skript wie unten gezeigt über die Shell (Linux) ausführen.

Lokalbetrieb	MapReduce-Modus
$ pig -x lokal Sample_script.pig	$ pig -x mapreduce Sample_script.pig

Sie können es auch über die Grunt-Shell ausführen, indem Sie den Befehl exec wie unten gezeigt verwenden.

grunt> exec /sample_script.pig

Ausführen eines Pig-Skripts aus HDFS

Wir können auch ein Pig-Skript ausführen, das sich im HDFS befindet. Angenommen, es gibt ein Pig-Skript mit dem NamenSample_script.pig im HDFS-Verzeichnis mit dem Namen /pig_data/. Wir können es wie unten gezeigt ausführen.

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

Beispiel

Angenommen, wir haben eine Datei student_details.txt in HDFS mit folgendem Inhalt.

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

Wir haben auch ein Beispielskript mit dem Namen sample_script.pigim selben HDFS-Verzeichnis. Diese Datei enthält Anweisungen, die Operationen und Transformationen auf dem ausführenstudent Beziehung, wie unten gezeigt.

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;

• Die erste Anweisung des Skripts lädt die Daten in die genannte Datei student_details.txt als eine Beziehung benannt student.

• Die zweite Anweisung des Skripts ordnet die Tupel der Beziehung in absteigender Reihenfolge nach Alter an und speichert sie als student_order.

• Die dritte Anweisung des Skripts speichert die ersten 4 Tupel von student_order wie student_limit.

• Schließlich wird die vierte Anweisung den Inhalt der Beziehung ausgeben student_limit.

Lassen Sie uns nun das ausführen sample_script.pig Wie nachfolgend dargestellt.

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

Apache Pig wird ausgeführt und gibt Ihnen die Ausgabe mit dem folgenden Inhalt.

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