hadoop / big data -...

MBDS 2017 - 2018

Hadoop / Big Data

Benjamin Renaut <[email protected]>

HDFS et bases de données relationnelles8

8-1

Présentation● On a présenté Sqoop, un outil polyvalent qui permet d'importer ou d'exporter

des données entre HDFS et les bases de données « classiques » (Oracle, MySQL, PostgreSQL, etc...).

● Sqoop est extrêmement utile pour faire des échanges entre les bases de données et HDFS. Il s'agit cependant d'un outil utilisé pour des échanges de données ponctuels: on s'en servira par exemple pour effectuer des traitements Hadoop sur les données de la base toutes les nuits, ou encore toutes les N minutes, etc... en ré-important éventuellement les données dans la base après traitement.

● Il y a cependant des cas d'utilisation où on souhaite pouvoir échanger des données entre une base de données et la couche HDFS en temps réel. Par exemple, on pourrait avoir des retours statistiques sur un large réseau social depuis un backend centralisé, dont les données nécessitent des traitements massifs par le biais de Hadoop.

8-2

Les connecteurs

● On pourrait imaginer utiliser un outil comme Sqoop de manière continue, en lançant en permanence la même tâche Sqoop. Cependant, pendant que la tâche s'exécute, de nouvelles données peuvent apparaître; par ailleurs, la charge appliquée au SGBD serait conséquente et provoquerait de potentiels problèmes d’accès aux bases (LOCK des tables).

● Pour répondre à ce problème, la plupart des bases de données largement utilisées ont développé des points d'intégration entre les SDBG et HDFS. On désigne souvent ces points d'intégration en parlant de connecteurs Hadoop. On voit également les termes applier ou encore bridges.

● Ces connecteurs ont tous en commun la capacité d'écrire sur HDFS les données de la base en permanence, au fur et à mesure. Parfois, ils sont aussi capables de répliquer des modifications faites sur HDFS dans la base de données.

8-3

MySQL applier for Hadoop● Dans le cas de MySQL, le connecteur est le MySQL applier for Hadoop

d'Oracle.

● Il fonctionne en tirant partie des binary logs de MySQL – les logs binaires que MySQL peut générer (si activé) en permanence et qui indiquent toutes les modifications faites sur la base de données. Ce sont ces mêmes binary logs qui sont utilisés pour les mécanismes de réplication MySQL classiques (entre nœuds MySQL).

● Le connecteur génère un répertoire par base de données sur HDFS. A l'intérieur de ce répertoire, il créé un répertoire différent par table présente dans la base de données. Enfin, à l'intérieur de ces répertoires, il génère des séries de fichiers contenant les données de la table concernée.

● Le format des fichiers est configurable: format texte ou format binaire sequence files (les mêmes que ceux vus avec Sqoop).

8-4

MySQL applier for Hadoop

(source: documentation MySQL)

8-5

MySQL applier for Hadoop

(source: documentation MySQL)

8-6

Oracle SQL connector for HDFS● Dans le cas de Oracle, le connecteur est le Oracle SQL connector for HDFS.

● Il est sensiblement plus puissant que le connecteur de MySQL; notamment, il est capable de lire des données depuis HDFS qui ont été générées par des programmes Hadoop. Il fonctionne en utilisant le mécanisme des tables externes Oracle: des « tables » virtuelles Oracles qui désignent en réalité des données situées en dehors du SGBD.

● Pour connecter des dossiers ou fichiers HDFS à Oracle, il suffit de créer ces tables externes en définissant un schéma de données bien précis (comme pour une table classique). Ce schéma correspond à un format de données situé sur HDFS.Il est même possible d'effectuer des jointures entre des tables Oracle « classiques » et des tables virtuelles qui correspondent à des données sur HDFS.

8-7

Oracle SQL connector for HDFS

● Le connecteur Oracle est capable de stocker les données sous HDFS dans deux formats principaux: un format texte, similaire au format texte utilisé dans Sqoop et le connecteur MySQL et humainement lisible, ou un format binaire.Le format binaire en question n'est pas celui des sequences files vu précédemment, mais un format propre à Oracle et désigné sous le terme de data dumps.

● Oracle fourni par ailleurs des APIs Java nécessaires pour accéder simplement et rapidement aux données stockées dans ce format – de la même manière que pour des Sequence Files.Ces APIs définissent notamment des classes Input/OutputFormat Hadoop, de la même manière que – par exemple – la classe Hadoop SequenceFileInputFormat vue en TP.On peut donc se servir de ces classes comme d'un format d'entrée pour une tâche Hadoop, ou d'un format de sortie, toujours sur HDFS.

8-8

Autres connecteurs et modèles● Il existe de nombreux autres connecteurs permettant l'accés à des données

situées dans une base de données depuis Hadoop – certains propriétaires et commerciaux, d'autres Open Source et librement disponibles.

● D'autres connecteurs évitent complètement HDFS – Hadoop va alors récupérer ses données dans le SGBD directement lors de l'exécution d'une tâche. Il suffit au programmeur d'utiliser une autre API pour préciser à Hadoop la source de ses données.

● Exemple: VoltDB. Il s'agit d'un SGBD Open Source innovant qui utilise un stocke ses données en mémoire vive (un peu comme le moteur MEMORY de MySQL), de manière distribuée et répliquée, et constitue ainsi une alternative à HDFS. Il propose des APIs Java pour l'accés aux données depuis Hadoop, et offre ainsi l'avantage de pouvoir directement s'intégrer à Hadoop et venir « remplacer » HDFS.

Apache Pig9

9-1

Présentation

● Pig est un autre outil associé à Hadoop – au même titre que Sqoop.

● Son but est de permettre de développer facilement et rapidement des programmes map/reduce, sans avoir à développer en Java. Sa syntaxe se rapproche du langage SQL et il est notamment utile pour les programmeurs peu familiers avec Java ou qui souhaitent simplement expérimenter avec la méthodologie map/reduce ou Hadoop en général rapidement.

● A l'origine (2006) un projet développé en interne au départementR&D de Yahoo, il est depuis 2007 un projet de la fondationApache.

● Le langage de programmation de Pig est appelé Pig Latin.

9-2

Utilisation

● Pig fonctionne comme un interpréteur de scripts – exactement comme Python.Il suffit d'écrire un script Pig, de l'exécuter avec l'interpréteur (le programme en ligne de commande pig), et il exécutera le script dans l'environnement Hadoop. Pour exécuter un script Pig Latin sur Hadoop, on utilisera la commande:

pig -x mapreduce fichier.pig

● Il est également possible de l'exécuter en mode local. Dans ce mode, Pig ignore complètement Hadoop et HDFS: il chargera ses fichiers depuis le disque local, et stockera ses résultats au même endroit. Pour ce faire, on utilise la commande:

pig -x local fichier.pig

9-3

Utilisation

● Enfin – et toujours comme Python – il peut également s'utiliser en mode interactif, où on tape ses instructions Pig Latin dans une invite de commande. Pour ce faire, il suffit de le lancer avec la commande:

pig

Dans ce mode, il détectera automatiquement si oui ou non Hadoop est présent et se placera dans le mode d'exécution qui correspond (on peut également forcer le mode à utiliser, toujours avec l'option -x).Par exemple:

pig -x local

ou encore:pig -x mapreduce

9-4

Fonctionnement

● Pig constitue une couche d'abstraction au dessus de Hadoop. Un script écrit en Pig Latin est converti en une ou plusieurs tâches map/reduce exécutées sur Hadoop.

● Tout programme Pig est constitué a minima des étapes suivantes:

● Chargement des données (LOAD).● Transformations/traitements sur les données.● Sauvegarde des résultats (DUMP/STORE).

● Ces trois étapes sont toutes parallélisées par le biais de tâches map/reduce.

9-5

Syntaxe

● Chaque ligne d'un script PIG doit être terminée par un point-virgule ';'.

● Il est possible de commenter le code avec la syntaxe multi-lignes:

/* Ceci est un commentaire sur plusieurs lignes. */

(issue du C)… ou avec la syntaxe sur une ligne:

LOAD... -- Ceci est un commentaire sur une ligne.

(issue de SQL)

9-6

Types

● Pig supporte les types de données usuels suivants:

● int – un entier sur 32 bits.● long – un entier sur 64 bits.

● float – un flottant sur 32 bits.● double – un flottant sur 64 bits.

● chararray – une chaîne de caractères UTF-8.● bytearray – une chaîne binaire.

● boolean – un booléen (true/false).

9-7

Types

● Pig supporte également les trois types complexes suivants:

● tuple: une série de données. Par exemple:(12, John, 5.3)

● bag: un ensemble de tuples. Par exemple:{(12, John, 5.3), (8), (3.5, TRUE, Bob, 42)}

● map: une série de couples (clef;valeur). Par exemple:[qui#22, le#3](ici avec deux couples clef;valeur)

Au sein d'un type map, chaque clef doit être unique.

9-8

Types

● Un tuple peut tout à fait contenir d'autres tuples, ou encore des bags, ou autres types simples et complexes.

● Par exemple:

({(1, 2), (3, John)}, 3, [qui#23])

Ce tuple contient trois membres:

● Un bag contenant lui-même trois tuples.● Un entier de valeur 3.● Un map contenant un seul couple (clef;valeur).

9-9

Chargement des données

● Les données d'entrée d'un programme pig seront typiquement chargées au sein d'un bag.

● Pour charger des données depuis le système de fichier (HDFS en mode mapreduce ou système de fichiers local en mode local), on utilise la commande LOAD.

● Synopsis:

LOAD 'source' [USING fonction] [AS schemas]

… où source est le nom du/des fichier(s) ou répertoire(s), fonction le nom d'une fonction d'importation, et schemas un descriptif du format des données importées.

9-10


● Les paramètres fonction et schemas sont optionnels.

● Le paramètre source peut être:

● Un fichier unique, par exemple « poeme.txt ».● Un répertoire (chargera tous les fichiers du répertoire), par exemple

« data_input ».● Une expression complexe au même format que celles comprises par

Hadoop/HDFS, par exemple:

● « data_input/input-1-* »

9-11


● C'est le paramètre fonction qui permet d'indiquer la manière de charger/segmenter les données d'une manière cohérente.

● Le paramètre désigne une classe Java en charge d'interpréter les données depuis le système de fichier et d'en sortir des types Pig cohérents (tuples / bag / map).

● Pig offre une série de fonctions déjà disponibles pour simplifier la vie du programmeur. La plus couramment utilisée est la fonction PigStorage. Sa syntaxe:

PigStorage("SEPARATEUR")

9-13


● Si on exécute la ligne:

A = LOAD 'etudiants.txt' USING PigStorage('|');

… alors A contiendra le bag de tuples suivant:

(ADAM,Guillaume,15)(BERCHANE,Rachid,18)(BOULLAIRE,Alexandre,16)(BOYER,Raphael,17)(CHAMPOUSSIN,Luca,14)(CODA,Stephen,15)

(avec trois champs texte, texte et entier par tuple)

9-15


● La fonction de chargement PigStorage permet ainsi facilement de charger un fichier textuel avec des délimiteurs.

● Comme indiqué précédemment, le paramètre fonction est optionnel. Si on n'indique pas de fonction, alors la fonction utilisée est PigStorage, avec un séparateur correspondant à une tabulation.

● Ainsi, imaginons que notre fichier d'entrée « etudiants.txt » ait le format suivant:

(où [TAB] dénote unetabulation)

ADAM[TAB]Guillaume[TAB]15BERCHANE[TAB]Rachid[TAB]18BOULLAIRE[TAB]Alexandre[TAB]16BOYER[TAB]Raphael[TAB]17CHAMPOUSSIN[TAB]Luca[TAB]14CODA[TAB]Stephen[TAB]15

ADAM[TAB]Guillaume[TAB]15BERCHANE[TAB]Rachid[TAB]18BOULLAIRE[TAB]Alexandre[TAB]16BOYER[TAB]Raphael[TAB]17CHAMPOUSSIN[TAB]Luca[TAB]14CODA[TAB]Stephen[TAB]15

9-16


● Si on exécute:

A = LOAD 'etudiants.txt';


(ADAM,Guillaume,15)(BERCHANE,Rachid,18)(BOULLAIRE,Alexandre,16)(BOYER,Raphael,17)(CHAMPOUSSIN,Luca,14)(CODA,Stephen,15)

(avec trois champs texte, texte et entier par tuple)

9-17


● Il existe d'autres fonctions « standard » de chargement mises à disposition par Pig, parmi lesquelles:

● TextLoader: aucun paramètre, charge simplement chaque ligne de texte comme un tuple avec un seul champs – la ligne elle-même.

● JsonLoader: permet de charger un fichier JSON de manière structurée. Un argument, indiquant le format du JSON à charger.

● AvroLoader: permet de charger un fichier binaire AVRO – un des formats supportés par Sqoop ! Un argument également.… et d'autres …

● Il est également possible de développer sa propre fonction de chargement (sous la forme d'une classe Java compilée en .jar).

9-18

Chargement des données - Schémas

● Par défaut, une fois le bag des données d'entrée chargé, on pourra se référer à différents membres de chaque tuple en utilisant la syntaxe:$0, $1, $2, etc.… pour référencer le premier, second, troisième, etc. membre de chaque tuple.

● Par exemple, si on a chargé les données suivantes dans A:

(ADAM,Guillaume,15)(BERCHANE,Rachid,18)(BOULLAIRE,Alexandre,16)

… alors l'expression « A.$2 » designera la note (15, 18, …); de même, l'expression « A.$0 » désignera le nom de famille (ADAM, …).

9-19


● Le troisième argument optionnel de LOAD, schemas, permet de:

● Donner un nom aux champs des tuples chargés.● Leur attribuer un type de données explicite.● Spécifier un type de chargement différent (autre qu'un simple bag de

tuples).

● La syntaxe:

(NOM1:TYPE1, NOM2:TYPE2,NOM3:TYPE3…)

Le type est optionnel.

9-20


● Par exemple, avec les données d'entrée « in.txt »:

● Si on fait:

A = LOAD 'in.txt' USING PigStorage('|') AS (nom, prenom, note);

Alors on pourra se référer par exemple à la note plus loin par le biais de la syntaxe « A.note ».



9-21


● On pourrait également forcer le type de la note par le biais de:

A = LOAD 'in.txt' USING PigStorage('|') AS (nom, prenom, note:float);

… et si on exécute par exemple:

A = LOAD 'in.txt' USING PigStorage('|') AS (nom, prenom:int, note:float);

… alors le champs « prenom » de notre fichier d'entrée ne sera pas chargé (valeur vide), puisque Pig tente de l'interpréter comme un type int et qu'il s'agit d'une chaîne de caractères dans les données d'entrée.

9-22


● Un exemple plus complexe. Données d'entrée « in.txt »:

● Si on fait:

A = LOAD 'in.txt' Using PigStorage('|') AS \(infos:tuple(nom,prenom),notes:tuple(n1,n2,n3));

Alors les données obtenues auront la forme:

(ADAM,Guillaume)|(15,15,12)(BERCHANE,Rachid)|(18,15,20)(BOULLAIRE,Alexandre)|(16,11,18)

(ADAM,Guillaume)|(15,15,12)(BERCHANE,Rachid)|(18,15,20)(BOULLAIRE,Alexandre)|(16,11,18)

((ADAM,Guillaume),(15,15,12))((BERCHANE,Rachid),(18,15,20))((BOULLAIRE,Alexandre),(16,11,18))

((ADAM,Guillaume),(15,15,12))((BERCHANE,Rachid),(18,15,20))((BOULLAIRE,Alexandre),(16,11,18))

9-23


● Dans l'exemple précédent, en délimitant au sein du fichier source les données sous la forme de deux champs « tuples », on a pu indiquer à PigStorage lors du chargement qu'on souhaitait qu'ils soient chargés sous cette forme.

● On pourra alors se référer par exemple à « A.infos.prenom », ou encore « A.notes.n1 », etc.

● Il faut évidemment que la fonction de chargement supporte ce type de schémas plus complexes.

● Il est recommander de toujours explicitement définir un schéma de chargement avec tous les types et noms définis; ceci d'une part pour la lisibilité, d'autre part pour assurer la cohérence dans le type des données d'entrée.

9-24

Commande DESCRIBE

● On peut à tout moment obtenir (au sein du shell interactif) une description de la composition d'un container par le biais de la commande describe.

● Par exemple:

A = LOAD 'in.txt' Using PigStorage('|') AS \(infos:tuple(nom,prenom),notes:tuple(n1,n2,n3));DESCRIBE A;

● Donnera à l'écran:

A: {infos: (nom: bytearray,prenom: bytearray),notes: (n1: bytearray,n2: bytearray,n3: bytearray)}

… c'est notamment utile lors de la rédaction/test d'un programme Pig.

9-25

Sauvegarde de données – DUMP

● Deux commandes principales existent pour extraire des données depuis Pig.

● La première est la commande DUMP. Syntaxe:

DUMP <nom du container>;

Par exemple:

DUMP A;

● Elle ne sauvegarde pas les données sur le système de fichier mais se contente de les afficher à l'écran. Elle est utile lors de l'utilisation de Pig en mode interactif. Les sorties affichées plus haut (résultats de LOAD) au sein de ce cours sont directement issues de la commande DUMP.

9-26

Sauvegarde de données – STORE

● La seconde est la commande STORE, qui sauve véritablement des données au sein du système de fichier (HDFS ou local selon le mode).

● Sa syntaxe:

STORE alias INTO 'repertoire' [USING fonction];

● alias représente le container à sauvegarder (par exemple « A »).

● Comme les données sont issues d'une tâche map/reduce, elles seront stockées sous la forme de plusieurs fichiers « part-r-* ». En conséquence, repertoire indique le répertoire dans lequel on souhaite que la série de fichiers résultants de la tâche/du stockage soient écrits.

9-27

Sauvegarde de données – STORE

● Là aussi, on peut spécifier une fonction indiquant la manière de formater les données. Les mêmes fonctions que celles vu précédemment sont utilisables (PigStorage, JsonStorage, AvroStorage… mais pas par exemple TextLoader). fonction est ici aussi optionnel; là aussi, si on ne précise pas de fonction, c'est PigStorage('\t') qui est utilisée.

● STORE ne supporte pas de schéma; à la place, si un schéma est nécessaire (par exemple pour du json), c'est généralement le paramètre de la fonction de stockage qui est utilisé.

● Dans le cas du JSON, par défaut, Pig utilisera les noms de colonnes directement issues du schéma de l'alias concerné; il stocke par ailleurs le schéma sous la forme d'un fichier .pig_schema dans le répertoire. Si on recharge les données avec un JsonStorage, le schéma sera automatiquement importé par la fonction.

9-28

Sauvegarde de données – Exemples

● Fichier d'entrée « in.txt »:

● Chargé dans l'alias A avec:

A = LOAD 'in.txt' USING PigStorage('|') \ AS (nom:chararray, prenom:chararray, note:float);

● Sortie de:

DUMP A;

ADAM|Guillaume|15BERCHANE|Rachid|18BOULLAIRE|Alexandre|16BOYER|Raphael|17

ADAM|Guillaume|15BERCHANE|Rachid|18BOULLAIRE|Alexandre|16BOYER|Raphael|17

(ADAM,Guillaume,15)(BERCHANE,Rachid,18)(BOULLAIRE,Alexandre,16)(BOYER,Raphael,17)

(ADAM,Guillaume,15)(BERCHANE,Rachid,18)(BOULLAIRE,Alexandre,16)(BOYER,Raphael,17)

A: {nom:chararray,prenom:chararray,note:float}A: {nom:chararray,prenom:chararray,note:float}

DESCRIBE A;

9-29


● Si on utilise:

STORE A INTO 'results' USING PigStorage(',');

Un répertoire « results/ » sera créé, contenant ici un fichier unique part-r-00000 avec pour contenu:

● Si les données avaient été plus conséquentes, on aurait pu avoir de nombreux fichiers part-r-00000, part-r-00001, etc.

ADAM,Guillaume,15BERCHANE,Rachid,18BOULLAIRE,Alexandre,16BOYER,Raphael,17

ADAM,Guillaume,15BERCHANE,Rachid,18BOULLAIRE,Alexandre,16BOYER,Raphael,17

9-30


● Si on utilise:

STORE A INTO 'results' USING JsonStorage();

Un répertoire « results/ » sera créé, contenant ici un fichier unique part-r-00000 avec pour contenu:

● Par ailleurs, Pig a également créé un fichier .pig_schema; si on recharge plus tard les données avec JsonLoader (le pendant « chargement » de JsonStorage), le schéma sera automatiquement déduit.

{"nom":"ADAM","prenom":"Guillaume","note":15.0}{"nom":"BERCHANE","prenom":"Rachid","note":18.0}{"nom":"BOULLAIRE","prenom":"Alexandre","note":16.0}{"nom":"BOYER","prenom":"Raphael","note":17.0}

{"nom":"ADAM","prenom":"Guillaume","note":15.0}{"nom":"BERCHANE","prenom":"Rachid","note":18.0}{"nom":"BOULLAIRE","prenom":"Alexandre","note":16.0}{"nom":"BOYER","prenom":"Raphael","note":17.0}

9-31

Autres commandes utiles – cat

● Le shell interactif de Pig offre quelques commandes pratiques pour le développeur.

● L'une de ces commandes est cat: comme la commande « cat » Unix, elle affiche le contenu d'un fichier.

● En revanche, dans le cadre de Pig, elle est étendue au fonctionnement Hadoop; si on fait:

cat [REPERTOIRE]

… la commande affichera automatiquement le contenu concaténé de tous les fichiers du répertoire (utile pour vérifier un ensemble de données d'entrée/de sortie).

9-32

Autres commandes utiles

● Autres commandes uniquement disponibles en mode interactif:

● help: affiche une aide.

● sh [COMMANDE]: exécute une commande shell.

● exec [FICHIER.PIG]: exécute le script pig indiqué.

● history: affiche un historique de toutes les commandes utilisées.

● ls, mkdir, rm, etc. : équivalentes à leur pendant Unix.

… et d'autres (consulter la documentation).

9-33

Traitement des données

● On a vu jusqu'ici comment charger des données depuis le système de fichiers local/HDFS au sein d'un alias Pig, et comment sauvegarder un alias au sein du système de fichier ou simplement l'afficher à l'écran en mode interfactif (DUMP).

● On va maintenant voir comment manipuler les données, c'est à dire effectuer un traitement sur nos données d'entrée.

● Toutes les fonctions et opérateurs de Pig ne sont pas décrites ici; seule une sélection large mais non exhaustive est décrite; se référer à la documentation de Pig pour plus d'informations.

9-34

Opérateur FILTER

● L'opérateur FILTER permet de filtrer les éléments d'un alias selon une ou plusieurs conditions.

● Syntaxe:

DEST = FILTER SOURCE BY EXPRESSION;

Il s'agit grosso modo d'un équivalent au WHERE de SQL.On pourra ainsi faire par exemple:

B = FILTER A BY note > 10;

Ou encore:

B = FILTER A BY note > 10 AND ((annee_naissance+age)<2014);

9-35

Opérateur ORDER

● L'opérateur ORDER permet de trier les éléments selon une condition. C'est l'équivalent du ORDER BY de SQL.

● Syntaxe:

DEST = ORDER SOURCE BY FIELD [ASC|DESC];

On pourra ainsi faire par exemple:

B = ORDER A BY note DESC;

Ou encore:

B = ORDER A BY note DESC, nom ASC;

9-36

Opérateur GROUP

● L'opérateur GROUP permet de grouper les tuples selon un champs.

● Il génère des tuples constitués de deux champs:

● Le premier, nommé « group », est un champs simple, contenant la valeur unique du champs utilisé lors de l'appel à GROUP.

● Le second, qui porte le nom de l'alias sur lequel a été appliqué GROUP, est un bag qui contient une série de tuples: tous ceux pour lesquels la valeur en question a été rencontrée.

● Syntaxe:

DEST = GROUP SOURCE BY FIELD;

9-37

Opérateur GROUP

● Par exemple:

● On exécute: B = GROUP A BY note;

Et on obtient:

ADAM,Guillaume,15BERCHANE,Rachid,15BOULLAIRE,Alexandre,16




DUMP A;

(15,{(BERCHANE,Rachid,15),(ADAM,Guillaume,15)})(16,{(BOULLAIRE,Alexandre,16)})(15,{(BERCHANE,Rachid,15),(ADAM,Guillaume,15)})(16,{(BOULLAIRE,Alexandre,16)})

DUMP B;

DESCRIBE B ;

B: {group:float,A:{(nom:chararray,prenom:chararray,note:float)}}B: {group:float,A:{(nom:chararray,prenom:chararray,note:float)}}

9-38

Opérateur FOREACH… GENERATE

● L'opérateur FOREACH … GENERATE permet d'itérer chacun des tuples du bag de l'alias concerné, et de générer d'autres tuples pour chacun d'entre eux.

● Syntaxe:

DEST = FOREACH SOURCE GENERATE EXPRESSION;

● Au sein de l'expression, on peut générer des bags, des tuples, des maps, etc. et appeler des fonctions à la volée.

● On peut également nommer des champs générés de cette manière au sein de l'appel à GENERATE.

9-39


● Par exemple:

● On exécute: B = FOREACH A GENERATE note;

Et on obtient:





DUMP A;

(15)(15)(16)

(15)(15)(16)

DUMP B;

B: {note: float}B: {note: float}

DESCRIBE B;

9-40


● Par exemple:

● On exécute: B = FOREACH A GENERATE (nom,prenom) AS infos, note;

Et on obtient:





DUMP A;

((ADAM,Guillaume),15.0)((BERCHANE,Rachid),15.0)((BOULLAIRE,Alexandre),16.0)

((ADAM,Guillaume),15.0)((BERCHANE,Rachid),15.0)((BOULLAIRE,Alexandre),16.0)

DUMP B;

B: {infos: (nom: chararray,prenom: chararray),note: float}B: {infos: (nom: chararray,prenom: chararray),note: float}

DESCRIBE B;

9-40


● Il est également possible d'imbriquer des traitement plus complexe au sein de cet opérateur, par exemple pour effectuer des traitements sur les tuples d'un bag. La syntaxe:

DEST = FOREACH SOURCE { OPERATION_1; OPERATION_2; … etc …};

● Imaginons par exemple qu'on ait des données sous la forme:

A: {infos: (nom: bytearray,prenom: bytearray), \notes: (n1: bytearray,n2: bytearray,n3: bytearray)}A: {infos: (nom: bytearray,prenom: bytearray), \notes: (n1: bytearray,n2: bytearray,n3: bytearray)}

9-40


… on pourrait alors faire:

B = FOREACH A { C = (notes.n1+notes.n2+notes.n3)/3.0; GENERATE infos,C as moyenne;};

Pour générer la moyenne des notes tout en conservant les noms & prénoms des élèves contenus dans l'alias A.

9-41

Opérateur FLATTEN

● L'opérateur FLATTEN permet de « déplier » un ensemble tuples et bags pour les transformer en de simples tuples.

● Par exemple, si on a une liste de tuples dans un alias B au format suivant:

● Et qu'on exécute:

C = FOREACH B GENERATE FLATTEN(A);

(15,{(BERCHANE,Rachid,15),(ADAM,Guillaume,15)})(16,{(BOULLAIRE,Alexandre,16)})(15,{(BERCHANE,Rachid,15),(ADAM,Guillaume,15)})(16,{(BOULLAIRE,Alexandre,16)})

B: {group:float,A:{(nom:chararray,prenom:chararray,note:float)}}B: {group:float,A:{(nom:chararray,prenom:chararray,note:float)}}

9-42

Opérateur FLATTEN

● … on obtiendra:

(BERCHANE,Rachid,15.0)(ADAM,Guillaume,15.0)(BOULLAIRE,Alexandre,16.0)

(BERCHANE,Rachid,15.0)(ADAM,Guillaume,15.0)(BOULLAIRE,Alexandre,16.0)

9-43

Autres opérateurs

● Il existe divers autres opérateurs utiles dans Pig:

● LIMIT: récupérer les N premiers tuples d'un alias.● SPLIT: générer plusieurs alias à partir d'un alias; selon des expressions

conditionnelles.● CROSS: mélanger les tuples de deux alias.● DISTINCT: éliminer les tuples identiques au sein d'un alias.● SAMPLE: obtenir une sous-sélection aléatoire de tuples depuis un alias (par

exemple, récupérer 10% des tuples d'un alias de manière aléatoire).

… et d'autres (se référer à la documentation officielle de Pig pour plus d'informations).

9-44

Fonctions – Chaînes de caractères

● Pig propose, en standard, de nombreuses fonctions pour la manipulation des types chaîne de caractère.

● Quelques exemples:

● TOKENIZE: découpe les différents mots d'une ligne. Génère un bag contenant un tuple pour chacun des mots.Par exemple, A:

B = FOREACH A GENERATE TOKENIZE($0);

● DUMP B:

("exemple de phrase")("autre exemple")("exemple de phrase")("autre exemple")

({("exemple"), ("de"), ("phrase")})({("autre"),("exemple")})({("exemple"), ("de"), ("phrase")})({("autre"),("exemple")})

9-45

Fonctions – Chaînes de caractères

● SIZE: renvoie la taille d'une chaîne de caractères.

● SUBSTRING: permet de récupérer une sous-chaîne de caractères.

● STRSPLIT: permet de découper une chaîne de caractères à partir d'une expression régulière.

● LOWER: converti une chaîne en minuscules.

● REPLACE: remplacement dans une chaîne (supporte là aussi les regexp).

… et d'autres (là aussi, consulter la documentation).

9-46

Fonctions – Mathématiques

● De même, Pig propose un certain nombre de fonction pour la manipulation des nombres.

● Quelques exemples:

● ABS: renvoie la valeur absolue d'un nombre.

● COS/SIN/TAN: cosinus/sinus/tangente.

● RANDOM: génère un flottant aléatoire entre 0 et 1.

● ROUND: génère l'arrondi d'un nombre.

… et d'autres (même remarque).

9-47

Fonctions – Autres

● Pig propose enfin quelques autres fonctions utiles:

● COUNT(bag): renvoie le nombre de tuples contenus au sein d'un bag.

● CONCAT(f1, f2, f3, …): concatène une série de champs d'un tuple. Supporte la concaténation des nombres (leur représentation textuelle).

● SUBSTRACT(b1, b2): renvoie un bag constitué des éléments présents dans le bag b1 mais absents du bag b2.

● SUM(bag): renvoie la somme des éléments numériques contenus au sein d'un bag.

… et d'autres (même remarques).

9-48

Exemple – Compteur de mots, version Pig

● On reprend l'exemple précédent du compteur d'occurences de mots.

● Les données d'entrée, au sein d'un fichier poeme.txt:

● On commence par charger les données:

A = LOAD 'poeme.txt' USING TextLoader AS ligne:chararray;

Celui qui croyait au cielCelui qui ny croyait pasTous deux adoraient la bellePrisonniere des soldats

Celui qui croyait au cielCelui qui ny croyait pasTous deux adoraient la bellePrisonniere des soldats

9-49


● Aprés chargement:

DUMP A:

● DESCRIBE A:

(Celui qui croyait au ciel)(Celui qui ny croyait pas)(Tous deux adoraient la belle)(Prisonniere des soldats)

(Celui qui croyait au ciel)(Celui qui ny croyait pas)(Tous deux adoraient la belle)(Prisonniere des soldats)

A: {ligne: chararray}A: {ligne: chararray}

9-50


● On exécute ensuite:

B = FOREACH A GENERATE TOKENIZE(LOWER(ligne)) AS mots;

… ce qui aura pour effet, pour chaque ligne, de la convertir en minuscules, puis de générer un bag de tuples: un pour chacun des mots de la ligne en minuscules (fonction TOKENIZE).

● On donne également un nom au bag en question: « mots ».

9-51


● Aprés exécution:

DUMP B:

● DESCRIBE B:

({(celui),(qui),(croyait),(au),(ciel)})({(celui),(qui),(ny),(croyait),(pas)})({(tous),(deux),(adoraient),(la),(belle)})({(prisonniere),(des),(soldats)})

({(celui),(qui),(croyait),(au),(ciel)})({(celui),(qui),(ny),(croyait),(pas)})({(tous),(deux),(adoraient),(la),(belle)})({(prisonniere),(des),(soldats)})

B: {mots: {tuple_of_tokens: (token: chararray)}}B: {mots: {tuple_of_tokens: (token: chararray)}}

9-52



C = FOREACH B GENERATE FLATTEN(mots) AS mot;

… ce qui aura pour effet, pour chaque tuple, de « déplier » le bag contenant chacun des mots et de générer pour chacun des tuples contenu dans ce bag un tuple indépendant.

● On donne également un nom à ces tuples désormais indépendants: « mot ».

9-53



DUMP C:

(celui)(qui)(croyait)(au)(ciel)(celui)(qui)(ny)(croyait)(pas)(tous)...

(celui)(qui)(croyait)(au)(ciel)(celui)(qui)(ny)(croyait)(pas)(tous)...

C: {mot: chararray}C: {mot: chararray}

DESCRIBE C:

9-54



D = GROUP C BY mot;

… ce qui aura pour effet de regrouper les tuples par mot commun.

● On rappelle que l'opérateur GROUP va générer un tuple constitué d'un premier membre « group » qui contient le mot unique en question, et d'un second membre « C » de type bag qui contient tous les tuples correspondant à cette valeur.

9-55



DUMP D: (au,{(au)})(la,{(la)})(ny,{(ny)})(qui,{(qui),(qui)})(tous,{(tous)})(belle,{(belle)})(celui,{(celui),(celui)})(croyait,{(croyait),(croyait)})...

(au,{(au)})(la,{(la)})(ny,{(ny)})(qui,{(qui),(qui)})(tous,{(tous)})(belle,{(belle)})(celui,{(celui),(celui)})(croyait,{(croyait),(croyait)})...

D: {group: chararray,C: {(mot: chararray)}}D: {group: chararray,C: {(mot: chararray)}}

DESCRIBE D:

9-56


● On exécute enfin:

E = FOREACH D GENERATE group AS mot, COUNT(C) as occurrences;

… ce qui aura pour effet de parcourir l'alias D et, pour chaque tuple, de récupérer le premier membre « group » et le nombre de tuples du second membre de type bag « C ».

● On génère un nouveau tuple à partir de ces deux informations: on donne au premier champs le nom « mot », et au second le nom « occurences ».

9-57



DUMP E: (au,1)(la,1)(qui,2)(belle,1)(celui,2)(croyait,2)(soldats,1)(prisonniere,1)...

(au,1)(la,1)(qui,2)(belle,1)(celui,2)(croyait,2)(soldats,1)(prisonniere,1)...

E: {mot: chararray,occurrences: long}E: {mot: chararray,occurrences: long}

DESCRIBE D:

9-58


● Il reste enfin à sauvegarder les données:

STORE E INTO '/results';

● Puisqu'on ne précise pas de fonction de stockage, Pig utilisera par défaut PigStorage('\'): il devrait écrire chacun des tuple sur une ligne textuelle, en séparant chacun des champs par une tabulation.

● La méthode générera un répertoire /results (sur HDFS ou le système de fichiers local), qui contiendra une série de fichier part-r-XXXXX, contenant les différents tuples de E.

9-59


● Contenu du fichier /results/part-r-00000: au 1la 1ny 1des 1pas 1qui 2ciel 1deux 1tous 1belle 1celui 2croyait 2soldats 1adoraient 1prisonniere 1

au 1la 1ny 1des 1pas 1qui 2ciel 1deux 1tous 1belle 1celui 2croyait 2soldats 1adoraient 1prisonniere 1

9-60

Etendre Pig

● On l'a vu, Pig propose de nombreuses fonctions en standard.

● En revanche, dans beaucoup de cas complexes, on a besoin d'effectuer des traitements qui sont impossible avec les seules fonctions standard de Pig.

● Pour pallier à ce manque, Pig implémente le concept de User Defined Functions. Il s'agit d'un mécanisme permettant d'étendre Pig.

● Le fonctionnement est simple: il suffit de développer la fonction dont on a besoin en Java (en implémentant certaines interfaces Pig), et une fois compilées, elles deviennent disponibles au sein de tout programme Pig chargeant le .jar correspondant.

● Il est également possible de développer ces fonctions en Python / autres langages (par un mécanisme similaire à Streaming pour Hadoop).

9-61

User Defined Functions

● Pour charger un .jar additionnel depuis un programme Pig, on utilise la commande REGISTER. Par exemple:

REGISTER udf.jar;

(sans guillemets autour du nom du .jar)

● On peut ensuite simplement invoquer la fonction à partir de son classpath directement depuis le langage Pig Latin. Par exemple:

B = FOREACH A GENERATE org.mbds.udf.UpperCase(nom);

(en supposant qu'une classe org.mbds.udf.UpperCase existe au sein du fichier udf.jar d'exemple)

9-62

User Defined Functions - Exemple

● Un exemple: on ne peut pas sans fonction additionnelle implémenter un programme Pig pour résoudre le problème des anagrammes vu précédemment. En effet, il n'y a pas de moyen depuis les fonctions standard Pig de générer la clef (les lettres du mot, classées par ordre alphabétique).

● En conséquence, on imagine qu'on va rédiger une fonction Pig additionnelle pour implémenter cette opération: elle prendra en entrée une chaîne de caractères, et fournira en sortie la même chaîne avec les lettres ordonnées alphabétiquement.

● On décide d'appeler cette classe SortLetters au sein d'un package:

org.mbds.hadoop.pigudfs

9-63


9-64


● Une fois ce code compilé dans un .jar, par exemple un fichier mbds_udfs.jar, on pourra faire au sein de tout programme Pig:

REGISTER mbds_udfs.jar;

● Et si on utilise:

org.mbds.hadoop.pigudfs.SortLetter(field)

… alors on recevra en valeur de retour la valeur de la chaîne field, avec les lettres triées alphabétiquement.

9-65

Conclusion

● On a vu que Pig constituait un outil puissant et accessible pour la rédaction et l'exécution de programmes map/reduce via Hadoop.

● Il est par ailleurs infiniment extensible via le mécanisme des User Defined Functions.

● Si beaucoup d'opérateurs et de fonctions « standards » de Pig ont été abordés, il y en a beaucoup d'autres: pour approfondir le sujet, se référer à la documentation officielle de Pig (+ guide de lectures additionnelles du cours).

hadoop / big data -...

Documents