Apache Pig - Guide rapide

Qu'est-ce qu'Apache Pig?

Apache Pig est une abstraction sur MapReduce. C'est un outil / une plateforme qui est utilisé pour analyser des ensembles de données plus volumineux les représentant sous forme de flux de données. Le porc est généralement utilisé avecHadoop; nous pouvons effectuer toutes les opérations de manipulation de données dans Hadoop en utilisant Apache Pig.

Pour écrire des programmes d'analyse de données, Pig fournit un langage de haut niveau appelé Pig Latin. Ce langage fournit divers opérateurs à l'aide desquels les programmeurs peuvent développer leurs propres fonctions de lecture, d'écriture et de traitement des données.

Pour analyser les données en utilisant Apache Pig, les programmeurs doivent écrire des scripts en utilisant le langage Pig Latin. Tous ces scripts sont convertis en interne en tâches de mappage et de réduction. Apache Pig a un composant appeléPig Engine qui accepte les scripts Pig Latin comme entrée et convertit ces scripts en travaux MapReduce.

Pourquoi avons-nous besoin d'Apache Pig?

Les programmeurs qui ne sont pas très bons en Java avaient généralement du mal à travailler avec Hadoop, en particulier lorsqu'ils exécutaient des tâches MapReduce. Apache Pig est une aubaine pour tous ces programmeurs.

En utilisant Pig Latin, les programmeurs peuvent effectuer facilement des tâches MapReduce sans avoir à taper des codes complexes en Java.
Apache Pig utilise multi-query approach, réduisant ainsi la longueur des codes. Par exemple, une opération qui vous obligerait à taper 200 lignes de code (LoC) en Java peut être facilement effectuée en tapant aussi moins que 10 LoC dans Apache Pig. En fin de compte, Apache Pig réduit le temps de développement de près de 16 fois.
Pig Latin est SQL-like language et il est facile d'apprendre Apache Pig lorsque vous êtes familiarisé avec SQL.
Apache Pig fournit de nombreux opérateurs intégrés pour prendre en charge les opérations sur les données telles que les jointures, les filtres, le classement, etc.

Caractéristiques de Pig

Apache Pig est livré avec les fonctionnalités suivantes -

Rich set of operators - Il fournit de nombreux opérateurs pour effectuer des opérations telles que joindre, trier, filer, etc.
Ease of programming - Pig Latin est similaire à SQL et il est facile d'écrire un script Pig si vous êtes bon en SQL.
Optimization opportunities - Les tâches dans Apache Pig optimisent automatiquement leur exécution, les programmeurs doivent donc se concentrer uniquement sur la sémantique du langage.
Extensibility - En utilisant les opérateurs existants, les utilisateurs peuvent développer leurs propres fonctions pour lire, traiter et écrire des données.
UDF’s - Pig fournit la possibilité de créer User-defined Functions dans d'autres langages de programmation tels que Java et les invoquer ou les incorporer dans des scripts Pig.
Handles all kinds of data- Apache Pig analyse toutes sortes de données, aussi bien structurées que non structurées. Il stocke les résultats dans HDFS.

Apache Pig contre MapReduce

Vous trouverez ci-dessous les principales différences entre Apache Pig et MapReduce.

Apache Pig	MapReduce
Apache Pig est un langage de flux de données.	MapReduce est un paradigme de traitement de données.
C'est un langage de haut niveau.	MapReduce est de bas niveau et rigide.
L'exécution d'une opération de jointure dans Apache Pig est assez simple.	Il est assez difficile dans MapReduce d'effectuer une opération de jointure entre des ensembles de données.
Tout programmeur novice ayant une connaissance de base de SQL peut travailler facilement avec Apache Pig.	L'exposition à Java est indispensable pour travailler avec MapReduce.
Apache Pig utilise une approche multi-requêtes, réduisant ainsi la longueur des codes dans une large mesure.	MapReduce nécessitera près de 20 fois plus de lignes pour effectuer la même tâche.
Il n'y a pas besoin de compilation. Lors de l'exécution, chaque opérateur Apache Pig est converti en interne en un travail MapReduce.	Les travaux MapReduce ont un long processus de compilation.

Apache Pig contre SQL

Vous trouverez ci-dessous les principales différences entre Apache Pig et SQL.

Porc	SQL
Pig Latin est un procedural Langue.	SQL est un declarative Langue.
Dans Apache Pig, schemaest facultatif. Nous pouvons stocker des données sans concevoir de schéma (les valeurs sont stockées comme$01, $02 etc.)	Le schéma est obligatoire dans SQL.
Le modèle de données dans Apache Pig est nested relational.	Le modèle de données utilisé dans SQL is flat relational.
Apache Pig offre des opportunités limitées pour Query optimization.	Il y a plus d'opportunités d'optimisation des requêtes dans SQL.

En plus des différences ci-dessus, Apache Pig Latin -

Permet les fractionnements dans le pipeline.
Permet aux développeurs de stocker des données n'importe où dans le pipeline.
Déclare les plans d'exécution.
Fournit des opérateurs pour exécuter les fonctions ETL (Extraire, Transformer et Charger).

Apache Pig Vs Hive

Apache Pig et Hive sont tous deux utilisés pour créer des tâches MapReduce. Et dans certains cas, Hive fonctionne sur HDFS de la même manière qu'Apache Pig. Dans le tableau suivant, nous avons répertorié quelques points importants qui distinguent Apache Pig de Hive.

Apache Pig	Ruche
Apache Pig utilise un langage appelé Pig Latin. Il a été créé à l'origine àYahoo.	Hive utilise un langage appelé HiveQL. Il a été créé à l'origine àFacebook.
Pig Latin est un langage de flux de données.	HiveQL est un langage de traitement de requêtes.
Pig Latin est un langage procédural et il s'inscrit dans le paradigme du pipeline.	HiveQL est un langage déclaratif.
Apache Pig peut gérer des données structurées, non structurées et semi-structurées.	Hive est principalement destiné aux données structurées.

Applications d'Apache Pig

Apache Pig est généralement utilisé par les data scientists pour effectuer des tâches impliquant un traitement ad hoc et un prototypage rapide. Apache Pig est utilisé -

Pour traiter d'énormes sources de données telles que les journaux Web.
Pour effectuer le traitement des données pour les plateformes de recherche.
Pour traiter les charges de données sensibles au temps.

Apache Pig - Histoire

Dans 2006, Apache Pig a été développé en tant que projet de recherche chez Yahoo, en particulier pour créer et exécuter des tâches MapReduce sur chaque ensemble de données. Dans2007, Apache Pig a été open source via l'incubateur Apache. Dans2008, la première version d'Apache Pig est sortie. Dans2010, Apache Pig a obtenu son diplôme en tant que projet de premier niveau Apache.

Le langage utilisé pour analyser les données dans Hadoop à l'aide de Pig est appelé Pig Latin. C'est un langage de traitement de données de haut niveau qui fournit un riche ensemble de types de données et d'opérateurs pour effectuer diverses opérations sur les données.

Pour effectuer une tâche particulière Les programmeurs utilisant Pig, les programmeurs doivent écrire un script Pig en utilisant le langage Pig Latin, et les exécuter en utilisant l'un des mécanismes d'exécution (Grunt Shell, UDF, Embedded). Après exécution, ces scripts passeront par une série de transformations appliquées par le Pig Framework, pour produire la sortie souhaitée.

En interne, Apache Pig convertit ces scripts en une série de tâches MapReduce et facilite ainsi le travail du programmeur. L'architecture d'Apache Pig est illustrée ci-dessous.

Composants Apache Pig

Comme le montre la figure, il existe différents composants dans le framework Apache Pig. Jetons un coup d'œil aux principaux composants.

Analyseur

Au départ, les scripts Pig sont gérés par l'analyseur. Il vérifie la syntaxe du script, effectue une vérification de type et d'autres vérifications diverses. La sortie de l'analyseur sera un DAG (graphique acyclique dirigé), qui représente les instructions Pig Latin et les opérateurs logiques.

Dans le DAG, les opérateurs logiques du script sont représentés sous forme de nœuds et les flux de données sont représentés sous forme d'arêtes.

Optimiseur

Le plan logique (DAG) est transmis à l'optimiseur logique, qui effectue les optimisations logiques telles que la projection et le refoulement.

Compilateur

Le compilateur compile le plan logique optimisé en une série de travaux MapReduce.

Moteur d'exécution

Enfin, les travaux MapReduce sont soumis à Hadoop dans un ordre trié. Enfin, ces jobs MapReduce sont exécutés sur Hadoop et produisent les résultats souhaités.

Modèle de données Pig Latin

Le modèle de données de Pig Latin est entièrement imbriqué et autorise des types de données non atomiques complexes tels que map et tuple. Ci-dessous, la représentation schématique du modèle de données de Pig Latin.

Atome

Toute valeur unique en Pig Latin, indépendamment de leurs données, le type est appelée Atom. Il est stocké sous forme de chaîne et peut être utilisé comme chaîne et nombre. int, long, float, double, chararray et bytearray sont les valeurs atomiques de Pig. Une donnée ou une simple valeur atomique est connue sous le nom defield.

Example - 'raja' ou '30'

Tuple

Un enregistrement formé par un ensemble ordonné de champs est appelé tuple, les champs peuvent être de n'importe quel type. Un tuple est similaire à une ligne dans une table de SGBDR.

Example - (Raja, 30 ans)

Sac

Un sac est un ensemble non ordonné de tuples. En d'autres termes, une collection de tuples (non uniques) est connue sous le nom de sac. Chaque tuple peut avoir n'importe quel nombre de champs (schéma flexible). Un sac est représenté par «{}». Elle est similaire à une table en SGBDR, mais contrairement à une table en SGBDR, il n'est pas nécessaire que chaque tuple contienne le même nombre de champs ou que les champs à la même position (colonne) aient le même type.

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

Un sac peut être un champ dans une relation; dans ce contexte, il est connu commeinner bag.

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

Carte

Une carte (ou carte de données) est un ensemble de paires clé-valeur. lekeydoit être de type chararray et doit être unique. levaluepeut être de n'importe quel type. Il est représenté par «[]»

Example - [nom # Raja, 30 ans]

Relation

Une relation est un sac de tuples. Les relations en Pig Latin ne sont pas ordonnées (il n'y a aucune garantie que les tuples soient traités dans un ordre particulier).

Ce chapitre explique comment télécharger, installer et configurer Apache Pig dans votre système.

Conditions préalables

Il est essentiel que Hadoop et Java soient installés sur votre système avant de passer à Apache Pig. Par conséquent, avant d'installer Apache Pig, installez Hadoop et Java en suivant les étapes indiquées dans le lien suivant -

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

Télécharger Apache Pig

Tout d'abord, téléchargez la dernière version d'Apache Pig à partir du site Web suivant - https://pig.apache.org/

Étape 1

Ouvrez la page d'accueil du site Web Apache Pig. Sous la sectionNews, Clique sur le lien release page comme illustré dans l'instantané suivant.

Étape 2

En cliquant sur le lien spécifié, vous serez redirigé vers le Apache Pig Releasespage. Sur cette page, sous leDownload section, vous aurez deux liens, à savoir, Pig 0.8 and later et Pig 0.7 and before. Clique sur le lienPig 0.8 and later, vous serez alors redirigé vers la page contenant un ensemble de miroirs.

Étape 3

Choisissez et cliquez sur l'un de ces miroirs comme indiqué ci-dessous.

Étape 4

Ces miroirs vous mèneront au Pig Releasespage. Cette page contient différentes versions d'Apache Pig. Cliquez sur la dernière version parmi eux.

Étape 5

Dans ces dossiers, vous aurez les fichiers source et binaire d'Apache Pig dans diverses distributions. Téléchargez les fichiers tar des fichiers source et binaire d'Apache Pig 0.15,pig0.15.0-src.tar.gz et pig-0.15.0.tar.gz.

Installez Apache Pig

Après avoir téléchargé le logiciel Apache Pig, installez-le dans votre environnement Linux en suivant les étapes ci-dessous.

Étape 1

Créez un répertoire avec le nom Pig dans le même répertoire où les répertoires d'installation de Hadoop, Java,et d'autres logiciels ont été installés. (Dans notre tutoriel, nous avons créé le répertoire Pig dans l'utilisateur nommé Hadoop).

$ mkdir Pig

Étape 2

Extrayez les fichiers tar téléchargés comme indiqué ci-dessous.

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

Étape 3

Déplacer le contenu de pig-0.15.0-src.tar.gz fichier au Pig répertoire créé précédemment comme indiqué ci-dessous.

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

Configurer Apache Pig

Après avoir installé Apache Pig, nous devons le configurer. Pour configurer, nous devons éditer deux fichiers -bashrc and pig.properties.

fichier .bashrc

dans le .bashrc fichier, définissez les variables suivantes -

PIG_HOME dossier dans le dossier d'installation d'Apache Pig,
PATH variable d'environnement dans le dossier bin, et
PIG_CLASSPATH dans le dossier etc (configuration) de vos installations Hadoop (le répertoire qui contient les fichiers core-site.xml, hdfs-site.xml et mapred-site.xml).

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

fichier pig.properties

dans le conf dossier de Pig, nous avons un fichier nommé pig.properties. Dans le fichier pig.properties, vous pouvez définir divers paramètres comme indiqué ci-dessous.

pig -h properties

Les propriétés suivantes sont prises en charge -

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.

Vérification de l'installation

Vérifiez l'installation d'Apache Pig en tapant la commande version. Si l'installation réussit, vous obtiendrez la version d'Apache Pig comme indiqué ci-dessous.

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

Dans le chapitre précédent, nous avons expliqué comment installer Apache Pig. Dans ce chapitre, nous verrons comment exécuter Apache Pig.

Modes d'exécution d'Apache Pig

Vous pouvez exécuter Apache Pig dans deux modes, à savoir, Local Mode et HDFS mode.

Mode local

Dans ce mode, tous les fichiers sont installés et exécutés à partir de votre hôte local et de votre système de fichiers local. Il n'y a pas besoin de Hadoop ou HDFS. Ce mode est généralement utilisé à des fins de test.

Mode MapReduce

Le mode MapReduce est l'endroit où nous chargeons ou traitons les données qui existent dans le système de fichiers Hadoop (HDFS) à l'aide d'Apache Pig. Dans ce mode, chaque fois que nous exécutons les instructions Pig Latin pour traiter les données, une tâche MapReduce est appelée dans le back-end pour effectuer une opération particulière sur les données qui existent dans le HDFS.

Mécanismes d'exécution Apache Pig

Les scripts Apache Pig peuvent être exécutés de trois manières, à savoir, en mode interactif, en mode batch et en mode intégré.

Interactive Mode(Grunt shell) - Vous pouvez exécuter Apache Pig en mode interactif à l'aide du shell Grunt. Dans ce shell, vous pouvez entrer les instructions Pig Latin et obtenir la sortie (en utilisant l'opérateur Dump).
Batch Mode (Script) - Vous pouvez exécuter Apache Pig en mode Batch en écrivant le script Pig Latin dans un seul fichier avec .pig extension.
Embedded Mode (UDF) - Apache Pig fournit la possibilité de définir nos propres fonctions (User Ddéfini Functions) dans des langages de programmation tels que Java, et en les utilisant dans notre script.

Invoquer le Grunt Shell

Vous pouvez invoquer le shell Grunt dans un mode souhaité (local / MapReduce) en utilisant le −x option comme indiqué ci-dessous.

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

Chacune de ces commandes vous donne l'invite du shell Grunt comme indiqué ci-dessous.

grunt>

Vous pouvez quitter le shell Grunt en utilisant ‘ctrl + d’.

Après avoir appelé le shell Grunt, vous pouvez exécuter un script Pig en y entrant directement les instructions Pig Latin.

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

Exécution d'Apache Pig en mode batch

Vous pouvez écrire un script Pig Latin entier dans un fichier et l'exécuter en utilisant le –x command. Supposons que nous ayons un script Pig dans un fichier nommésample_script.pig comme indiqué ci-dessous.

Sample_script.pig

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

Maintenant, vous pouvez exécuter le script dans le fichier ci-dessus comme indiqué ci-dessous.

Mode local	Mode MapReduce
$ cochon -x local Sample_script.pig	$ cochon -x mapreduce Sample_script.pig

Note - Nous discuterons en détail comment exécuter un script Pig dans Bach mode et en embedded mode dans les chapitres suivants.

Après avoir appelé le shell Grunt, vous pouvez exécuter vos scripts Pig dans le shell. En plus de cela, il existe certaines commandes shell et utilitaires utiles fournies par le shell Grunt. Ce chapitre explique les commandes shell et utilitaires fournies par le shell Grunt.

Note - Dans certaines parties de ce chapitre, les commandes comme Load et Storesont utilisés. Reportez-vous aux chapitres respectifs pour obtenir des informations détaillées à leur sujet.

Commandes du shell

Le shell Grunt d'Apache Pig est principalement utilisé pour écrire des scripts Pig Latin. Avant cela, nous pouvons invoquer toutes les commandes shell en utilisantsh et fs.

Commande sh

En utilisant shcommande, nous pouvons invoquer n'importe quelle commande shell à partir du shell Grunt. En utilisantsh commande depuis le shell Grunt, nous ne pouvons pas exécuter les commandes qui font partie de l'environnement du shell (ex - cd).

Syntax

Voici la syntaxe de sh commander.

grunt> sh shell command parameters

Example

Nous pouvons invoquer le ls commande du shell Linux depuis le shell Grunt en utilisant le shoption comme indiqué ci-dessous. Dans cet exemple, il répertorie les fichiers dans le/pig/bin/ annuaire.

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

Commande fs

En utilisant le fs commande, nous pouvons invoquer toutes les commandes FsShell à partir du shell Grunt.

Syntax

Voici la syntaxe de fs commander.

grunt> sh File System command parameters

Example

Nous pouvons appeler la commande ls de HDFS à partir du shell Grunt en utilisant la commande fs. Dans l'exemple suivant, il répertorie les fichiers dans le répertoire racine HDFS.

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

De la même manière, nous pouvons invoquer toutes les autres commandes shell du système de fichiers depuis le shell Grunt en utilisant le fs commander.

Commandes utilitaires

Le shell Grunt fournit un ensemble de commandes utilitaires. Ceux-ci incluent des commandes utilitaires telles queclear, help, history, quit, et set; et des commandes telles queexec, kill, et runpour contrôler Pig depuis le shell Grunt. Ci-dessous se trouve la description des commandes utilitaires fournies par le shell Grunt.

Effacer la commande

le clear La commande est utilisée pour effacer l'écran du shell Grunt.

Syntax

Vous pouvez effacer l'écran du grunt shell en utilisant le clear comme indiqué ci-dessous.

grunt> clear

Commande help

le help La commande vous donne une liste de commandes Pig ou de propriétés Pig.

Usage

Vous pouvez obtenir une liste des commandes Pig en utilisant le help comme indiqué ci-dessous.

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.

Commande historique

Cette commande affiche une liste des instructions exécutées / utilisées jusqu'à présent depuis l'appel de la vente Grunt.

Usage

Supposons que nous ayons exécuté trois instructions depuis l'ouverture du shell Grunt.

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(',');

Ensuite, en utilisant le history commande produira la sortie suivante.

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(',');

commande set

le set La commande est utilisée pour afficher / affecter des valeurs aux clés utilisées dans Pig.

Usage

À l'aide de cette commande, vous pouvez définir les valeurs des touches suivantes.

Clé	Description et valeurs
default_parallel	Vous pouvez définir le nombre de réducteurs pour un travail de carte en transmettant n'importe quel nombre entier comme valeur à cette clé.
debug	Vous pouvez désactiver ou activer la fonction de débogage dans Pig en passant on / off à cette touche.
job.name	Vous pouvez définir le nom du travail sur le travail requis en transmettant une valeur de chaîne à cette clé.
job.priority	Vous pouvez définir la priorité du travail sur un travail en transmettant l'une des valeurs suivantes à cette clé - very_low low normal high very_high
stream.skippath	Pour le streaming, vous pouvez définir le chemin à partir duquel les données ne doivent pas être transférées, en passant le chemin souhaité sous forme de chaîne à cette clé.

Commande quit

Vous pouvez quitter le shell Grunt en utilisant cette commande.

Usage

Quittez le shell Grunt comme indiqué ci-dessous.

grunt> quit

Jetons maintenant un coup d'œil aux commandes à l'aide desquelles vous pouvez contrôler Apache Pig à partir du shell Grunt.

Commande exec

En utilisant le exec commande, nous pouvons exécuter des scripts Pig à partir du shell Grunt.

Syntax

Voici la syntaxe de la commande utilitaire exec.

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

Example

Supposons qu'il existe un fichier nommé student.txt dans le /pig_data/ répertoire de HDFS avec le contenu suivant.

Student.txt

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

Et, supposons que nous ayons un fichier de script nommé sample_script.pig dans le /pig_data/ répertoire de HDFS avec le contenu suivant.

Sample_script.pig

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

Maintenant, exécutons le script ci-dessus à partir du shell Grunt en utilisant le exec comme indiqué ci-dessous.

grunt> exec /sample_script.pig

Output

le exec commande exécute le script dans le sample_script.pig. Comme indiqué dans le script, il charge lestudent.txt fichier dans Pig et vous donne le résultat de l'opérateur Dump affichant le contenu suivant.

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

Commande kill

Vous pouvez tuer un travail du shell Grunt en utilisant cette commande.

Syntax

Ci-dessous, la syntaxe du kill commander.

grunt> kill JobId

Example

Supposons qu'il y ait un travail Pig en cours d'exécution ayant un identifiant Id_0055, vous pouvez le tuer depuis le shell Grunt en utilisant le kill commande, comme indiqué ci-dessous.

grunt> kill Id_0055

exécuter la commande

Vous pouvez exécuter un script Pig à partir du shell Grunt en utilisant le run commander

Syntax

Ci-dessous, la syntaxe du run commander.

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

Example

Supposons qu'il existe un fichier nommé student.txt dans le /pig_data/ répertoire de HDFS avec le contenu suivant.

Student.txt

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

Et, supposons que nous ayons un fichier de script nommé sample_script.pig dans le système de fichiers local avec le contenu suivant.

Sample_script.pig

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

Maintenant, exécutons le script ci-dessus à partir du shell Grunt en utilisant la commande run comme indiqué ci-dessous.

grunt> run /sample_script.pig

Vous pouvez voir la sortie du script en utilisant le Dump operator comme indiqué ci-dessous.

grunt> Dump;

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

Note - La différence entre exec et le run commande est que si nous utilisons run, les instructions du script sont disponibles dans l'historique des commandes.

Pig Latin est la langue utilisée pour analyser les données dans Hadoop à l'aide d'Apache Pig. Dans ce chapitre, nous allons discuter des bases de Pig Latin telles que les instructions Pig Latin, les types de données, les opérateurs généraux et relationnels et les UDF Pig Latin.

Pig Latin - Modèle de données

Comme indiqué dans les chapitres précédents, le modèle de données de Pig est entièrement imbriqué. UNERelationest la structure la plus externe du modèle de données Pig Latin. Et c'est unbag où -

Un sac est une collection de tuples.
Un tuple est un ensemble ordonné de champs.
Un champ est une donnée.

Pig Latin - Statemets

Lors du traitement des données avec Pig Latin, statements sont les constructions de base.

Ces déclarations fonctionnent avec relations. Ils comprennentexpressions et schemas.
Chaque instruction se termine par un point-virgule (;).
Nous effectuerons diverses opérations à l'aide d'opérateurs fournis par Pig Latin, à travers des instructions.
À l'exception de LOAD et STORE, lors de l'exécution de toutes les autres opérations, les instructions Pig Latin prennent une relation en entrée et en produisent une autre en sortie.
Dès que vous entrez un Loaddans le shell Grunt, sa vérification sémantique sera effectuée. Pour voir le contenu du schéma, vous devez utiliser leDumpopérateur. Seulement après avoir effectué ledump opération, le travail MapReduce de chargement des données dans le système de fichiers sera exécuté.

Exemple

Vous trouverez ci-dessous une instruction Pig Latin, qui charge les données dans Apache Pig.

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

Pig Latin - Types de données

Le tableau ci-dessous décrit les types de données Pig Latin.

SN	Type de données	Description et exemple
1	int	Représente un entier 32 bits signé. Example : 8
2	longue	Représente un entier 64 bits signé. Example : 5 L
3	flotte	Représente une virgule flottante 32 bits signée. Example : 5.5F
4	double	Représente une virgule flottante 64 bits. Example : 10,5
5	chararray	Représente un tableau de caractères (chaîne) au format Unicode UTF-8. Example : 'point de tutoriels'
6	Bytearray	Représente un tableau d'octets (blob).
sept	Booléen	Représente une valeur booléenne. Example : vrai faux.
8	Datetime	Représente une date-heure. Example : 1970-01-01T00: 00: 00.000 + 00: 00
9	Biginteger	Représente un BigInteger Java. Example : 60708090709
dix	Bigdecimal	Représente un Java BigDecimal Example : 185,98376256272893883
Types complexes
11	Tuple	Un tuple est un ensemble ordonné de champs. Example : (raja, 30 ans)
12	Sac	Un sac est une collection de tuples. Example : {(raju, 30), (Mohhammad, 45)}
13	Carte	Une carte est un ensemble de paires clé-valeur. Example : ['nom' # 'Raju', 'âge' # 30]

Valeurs nulles

Les valeurs de tous les types de données ci-dessus peuvent être NULL. Apache Pig traite les valeurs nulles de la même manière que SQL.

Un null peut être une valeur inconnue ou une valeur inexistante. Il est utilisé comme espace réservé pour les valeurs facultatives. Ces valeurs nulles peuvent se produire naturellement ou être le résultat d'une opération.

Pig Latin - Opérateurs arithmétiques

Le tableau suivant décrit les opérateurs arithmétiques de Pig Latin. Supposons a = 10 et b = 20.

Opérateur	La description	Exemple
+	Addition - Ajoute des valeurs de chaque côté de l'opérateur	a + b donnera 30
-	Subtraction - Soustrait l'opérande de droite de l'opérande de gauche	a - b donnera −10
*	Multiplication - Multiplie les valeurs de chaque côté de l'opérateur	a * b donnera 200
/	Division - Divise l'opérande de gauche par l'opérande de droite	b / a donnera 2
%	Modulus - Divise l'opérande de gauche par l'opérande de droite et renvoie le reste	b% a donnera 0
? :	Bincond- Évalue les opérateurs booléens. Il a trois opérandes comme indiqué ci-dessous. variable x = (expression)? value1 si vrai :value2 si faux .	b = (a == 1)? 20: 30; si a = 1, la valeur de b est 20. si a! = 1 la valeur de b est 30.
CAS QUAND PUIS AUTRE FIN	Case - L'opérateur case est équivalent à l'opérateur bincond imbriqué.	CAS f2% 2 QUAND 0 PUIS 'même' QUAND 1 PUIS 'impair' FIN

Pig Latin - Opérateurs de comparaison

Le tableau suivant décrit les opérateurs de comparaison de Pig Latin.

Opérateur	La description	Exemple
==	Equal- Vérifie si les valeurs de deux opérandes sont égales ou non; si oui, alors la condition devient vraie.	(a = b) n'est pas vrai
! =	Not Equal- Vérifie si les valeurs de deux opérandes sont égales ou non. Si les valeurs ne sont pas égales, la condition devient vraie.	(a! = b) est vrai.
>	Greater than- Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit. Si oui, alors la condition devient vraie.	(a> b) n'est pas vrai.
<	Less than- Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit. Si oui, alors la condition devient vraie.	(a <b) est vrai.
> =	Greater than or equal to- Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit. Si oui, alors la condition devient vraie.	(a> = b) n'est pas vrai.
<=	Less than or equal to- Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit. Si oui, alors la condition devient vraie.	(a <= b) est vrai.
allumettes	Pattern matching - Vérifie si la chaîne du côté gauche correspond à la constante du côté droit.	f1 correspond à ". * tutorial. *"

Pig Latin - Opérateurs de construction de type

Le tableau suivant décrit les opérateurs de construction Type de Pig Latin.

Opérateur	La description	Exemple
()	Tuple constructor operator - Cet opérateur est utilisé pour construire un tuple.	(Raju, 30 ans)
{}	Bag constructor operator - Cet opérateur est utilisé pour construire un sac.	{(Raju, 30 ans), (Mohammad, 45 ans)}
[]	Map constructor operator - Cet opérateur est utilisé pour construire un tuple.	[nom # Raja, 30 ans]

Pig Latin - Opérations relationnelles

Le tableau suivant décrit les opérateurs relationnels de Pig Latin.

Opérateur	La description
Loading and Storing
CHARGE	Pour charger les données du système de fichiers (local / HDFS) dans une relation.
BOUTIQUE	Pour enregistrer une relation avec le système de fichiers (local / HDFS).
Filtration
FILTRE	Pour supprimer les lignes indésirables d'une relation.
DISTINCT	Pour supprimer les lignes dupliquées d'une relation.
AVANT CHAQUE, GÉNÉRER	Pour générer des transformations de données basées sur des colonnes de données.
COURANT	Transformer une relation à l'aide d'un programme externe.
Regroupement et regroupement
JOINDRE	Pour rejoindre deux ou plusieurs relations.
COGROUP	Pour regrouper les données en deux ou plusieurs relations.
GROUPE	Pour regrouper les données dans une seule relation.
TRAVERSER	Pour créer le produit croisé de deux ou plusieurs relations.
Tri
ORDRE	Pour organiser une relation dans un ordre trié basé sur un ou plusieurs champs (croissant ou décroissant).
LIMITE	Pour obtenir un nombre limité de tuples à partir d'une relation.
Combinaison et fractionnement
SYNDICAT	Combiner deux ou plusieurs relations en une seule relation.
DIVISÉ	Pour diviser une seule relation en deux ou plusieurs relations.
Opérateurs de diagnostic
DÉVERSER	Pour imprimer le contenu d'une relation sur la console.
DÉCRIS	Décrire le schéma d'une relation.
EXPLIQUE	Pour afficher les plans d'exécution logiques, physiques ou MapReduce pour calculer une relation.
ILLUSTRER	Pour afficher l'exécution pas à pas d'une série d'instructions.

En général, Apache Pig fonctionne sur Hadoop. C'est un outil analytique qui analyse les grands ensembles de données qui existent dans leHadoop File System. Pour analyser les données à l'aide d'Apache Pig, nous devons d'abord charger les données dans Apache Pig. Ce chapitre explique comment charger des données sur Apache Pig à partir de HDFS.

Préparation de HDFS

En mode MapReduce, Pig lit (charge) les données de HDFS et stocke les résultats dans HDFS. Par conséquent, commençons HDFS et créons les exemples de données suivants dans HDFS.

Carte d'étudiant	Prénom	Nom de famille	Téléphone	Ville
001	Rajiv	Reddy	9848022337	Hyderabad
002	siddarth	Battacharya	9848022338	Calcutta
003	Rajesh	Khanna	9848022339	Delhi
004	Preethi	Agarwal	9848022330	Pune
005	Trupthi	Mohanthy	9848022336	Bhuwaneshwar
006	Archana	Mishra	9848022335	Chennai

L'ensemble de données ci-dessus contient des informations personnelles telles que l'identifiant, le prénom, le nom, le numéro de téléphone et la ville de six étudiants.

Étape 1: vérification de Hadoop

Tout d'abord, vérifiez l'installation à l'aide de la commande de version Hadoop, comme indiqué ci-dessous.

$ hadoop version

Si votre système contient Hadoop, et si vous avez défini la variable PATH, vous obtiendrez la sortie suivante -

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

Étape 2: démarrer HDFS

Parcourez le sbin répertoire de Hadoop et démarrer yarn et Hadoop dfs (système de fichiers distribué) comme indiqué ci-dessous.

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

Étape 3: créer un répertoire dans HDFS

Dans Hadoop DFS, vous pouvez créer des répertoires à l'aide de la commande mkdir. Créez un nouveau répertoire dans HDFS avec le nomPig_Data dans le chemin requis comme indiqué ci-dessous.

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

Étape 4: Placement des données dans HDFS

Le fichier d'entrée de Pig contient chaque tuple / enregistrement dans des lignes individuelles. Et les entités de l'enregistrement sont séparées par un délimiteur (dans notre exemple nous avons utilisé“,”).

Dans le système de fichiers local, créez un fichier d'entrée student_data.txt contenant des données comme indiqué ci-dessous.

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.

Maintenant, déplacez le fichier du système de fichiers local vers HDFS en utilisant putcomme indiqué ci-dessous. (Vous pouvez utilisercopyFromLocal commande aussi.)

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

Vérification du fichier

Vous pouvez utiliser le cat pour vérifier si le fichier a été déplacé vers le HDFS, comme indiqué ci-dessous.

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

Production

Vous pouvez voir le contenu du fichier comme indiqué ci-dessous.

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

L'opérateur de charge

Vous pouvez charger des données dans Apache Pig à partir du système de fichiers (HDFS / Local) en utilisant LOAD opérateur de Pig Latin.

Syntaxe

L'instruction de chargement se compose de deux parties divisées par l'opérateur «=». Sur le côté gauche, nous devons mentionner le nom de la relationwhere nous voulons stocker les données, et sur le côté droit, nous devons définir hownous stockons les données. Ci-dessous, la syntaxe duLoad opérateur.

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

Où,

relation_name - Nous devons mentionner la relation dans laquelle nous voulons stocker les données.
Input file path- Nous devons mentionner le répertoire HDFS où le fichier est stocké. (En mode MapReduce)
function - Nous devons choisir une fonction parmi l'ensemble des fonctions de chargement fourni par Apache Pig (BinStorage, JsonLoader, PigStorage, TextLoader).
Schema- Nous devons définir le schéma des données. Nous pouvons définir le schéma requis comme suit -

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

Note- Nous chargeons les données sans spécifier le schéma. Dans ce cas, les colonnes seront adressées comme $ 01, $ 02, etc… (cocher).

Exemple

À titre d'exemple, chargeons les données dans student_data.txt dans Pig sous le schéma nommé Student en utilisant le LOAD commander.

Démarrez Pig Grunt Shell

Tout d'abord, ouvrez le terminal Linux. Démarrez le shell Pig Grunt en mode MapReduce comme indiqué ci-dessous.

$ Pig –x mapreduce

Il démarrera le shell Pig Grunt comme indiqué ci-dessous.

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>

Exécutez l'instruction Load

Maintenant, chargez les données du fichier student_data.txt dans Pig en exécutant l'instruction Pig Latin suivante dans le shell Grunt.

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

Voici la description de la déclaration ci-dessus.

Nom de la relation

Nous avons stocké les données dans le schéma student.

Chemin du fichier d'entrée

Nous lisons les données du fichier student_data.txt, qui se trouve dans le répertoire / pig_data / de HDFS.

Fonction de stockage

Nous avons utilisé le PigStorage()fonction. Il charge et stocke les données sous forme de fichiers texte structurés. Il prend un délimiteur à l'aide duquel chaque entité d'un tuple est séparée, en tant que paramètre. Par défaut, il prend '\ t' comme paramètre.

schéma

Nous avons stocké les données en utilisant le schéma suivant.

colonne	id	Prénom	nom de famille	téléphone	ville
Type de données	int	tableau de caractères	tableau de caractères	tableau de caractères	tableau de caractères

Note - Le loadL'instruction chargera simplement les données dans la relation spécifiée dans Pig. Pour vérifier l'exécution duLoad déclaration, vous devez utiliser la Diagnostic Operators qui sont discutés dans les chapitres suivants.

Dans le chapitre précédent, nous avons appris à charger des données dans Apache Pig. Vous pouvez stocker les données chargées dans le système de fichiers à l'aide dustoreopérateur. Ce chapitre explique comment stocker des données dans Apache Pig à l'aide deStore opérateur.

Syntaxe

Vous trouverez ci-dessous la syntaxe de l'instruction Store.

STORE Relation_name INTO ' required_directory_path ' [USING function];

Exemple

Supposons que nous ayons un fichier student_data.txt en HDFS avec le contenu suivant.

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.

Et nous l'avons lu dans une relation student en utilisant l'opérateur LOAD comme indiqué ci-dessous.

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

Maintenant, stockons la relation dans le répertoire HDFS “/pig_Output/” comme indiqué ci-dessous.

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

Production

Après avoir exécuté le storedéclaration, vous obtiendrez la sortie suivante. Un répertoire est créé avec le nom spécifié et les données y seront stockées.

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!

Vérification

Vous pouvez vérifier les données stockées comme indiqué ci-dessous.

Étape 1

Tout d'abord, listez les fichiers dans le répertoire nommé pig_output en utilisant le ls comme indiqué ci-dessous.

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

Vous pouvez observer que deux fichiers ont été créés après l'exécution du store déclaration.

Étape 2

En utilisant cat commande, listez le contenu du fichier nommé part-m-00000 comme indiqué ci-dessous.

$ 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

le loadL'instruction chargera simplement les données dans la relation spécifiée dans Apache Pig. Pour vérifier l'exécution duLoad déclaration, vous devez utiliser la Diagnostic Operators. Pig Latin propose quatre types différents d'opérateurs de diagnostic -

Opérateur de vidage
Décrire l'opérateur
Explication opérateur
Opérateur d'illustration

Dans ce chapitre, nous aborderons les opérateurs de vidage de Pig Latin.

Opérateur de vidage

le DumpL'opérateur est utilisé pour exécuter les instructions Pig Latin et afficher les résultats à l'écran. Il est généralement utilisé pour le débogage Objectif.

Syntaxe

Ci-dessous, la syntaxe du Dump opérateur.

grunt> Dump Relation_Name

Exemple

Supposons que nous ayons un fichier student_data.txt en HDFS avec le contenu suivant.

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.

Et nous l'avons lu dans une relation student en utilisant l'opérateur LOAD comme indiqué ci-dessous.

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

Maintenant, imprimons le contenu de la relation en utilisant le Dump operator comme indiqué ci-dessous.

grunt> Dump student

Une fois que vous exécutez ce qui précède Pig Latin, il lancera une tâche MapReduce pour lire les données à partir de HDFS. Il produira la sortie suivante.

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)

le describe L'opérateur est utilisé pour visualiser le schéma d'une relation.

Syntaxe

La syntaxe du describe l'opérateur est le suivant -

grunt> Describe Relation_name

Exemple

Supposons que nous ayons un fichier student_data.txt en HDFS avec le contenu suivant.

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.

Et nous l'avons lu dans une relation student en utilisant l'opérateur LOAD comme indiqué ci-dessous.

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

Maintenant, décrivons la relation nommée student et vérifiez le schéma comme indiqué ci-dessous.

grunt> describe student;

Production

Une fois que vous exécutez ce qui précède Pig Latin déclaration, il produira la sortie suivante.

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

le explain L'opérateur est utilisé pour afficher les plans d'exécution logique, physique et MapReduce d'une relation.

Syntaxe

Ci-dessous, la syntaxe du explain opérateur.

grunt> explain Relation_name;

Exemple

Supposons que nous ayons un fichier student_data.txt en HDFS avec le contenu suivant.

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.

Et nous l'avons lu dans une relation student en utilisant l'opérateur LOAD comme indiqué ci-dessous.

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

Maintenant, expliquons la relation nommée étudiant en utilisant le explain opérateur comme indiqué ci-dessous.

grunt> explain student;

Production

Il produira la sortie suivante.

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

le illustrate L'opérateur vous donne l'exécution étape par étape d'une séquence d'instructions.

Syntaxe

Ci-dessous, la syntaxe du illustrate opérateur.

grunt> illustrate Relation_name;

Exemple

Supposons que nous ayons un fichier student_data.txt en HDFS avec le contenu suivant.

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.

Et nous l'avons lu dans une relation student en utilisant l'opérateur LOAD comme indiqué ci-dessous.

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

Maintenant, illustrons la relation nommée étudiant comme indiqué ci-dessous.

grunt> illustrate student;

Production

En exécutant l'instruction ci-dessus, vous obtiendrez la sortie suivante.

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

le GROUPL'opérateur est utilisé pour regrouper les données dans une ou plusieurs relations. Il collecte les données ayant la même clé.

Syntaxe

Ci-dessous, la syntaxe du group opérateur.

grunt> Group_data = GROUP Relation_name BY age;

Exemple

Supposons que nous ayons un fichier nommé student_details.txt dans le répertoire HDFS /pig_data/ comme indiqué ci-dessous.

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

Et nous avons chargé ce fichier dans Apache Pig avec le nom de la relation student_details comme indiqué ci-dessous.

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

Maintenant, regroupons les enregistrements / tuples dans la relation par âge, comme indiqué ci-dessous.

grunt> group_data = GROUP student_details by age;

Vérification

Vérifier la relation group_data en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump group_data;

Production

Ensuite, vous obtiendrez une sortie affichant le contenu de la relation nommée group_datacomme indiqué ci-dessous. Ici, vous pouvez observer que le schéma résultant a deux colonnes -

L'un est age, par lequel nous avons regroupé la relation.
L'autre est un bag, qui contient le groupe de tuples, les enregistrements d'étudiants avec l'âge respectif.

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

Vous pouvez voir le schéma de la table après avoir regroupé les données à l'aide du describe comme indiqué ci-dessous.

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

De la même manière, vous pouvez obtenir l'exemple d'illustration du schéma en utilisant le illustrate comme indiqué ci-dessous.

$ Illustrate group_data;

Il produira la sortie suivante -

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

Regroupement par plusieurs colonnes

Regroupons la relation par âge et par ville comme indiqué ci-dessous.

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

Vous pouvez vérifier le contenu de la relation nommée group_multiple en utilisant l'opérateur Dump comme indiqué ci-dessous.

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

Regrouper tout

Vous pouvez regrouper une relation par toutes les colonnes comme indiqué ci-dessous.

grunt> group_all = GROUP student_details All;

Maintenant, vérifiez le contenu de la relation group_all comme indiqué ci-dessous.

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

le COGROUPL'opérateur fonctionne plus ou moins de la même manière que l' opérateur GROUP . La seule différence entre les deux opérateurs est que legroup L'opérateur est normalement utilisé avec une relation, tandis que cogroup L'opérateur est utilisé dans les instructions impliquant deux ou plusieurs relations.

Regroupement de deux relations à l'aide de Cogroup

Supposons que nous ayons deux fichiers à savoir student_details.txt et employee_details.txt dans le répertoire HDFS /pig_data/ comme indiqué ci-dessous.

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

Et nous avons chargé ces fichiers dans Pig avec les noms de relation student_details et employee_details respectivement, comme indiqué ci-dessous.

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

Maintenant, regroupons les enregistrements / tuples des relations student_details et employee_details avec l'âge de la clé, comme indiqué ci-dessous.

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

Vérification

Vérifier la relation cogroup_data en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump cogroup_data;

Production

Il produira la sortie suivante, affichant le contenu de la relation nommée cogroup_data comme indiqué ci-dessous.

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

le cogroup L'opérateur regroupe les tuples de chaque relation en fonction de l'âge où chaque groupe représente une valeur d'âge particulière.

Par exemple, si nous considérons le 1er tuple du résultat, il est groupé par âge 21. Et il contient deux sacs -

le premier sac contient tous les tuples de la première relation (student_details dans ce cas) avoir 21 ans, et
le deuxième sac contient tous les tuples de la deuxième relation (employee_details dans ce cas) avoir 21 ans.

Dans le cas où une relation n'a pas de tuples ayant la valeur d'âge 21, elle renvoie un sac vide.

le JOINL'opérateur est utilisé pour combiner des enregistrements de deux ou plusieurs relations. Lors de l'exécution d'une opération de jointure, nous déclarons un (ou un groupe de) tuple (s) de chaque relation, comme clés. Lorsque ces clés correspondent, les deux tuples particuliers sont mis en correspondance, sinon les enregistrements sont supprimés. Les jointures peuvent être des types suivants -

Self-join
Inner-join
Jointure externe - jointure gauche, jointure droite et jointure complète

Ce chapitre explique avec des exemples comment utiliser l'opérateur de jointure en Pig Latin. Supposons que nous ayons deux fichiers à savoircustomers.txt et orders.txt dans le /pig_data/ répertoire de HDFS comme indiqué ci-dessous.

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

Et nous avons chargé ces deux fichiers dans Pig avec les relations customers et orders comme indiqué ci-dessous.

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

Exécutons maintenant diverses opérations de jointure sur ces deux relations.

Auto-rejoindre

Self-join est utilisé pour joindre une table avec elle-même comme si la table était deux relations, en renommant temporairement au moins une relation.

Généralement, dans Apache Pig, pour effectuer une auto-jointure, nous chargerons les mêmes données plusieurs fois, sous différents alias (noms). Chargez donc le contenu du fichiercustomers.txt comme deux tableaux comme indiqué ci-dessous.

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

Syntaxe

Vous trouverez ci-dessous la syntaxe de l'exécution self-join opération utilisant le JOIN opérateur.

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

Exemple

Laissez-nous performer self-join opération sur la relation customers, en joignant les deux relations customers1 et customers2 comme indiqué ci-dessous.

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

Vérification

Vérifier la relation customers3 en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump customers3;

Production

Il produira la sortie suivante, affichant le contenu de la relation customers.

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

Jointure interne

Inner Joinest utilisé assez fréquemment; il est également appeléequijoin. Une jointure interne renvoie des lignes lorsqu'il existe une correspondance dans les deux tables.

Il crée une nouvelle relation en combinant les valeurs de colonne de deux relations (disons A et B) basées sur le prédicat de jointure. La requête compare chaque ligne de A avec chaque ligne de B pour trouver toutes les paires de lignes qui satisfont le prédicat de jointure. Lorsque le prédicat de jointure est satisfait, les valeurs de colonne pour chaque paire correspondante de lignes A et B sont combinées dans une ligne de résultat.

Syntaxe

Voici la syntaxe de l'exécution inner join opération utilisant le JOIN opérateur.

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

Exemple

Laissez-nous performer inner join opération sur les deux relations customers et orders comme indiqué ci-dessous.

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

Vérification

Vérifier la relation coustomer_orders en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump coustomer_orders;

Production

Vous obtiendrez la sortie suivante qui présentera le contenu de la relation nommée 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 -

Jointure externe : contrairement à la jointure interne,outer joinrenvoie toutes les lignes d'au moins une des relations. Une opération de jointure externe est effectuée de trois manières:

Jointure externe gauche
Jointure externe droite
Jointure externe complète

Jointure externe gauche

le left outer Join L'opération renvoie toutes les lignes de la table de gauche, même s'il n'y a pas de correspondance dans la relation de droite.

Syntaxe

Vous trouverez ci-dessous la syntaxe de l'exécution left outer join opération utilisant le JOIN opérateur.

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

Exemple

Réalisons l'opération de jointure externe gauche sur les deux relations clients et commandes comme indiqué ci-dessous.

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

Vérification

Vérifier la relation outer_left en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump outer_left;

Production

Il produira la sortie suivante, affichant le contenu de la relation outer_left.

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

Jointure externe droite

le right outer join L'opération renvoie toutes les lignes de la table de droite, même s'il n'y a aucune correspondance dans la table de gauche.

Syntaxe

Vous trouverez ci-dessous la syntaxe de l'exécution right outer join opération utilisant le JOIN opérateur.

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

Exemple

Laissez-nous performer right outer join opération sur les deux relations customers et orders comme indiqué ci-dessous.

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

Vérification

Vérifier la relation outer_right en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump outer_right

Production

Il produira la sortie suivante, affichant le contenu de la relation outer_right.

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

Jointure externe complète

le full outer join L'opération renvoie des lignes lorsqu'il y a une correspondance dans l'une des relations.

Syntaxe

Vous trouverez ci-dessous la syntaxe de l'exécution full outer join en utilisant le JOIN opérateur.

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

Exemple

Laissez-nous performer full outer join opération sur les deux relations customers et orders comme indiqué ci-dessous.

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

Vérification

Vérifier la relation outer_full en utilisant le DUMP opérateur comme indiqué ci-dessous.

grun> Dump outer_full;

Production

Il produira la sortie suivante, affichant le contenu de la relation outer_full.

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

Utilisation de plusieurs clés

Nous pouvons effectuer l'opération JOIN en utilisant plusieurs clés.

Syntaxe

Voici comment vous pouvez effectuer une opération JOIN sur deux tables à l'aide de plusieurs clés.

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

Supposons que nous ayons deux fichiers à savoir employee.txt et employee_contact.txt dans le /pig_data/ répertoire de HDFS comme indiqué ci-dessous.

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

Et nous avons chargé ces deux fichiers dans Pig avec des relations employee et employee_contact comme indiqué ci-dessous.

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

Maintenant, joignons le contenu de ces deux relations en utilisant le JOIN opérateur comme indiqué ci-dessous.

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

Vérification

Vérifier la relation emp en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump emp;

Production

Il produira la sortie suivante, affichant le contenu de la relation nommée emp comme indiqué ci-dessous.

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

le CROSSL'opérateur calcule le produit croisé de deux ou plusieurs relations. Ce chapitre explique avec un exemple comment utiliser l'opérateur croisé dans Pig Latin.

Syntaxe

Ci-dessous, la syntaxe du CROSS opérateur.

grunt> Relation3_name = CROSS Relation1_name, Relation2_name;

Exemple

Supposons que nous ayons deux fichiers à savoir customers.txt et orders.txt dans le /pig_data/ répertoire de HDFS comme indiqué ci-dessous.

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

Et nous avons chargé ces deux fichiers dans Pig avec les relations customers et orders comme indiqué ci-dessous.

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

Obtenons maintenant le produit croisé de ces deux relations en utilisant le cross opérateur sur ces deux relations comme indiqué ci-dessous.

grunt> cross_data = CROSS customers, orders;

Vérification

Vérifier la relation cross_data en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump cross_data;

Production

Il produira la sortie suivante, affichant le contenu de la relation cross_data.

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

le UNIONL'opérateur de Pig Latin est utilisé pour fusionner le contenu de deux relations. Pour effectuer l'opération UNION sur deux relations, leurs colonnes et domaines doivent être identiques.

Syntaxe

Ci-dessous, la syntaxe du UNION opérateur.

grunt> Relation_name3 = UNION Relation_name1, Relation_name2;

Exemple

Supposons que nous ayons deux fichiers à savoir student_data1.txt et student_data2.txt dans le /pig_data/ répertoire de HDFS comme indiqué ci-dessous.

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.

Et nous avons chargé ces deux fichiers dans Pig avec les relations student1 et student2 comme indiqué ci-dessous.

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

Fusionnons maintenant le contenu de ces deux relations en utilisant le UNION opérateur comme indiqué ci-dessous.

grunt> student = UNION student1, student2;

Vérification

Vérifier la relation student en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump student;

Production

Il affichera la sortie suivante, affichant le contenu de la relation student.

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

le SPLIT L'opérateur est utilisé pour diviser une relation en deux ou plusieurs relations.

Syntaxe

Ci-dessous, la syntaxe du SPLIT opérateur.

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

Exemple

Supposons que nous ayons un fichier nommé student_details.txt dans le répertoire HDFS /pig_data/ comme indiqué ci-dessous.

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

Et nous avons chargé ce fichier dans Pig avec le nom de la relation student_details comme indiqué ci-dessous.

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

Décomposons maintenant la relation en deux, l'une listant les salariés de moins de 23 ans et l'autre listant les salariés ayant entre 22 et 25 ans.

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

Vérification

Vérifier les relations student_details1 et student_details2 en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump student_details1;  

grunt> Dump student_details2;

Production

Il produira la sortie suivante, affichant le contenu des relations student_details1 et student_details2 respectivement.

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)

le FILTER L'opérateur est utilisé pour sélectionner les tuples requis à partir d'une relation basée sur une condition.

Syntaxe

Ci-dessous, la syntaxe du FILTER opérateur.

grunt> Relation2_name = FILTER Relation1_name BY (condition);

Exemple

Supposons que nous ayons un fichier nommé student_details.txt dans le répertoire HDFS /pig_data/ comme indiqué ci-dessous.

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

Et nous avons chargé ce fichier dans Pig avec le nom de la relation student_details comme indiqué ci-dessous.

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

Utilisons maintenant l'opérateur Filtre pour obtenir les coordonnées des étudiants qui appartiennent à la ville de Chennai.

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

Vérification

Vérifier la relation filter_data en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump filter_data;

Production

Il produira la sortie suivante, affichant le contenu de la relation filter_data comme suit.

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

le DISTINCT L'opérateur est utilisé pour supprimer les tuples redondants (dupliqués) d'une relation.

Syntaxe

Ci-dessous, la syntaxe du DISTINCT opérateur.

grunt> Relation_name2 = DISTINCT Relatin_name1;

Exemple

Supposons que nous ayons un fichier nommé student_details.txt dans le répertoire HDFS /pig_data/ comme indiqué ci-dessous.

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

Et nous avons chargé ce fichier dans Pig avec le nom de la relation student_details comme indiqué ci-dessous.

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

Supprimons maintenant les tuples redondants (dupliqués) de la relation nommée student_details en utilisant le DISTINCT opérateur, et stockez-le sous une autre relation nommée distinct_data comme indiqué ci-dessous.

grunt> distinct_data = DISTINCT student_details;

Vérification

Vérifier la relation distinct_data en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump distinct_data;

Production

Il produira la sortie suivante, affichant le contenu de la relation distinct_data comme suit.

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

le FOREACH L'opérateur est utilisé pour générer des transformations de données spécifiées basées sur les données de la colonne.

Syntaxe

Voici la syntaxe de FOREACH opérateur.

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

Exemple

Supposons que nous ayons un fichier nommé student_details.txt dans le répertoire HDFS /pig_data/ comme indiqué ci-dessous.

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

Et nous avons chargé ce fichier dans Pig avec le nom de la relation student_details comme indiqué ci-dessous.

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

Obtenons maintenant les valeurs d'identité, d'âge et de ville de chaque élève à partir de la relation student_details et stockez-le dans une autre relation nommée foreach_data en utilisant le foreach opérateur comme indiqué ci-dessous.

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

Vérification

Vérifier la relation foreach_data en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump foreach_data;

Production

Il produira la sortie suivante, affichant le contenu de la relation 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)

le ORDER BY L'opérateur est utilisé pour afficher le contenu d'une relation dans un ordre trié basé sur un ou plusieurs champs.

Syntaxe

Ci-dessous, la syntaxe du ORDER BY opérateur.

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

Exemple

Supposons que nous ayons un fichier nommé student_details.txt dans le répertoire HDFS /pig_data/ comme indiqué ci-dessous.

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

Et nous avons chargé ce fichier dans Pig avec le nom de la relation student_details comme indiqué ci-dessous.

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

Trions maintenant la relation dans un ordre décroissant en fonction de l'âge de l'élève et stockons-la dans une autre relation nommée order_by_data en utilisant le ORDER BY opérateur comme indiqué ci-dessous.

grunt> order_by_data = ORDER student_details BY age DESC;

Vérification

Vérifier la relation order_by_data en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump order_by_data;

Production

Il produira la sortie suivante, affichant le contenu de la relation 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)

le LIMIT L'opérateur est utilisé pour obtenir un nombre limité de tuples à partir d'une relation.

Syntaxe

Ci-dessous, la syntaxe du LIMIT opérateur.

grunt> Result = LIMIT Relation_name required number of tuples;

Exemple

Supposons que nous ayons un fichier nommé student_details.txt dans le répertoire HDFS /pig_data/ comme indiqué ci-dessous.

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

Et nous avons chargé ce fichier dans Pig avec le nom de la relation student_details comme indiqué ci-dessous.

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

Maintenant, trions la relation par ordre décroissant en fonction de l'âge de l'étudiant et stockons-la dans une autre relation nommée limit_data en utilisant le ORDER BY opérateur comme indiqué ci-dessous.

grunt> limit_data = LIMIT student_details 4;

Vérification

Vérifier la relation limit_data en utilisant le DUMP opérateur comme indiqué ci-dessous.

grunt> Dump limit_data;

Production

Il produira la sortie suivante, affichant le contenu de la relation limit_data comme suit.

(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 fournit diverses fonctions intégrées, à savoir eval, load, store, math, string, bag et tuple les fonctions.

Fonctions d'évaluation

Ci-dessous la liste des eval fonctions fournies par Apache Pig.

SN	Description de la fonction
1	AVG () Pour calculer la moyenne des valeurs numériques dans un sac.
2	BagToString () Pour concaténer les éléments d'un sac en une chaîne. Lors de la concaténation, nous pouvons placer un délimiteur entre ces valeurs (facultatif).
3	CONCAT () Pour concaténer deux ou plusieurs expressions du même type.
4	COMPTER() Pour obtenir le nombre d'éléments dans un sac, tout en comptant le nombre de tuples dans un sac.
5	COUNT_STAR () Il est similaire au COUNT()fonction. Il est utilisé pour obtenir le nombre d'éléments dans un sac.
6	DIFF () Pour comparer deux sacs (champs) dans un tuple.
sept	Est vide() Pour vérifier si un sac ou une carte est vide.
8	MAX () Pour calculer la valeur la plus élevée pour une colonne (valeurs numériques ou chararrays) dans un sac à une seule colonne.
9	MIN () Pour obtenir la valeur minimale (la plus basse) (numérique ou chararray) pour une certaine colonne dans un sac à une seule colonne.
dix	PluckTuple () Utiliser le Pig Latin PluckTuple() fonction, nous pouvons définir une chaîne Prefix et filtrer les colonnes dans une relation commençant par le préfixe donné.
11	TAILLE() Pour calculer le nombre d'éléments en fonction de n'importe quel type de données Pig.
12	SOUSTRAIRE() Pour soustraire deux sacs. Il prend deux sacs comme entrées et retourne un sac qui contient les n-uplets du premier sac qui ne sont pas dans le deuxième sac.
13	SOMME() Pour obtenir le total des valeurs numériques d'une colonne dans un sac à une seule colonne.
14	TOKENIZE () Pour fractionner une chaîne (qui contient un groupe de mots) en un seul tuple et renvoyer un sac contenant la sortie de l'opération de fractionnement.

le Load et StoreLes fonctions dans Apache Pig sont utilisées pour déterminer comment les données sont diffusées et sortent de Pig. Ces fonctions sont utilisées avec les opérateurs de chargement et de stockage. Vous trouverez ci-dessous la liste des fonctions de chargement et de stockage disponibles dans Pig.

SN	Description de la fonction
1	PigStorage () Pour charger et stocker des fichiers structurés.
2	TextLoader () Pour charger des données non structurées dans Pig.
3	BinStorage () Pour charger et stocker des données dans Pig en utilisant un format lisible par machine.
4	Gestion de la compression Dans Pig Latin, nous pouvons charger et stocker des données compressées.

Vous trouverez ci-dessous la liste des fonctions Bag et Tuple.

SN	Description de la fonction
1	TOBAG () Pour convertir deux expressions ou plus en un sac.
2	HAUT() Pour obtenir le top N tuples d'une relation.
3	TOTUPLE () Pour convertir une ou plusieurs expressions en un tuple.
4	TOMAP () Pour convertir les paires clé-valeur en une carte.

Nous avons les fonctions String suivantes dans Apache Pig.

SN	Fonctions et description
1	ENDSWITH (chaîne, testAgainst) Pour vérifier si une chaîne donnée se termine par une sous-chaîne particulière.
2	STARTSWITH (chaîne, sous-chaîne) Accepte deux paramètres de chaîne et vérifie si la première chaîne commence par la seconde.
3	SUBSTRING (chaîne, startIndex, stopIndex) Renvoie une sous-chaîne d'une chaîne donnée.
4	EqualsIgnoreCase (chaîne1, chaîne2) Pour comparer deux piqûres en ignorant le cas.
5	INDEXOF (chaîne, 'caractère', startIndex) Renvoie la première occurrence d'un caractère dans une chaîne, en recherchant en avant à partir d'un index de début.
6	LAST_INDEX_OF (expression) Renvoie l'index de la dernière occurrence d'un caractère dans une chaîne, en recherchant en arrière à partir d'un index de début.
sept	LCFIRST (expression) Convertit le premier caractère d'une chaîne en minuscules.
8	UCFIRST (expression) Renvoie une chaîne dont le premier caractère est converti en majuscules.
9	UPPER (expression) UPPER (expression) Renvoie une chaîne convertie en majuscules.
dix	INFÉRIEUR (expression) Convertit tous les caractères d'une chaîne en minuscules.
11	REMPLACER (chaîne, 'oldChar', 'newChar'); Pour remplacer les caractères existants dans une chaîne par de nouveaux caractères.
12	STRSPLIT (chaîne, expression régulière, limite) Pour diviser une chaîne autour des correspondances d'une expression régulière donnée.
13	STRSPLITTOBAG (chaîne, expression régulière, limite) Semblable à la STRSPLIT() fonction, il divise la chaîne par un délimiteur donné et renvoie le résultat dans un sac.
14	TRIM (expression) Renvoie une copie d'une chaîne avec les espaces de début et de fin supprimés.
15	LTRIM (expression) Renvoie une copie d'une chaîne avec les espaces de début supprimés.
16	RTRIM (expression) Renvoie une copie d'une chaîne avec les espaces de fin supprimés.

Apache Pig fournit les fonctions de date et d'heure suivantes -

SN	Fonctions et description
1	ToDate (millisecondes) Cette fonction renvoie un objet date-heure en fonction des paramètres donnés. Les autres alternatives pour cette fonction sont ToDate (iosstring), ToDate (userstring, format), ToDate (userstring, format, timezone)
2	Heure actuelle() renvoie l'objet date-heure de l'heure actuelle.
3	GetDay (date / heure) Renvoie le jour d'un mois à partir de l'objet date-heure.
4	GetHour (date / heure) Renvoie l'heure d'un jour à partir de l'objet date-heure.
5	GetMilliSecond (date / heure) Renvoie la milliseconde de seconde à partir de l'objet date-heure.
6	GetMinute (date / heure) Renvoie la minute d'une heure à partir de l'objet date-heure.
sept	GetMonth (date / heure) Renvoie le mois d'une année à partir de l'objet date-heure.
8	GetSecond (date / heure) Renvoie la seconde d'une minute à partir de l'objet date-heure.
9	GetWeek (date / heure) Renvoie la semaine d'une année à partir de l'objet date-heure.
dix	GetWeekYear (date / heure) Renvoie l'année de la semaine à partir de l'objet date-heure.
11	GetYear (date / heure) Renvoie l'année à partir de l'objet date-heure.
12	AddDuration (date / heure, durée) Renvoie le résultat d'un objet date-heure avec l'objet duration.
13	SubtractDuration (date / heure, durée) Soustrait l'objet Duration de l'objet Date-Time et renvoie le résultat.
14	DaysB Between (datetime1, datetime2) Renvoie le nombre de jours entre les deux objets date-heure.
15	HeuresBentre (datetime1, datetime2) Renvoie le nombre d'heures entre deux objets date-heure.
16	MilliSecondsB Between (datetime1, datetime2) Renvoie le nombre de millisecondes entre deux objets date-heure.
17	MinutesB Between (datetime1, datetime2) Renvoie le nombre de minutes entre deux objets date-heure.
18	MoisEntre (datetime1, datetime2) Renvoie le nombre de mois entre deux objets date-heure.
19	Secondes entre (datetime1, datetime2) Renvoie le nombre de secondes entre deux objets date-heure.
20	WeeksB Between (datetime1, datetime2) Renvoie le nombre de semaines entre deux objets date-heure.
21	AnnéesBentre (datetime1, datetime2) Renvoie le nombre d'années entre deux objets date-heure.

Nous avons les fonctions mathématiques suivantes dans Apache Pig -

SN	Fonctions et description
1	ABS (expression) Pour obtenir la valeur absolue d'une expression.
2	ACOS (expression) Pour obtenir l'arc cosinus d'une expression.
3	ASIN (expression) Pour obtenir l'arc sinus d'une expression.
4	ATAN (expression) Cette fonction est utilisée pour obtenir l'arc tangent d'une expression.
5	CBRT (expression) Cette fonction est utilisée pour obtenir la racine cubique d'une expression.
6	CEIL (expression) Cette fonction est utilisée pour obtenir la valeur d'une expression arrondie à l'entier supérieur le plus proche.
sept	COS (expression) Cette fonction est utilisée pour obtenir le cosinus trigonométrique d'une expression.
8	COSH (expression) Cette fonction est utilisée pour obtenir le cosinus hyperbolique d'une expression.
9	EXP (expression) Cette fonction est utilisée pour élever le nombre d'Euler e à la puissance x.
dix	FLOOR (expression) Pour obtenir la valeur d'une expression arrondie à l'entier inférieur le plus proche.
11	LOG (expression) Pour obtenir le logarithme naturel (base e) d'une expression.
12	LOG10 (expression) Pour obtenir le logarithme en base 10 d'une expression.
13	ALÉATOIRE( ) Pour obtenir un nombre pseudo aléatoire (type double) supérieur ou égal à 0,0 et inférieur à 1,0.
14	ROUND (expression) Pour obtenir la valeur d'une expression arrondie à un entier (si le type de résultat est float) ou arrondie à un long (si le type de résultat est double).
15	SIN (expression) Pour obtenir le sinus d'une expression.
16	SINH (expression) Pour obtenir le sinus hyperbolique d'une expression.
17	SQRT (expression) Pour obtenir la racine carrée positive d'une expression.
18	TAN (expression) Pour obtenir la tangente trigonométrique d'un angle.
19	TANH (expression) Pour obtenir la tangente hyperbolique d'une expression.

En plus des fonctions intégrées, Apache Pig fournit un support étendu pour User Ddéfini Ffonctions (UDF). En utilisant ces UDF, nous pouvons définir nos propres fonctions et les utiliser. Le support UDF est fourni dans six langages de programmation, à savoir, Java, Jython, Python, JavaScript, Ruby et Groovy.

Pour l'écriture d'UDF, un support complet est fourni en Java et un support limité est fourni dans toutes les langues restantes. En utilisant Java, vous pouvez écrire des UDF impliquant toutes les parties du traitement telles que le chargement / stockage de données, la transformation de colonne et l'agrégation. Depuis qu'Apache Pig a été écrit en Java, les UDF écrits en langage Java fonctionnent efficacement par rapport aux autres langages.

Dans Apache Pig, nous avons également un référentiel Java pour UDF nommé Piggybank. En utilisant Piggybank, nous pouvons accéder aux UDF Java écrits par d'autres utilisateurs et contribuer à nos propres UDF.

Types d'UDF en Java

Lors de l'écriture d'UDF en Java, nous pouvons créer et utiliser les trois types de fonctions suivants -

Filter Functions- Les fonctions de filtrage sont utilisées comme conditions dans les instructions de filtrage. Ces fonctions acceptent une valeur Pig comme entrée et renvoient une valeur booléenne.
Eval Functions- Les fonctions Eval sont utilisées dans les instructions FOREACH-GENERATE. Ces fonctions acceptent une valeur Pig comme entrée et renvoient un résultat Pig.
Algebraic Functions- Les fonctions algébriques agissent sur les sacs intérieurs dans une instruction FOREACHGENERATE. Ces fonctions sont utilisées pour effectuer des opérations MapReduce complètes sur un sac interne.

Écrire des UDF en Java

Pour écrire un UDF en Java, il faut intégrer le fichier jar Pig-0.15.0.jar. Dans cette section, nous expliquons comment écrire un exemple d'UDF à l'aide d'Eclipse. Avant de continuer, assurez-vous d'avoir installé Eclipse et Maven sur votre système.

Suivez les étapes ci-dessous pour écrire une fonction UDF -

Ouvrez Eclipse et créez un nouveau projet (disons myproject).
Convertissez le projet nouvellement créé en projet Maven.
Copiez le contenu suivant dans le pom.xml. Ce fichier contient les dépendances Maven pour les fichiers jar Apache Pig et Hadoop-core.

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

Enregistrez le fichier et actualisez-le. dans leMaven Dependencies section, vous pouvez trouver les fichiers jar téléchargés.
Créer un nouveau fichier de classe avec un nom Sample_Eval et copiez-y le contenu suivant.

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

Lors de l'écriture des UDF, il est obligatoire d'hériter de la classe EvalFunc et de fournir une implémentation à exec()fonction. Dans cette fonction, le code requis pour l'UDF est écrit. Dans l'exemple ci-dessus, nous avons renvoyé le code pour convertir le contenu de la colonne donnée en majuscules.

Après avoir compilé la classe sans erreur, cliquez avec le bouton droit sur le fichier Sample_Eval.java. Cela vous donne un menu. Sélectionnerexport comme indiqué dans la capture d'écran suivante.

En cliquant export, vous obtiendrez la fenêtre suivante. Cliquer surJAR file.

Continuez en cliquant sur Next>bouton. Vous obtiendrez une autre fenêtre dans laquelle vous devrez entrer le chemin dans le système de fichiers local, où vous devez stocker le fichier jar.

Cliquez enfin sur le Finishbouton. Dans le dossier spécifié, un fichier Jarsample_udf.jarest créé. Ce fichier jar contient l'UDF écrit en Java.

Utilisation de l'UDF

Après avoir écrit l'UDF et généré le fichier Jar, suivez les étapes ci-dessous -

Étape 1: enregistrement du fichier Jar

Après avoir écrit UDF (en Java), nous devons enregistrer le fichier Jar qui contient l'UDF à l'aide de l'opérateur Register. En enregistrant le fichier Jar, les utilisateurs peuvent intimer l'emplacement de l'UDF à Apache Pig.

Syntax

Vous trouverez ci-dessous la syntaxe de l'opérateur Register.

REGISTER path;

Example

À titre d'exemple, enregistrons le sample_udf.jar créé plus tôt dans ce chapitre.

Démarrez Apache Pig en mode local et enregistrez le fichier jar sample_udf.jar comme indiqué ci-dessous.

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

REGISTER '/$PIG_HOME/sample_udf.jar'

Note - supposez le fichier Jar dans le chemin - /$PIG_HOME/sample_udf.jar

Étape 2: définition de l'alias

Après avoir enregistré l'UDF, nous pouvons lui définir un alias en utilisant le Define opérateur.

Syntax

Vous trouverez ci-dessous la syntaxe de l'opérateur Define.

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

Example

Définissez l'alias pour sample_eval comme indiqué ci-dessous.

DEFINE sample_eval sample_eval();

Étape 3: Utilisation de l'UDF

Après avoir défini l'alias, vous pouvez utiliser l'UDF de la même manière que les fonctions intégrées. Supposons qu'il existe un fichier nommé emp_data dans le HDFS/Pig_Data/ répertoire avec le contenu suivant.

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

Et supposons que nous avons chargé ce fichier dans Pig comme indiqué ci-dessous.

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

Convertissons maintenant les noms des employés en majuscules à l'aide de l'UDF sample_eval.

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

Vérifier le contenu de la relation Upper_case comme indiqué ci-dessous.

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

Ici, dans ce chapitre, nous verrons comment exécuter des scripts Apache Pig en mode batch.

Commentaires dans Pig Script

Lors de l'écriture d'un script dans un fichier, nous pouvons y inclure des commentaires comme indiqué ci-dessous.

Commentaires sur plusieurs lignes

Nous allons commencer les commentaires sur plusieurs lignes par '/ *', les terminer par '* /'.

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

Commentaires sur une seule ligne

Nous commencerons les commentaires sur une seule ligne par «-».

--we can write single line comments like this.

Exécution de Pig Script en mode batch

Lors de l'exécution des instructions Apache Pig en mode batch, suivez les étapes ci-dessous.

Étape 1

Écrivez toutes les instructions Pig Latin requises dans un seul fichier. Nous pouvons écrire toutes les instructions et commandes Pig Latin dans un seul fichier et l'enregistrer sous.pig fichier.

Étape 2

Exécutez le script Apache Pig. Vous pouvez exécuter le script Pig à partir du shell (Linux) comme indiqué ci-dessous.

Mode local	Mode MapReduce
$ cochon -x local Sample_script.pig	$ cochon -x mapreduce Sample_script.pig

Vous pouvez également l'exécuter à partir du shell Grunt en utilisant la commande exec comme indiqué ci-dessous.

grunt> exec /sample_script.pig

Exécution d'un script Pig à partir de HDFS

Nous pouvons également exécuter un script Pig qui réside dans le HDFS. Supposons qu'il existe un script Pig avec le nomSample_script.pig dans le répertoire HDFS nommé /pig_data/. Nous pouvons l'exécuter comme indiqué ci-dessous.

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

Exemple

Supposons que nous ayons un fichier student_details.txt en HDFS avec le contenu suivant.

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

Nous avons également un exemple de script avec le nom sample_script.pig, dans le même répertoire HDFS. Ce fichier contient des instructions effectuant des opérations et des transformations sur lestudent relation, comme indiqué ci-dessous.

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;

La première instruction du script chargera les données dans le fichier nommé student_details.txt comme une relation nommée student.
La deuxième instruction du script organisera les tuples de la relation dans l'ordre décroissant, en fonction de l'âge, et le stockera comme student_order.
La troisième instruction du script stockera les 4 premiers tuples de student_order comme student_limit.
Enfin, la quatrième instruction videra le contenu de la relation student_limit.

Exécutons maintenant le sample_script.pig comme indiqué ci-dessous.

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

Apache Pig est exécuté et vous donne la sortie avec le contenu suivant.

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