Utilisation du composant tMap dans le studio Talend

Nos experts Talend continuent leur suite de tutoriels dédiés à la réalisation de vos premiers projets dans le studio Talend Data Integration. Dans ce tutoriel, ils vous expliquent toutes les fonctionnalités du composant tMap. Vous aborderez d'abord l'utilisation de filtres de lignes et de colonnes puis le remplacement de texte et l'utilisation d'une table de jointure en sortie. Enfin, nos experts vous montrerons comment utiliser les jointures et rejets, les variables internes au tMap et les jointures multiples. 

Utilisation de filtres de ligne et de colonnes

Dans cette première partie, nous allons voir comment utiliser les filtres de lignes et de colonnes. Pour cela, nous allons refaire l’exercice de filtrage des lignes et des colonnes en utilisant uniquement le tMap.

Pour commencer, créez un nouveau Job nommé « tMap ».

Depuis vos métadonnées, faîtes glisser le schéma de la table personne sur votre Job pour créer un tDBInput.

Cliquez sur Oui pour ajouter le groupe de contextes correspondant puis cochez PROD avant de cliquer sur OK pour que nous ayons nos variables au complet dans nos contextes.

Nous allons ajouter un composant tMap à droite du tDBInput puis créer un flux Main allant jusqu’à lui.

Double-cliquez sur le tMap pour l’ouvrir.

Nous retrouvons à gauche les schémas en entrée de notre tMap et à droite les schémas en sortie (inexistant pour le moment).

Nous allons maintenant mettre en pratique le filtrage des colonnes ainsi que le filtrage des lignes tel que nous l’avons fait auparavant dans ce tutoriel Talend.  Pour rappel, nous souhaitons récupérer d’un côté uniquement les colonnes nom et prénom et d’un autre coté uniquement les lignes ayant le nom valant « Jefferson ».

Nous avons besoin de 2 sorties. Cliquez une première fois sur le « + » dans la partie de droite puis saisissez « FiltreColonnes » comme nom de sortie.

Votre sortie s’ajoute dans l’écran de droite.

Nous avons besoin de récupérer nos 2 colonnes dans cette sortie.

Sélectionnez les colonnes nom et prénom dans l’écran de gauche (« Ctrl + clic gauche ») et faites-les glisser jusque dans la sortie de droite.

Relâchez la souris et observez le résultat. Notre schéma de droite à désormais 2 colonnes nommées respectivement nom et prénom, et des liaisons indiquent que nos données en entrées doivent ressortir dans les champs définis.

Nous allons même aller un peu plus loin en ajoutant une colonne pour avoir le nom complet de la personne.

Pour cela, ajoutez une colonne nommé « nom_complet » de type String dans la sortie FiltreColonnes en cliquant sur le « + » en bas de page dans la fenêtre de droite.

La variable devient également visible dans la partie de mappage des champs.

Prenez le champ prénom de l’entrée et faites-le glisser dans la case du nom complet.

Attention il faut bien le faire glisser dans la case et non en dessous sinon cela créera une nouvelle ligne.

A présent, dans la case du nom complet, ajoutez + ' ' + à droite du row1.prenom.

A présent, prenez le champ nom de gauche et faites-le glisser à la suite.

Cette syntaxe (Java) signifie que nous concaténons le nom, un espace, puis le prénom dans le nom complet.

Notez que nous aurions également pu marquer row1.prenom + ' ' + row1.nom en toute lettre au lieu de faire glisser nos éléments, les liaisons se seraient automatiquement créées.

Ajoutez une deuxième sortie, cette fois-ci en la nommant « FiltreLignes ».

La sortie s’affiche à droite en dessous de la précédente. Notez que vous pouvez créer autant de sorties que vous le souhaitez comme ceci .

Cette fois-ci nous allons récupérer l’ensemble du schéma de notre entrée. Nous pourrions sélectionner tous nos champs et les faire glisser dans la sortie comme effectué juste avant, mais cette fois-ci nous allons faire autrement.

Dans la partie du bas de la fenêtre, sélectionnez toutes les colonnes de l’entrée et cliquez sur l’icône pour copier le schéma.

Rendez-vous ensuite sur le schéma de la sortie FiltreLignes et cliquez sur l’icône pour coller le schéma.

Votre schéma apparaît alors. Cette manœuvre de copier/coller pour le schéma peut se réaliser pour les schémas de n’importe quel composant.

Il reste encore à mapper nos colonnes d’entrée dans la sortie.

Il faut savoir que lorsque nous avons une sortie comportant des colonnes avec des noms exactement similaires aux noms de colonnes d’entrée, il suffit ensuite de cliquer sur le bouton « Mapping auto » en haut de page pour réaliser automatiquement les liaisons.

A présent il nous reste à appliquer notre filtre.

Pour cela cliquez sur l’icône de filtre de la sortie FiltreLignes.

Dans cette nouvelle case vous pouvez taper du code Java qui sera appliqué en tant que condition. Ici nous souhaitons avoir uniquement les « Jefferson » nous tapons donc row1.nom.equals('Jefferson').

Une flèche indique d’ailleurs que nous utilisons bien le nom de la personne dans la case de filtre.

Cliquez sur le bouton « … » à droite de la case pour ouvrir le constructeur d’expression.

Le constructeur d’expression peut éventuellement vous servir pour créer des expressions plus complexes en mettant à votre disposition des fonctions incluses dans le studio Talend. Ce n’est pour le moment pas utile pour nous, cliquez sur OK pour fermer cette fenêtre.

Nous avons maintenant tout ce qu’il nous faut. Fermez le tMap en cliquant sur OK.

Créez 2 tLogRow dans votre Job et placez-les à droite du tMap.

A présent, reliez chaque flux de sortie à un tLogRow de la même façon que vous créez des flux Main, en faisant un clic droit sur le tMap puis Row.

Exécutez votre Job en contexte par défaut et regardez la console.

Dans le premier tLogRow nous avons bien nos 3 colonnes définies.

Dans le second nous avons bien notre « Jefferson ».

Remplacement de texte et utilisation d’une table de jointure en sortie

Dans cette deuxième parie, nous allons refaire l'exercice de changement de couleur en utilisant une table de jointure en sortie. Nous allons ensuite reproduire la transformation des voitures rouges en voitures roses.

Pour commencer, désactivez le sous-job précédent.

Cette fois-ci faîtes glisser votre métadonnée de la table voiture et choisissez à nouveau tDBInput.

Ajoutez un tMap puis un tLogRow.

Reliez votre tDBInput à votre tMap. Ensuite, reliez votre tMap à votre tLogRow en choisissant « New Output ».

Saisissez « VoituresRoses » comme nom de sortie.

Ouvrez à présent votre tMap en double cliquant dessus.

Remarquez que votre sortie VoituresRoses est présente dans votre tMap.

Faîtes glisser vos colonnes depuis votre entrée vers votre sortie.

Allez dans la case couleur de votre sortie VoituresRoses, supprimez sa valeur et cliquez sur « … » pour ouvrir le constructeur d’expression vu précédemment.

Nous allons utiliser la fonction CHANGE de Talend. Cherchez la dans « StringHandling ».

Double-cliquez dessus pour l’afficher dans l’éditeur d’expression.

Lisez l’aide de la fonction pour comprendre les paramètres à utiliser.

Nous devons donc mettre en 1^er paramètre la source de données de base, en 2^nd la chaîne de caractères à remplacer et en 3^ème la valeur par laquelle la remplacer.

Ce qui nous donne : StringHandling.CHANGE(row2.couleur, 'rouge', 'rose')

A savoir que vous pouvez double-cliquer sur vos variables sur la droite pour les insérer dans l’expression. Cliquez sur OK pour fermer le constructeur puis à nouveau sur OK pour fermer le tMap.

Propagez le schéma dans votre tLogRow puis lancez votre Job. Vos voitures rouges s’affichent en rose dans votre console.

Sauvegardez puis versionnez votre Job.

Ouvrez à nouveau votre tMap et rendez-vous dans la case de la couleur de votre sortie VoituresRoses. Supprimez son contenu.

Nous allons utiliser un opérateur ternaire pour spécifier le changement de couleur.

Pour rappel l’opérateur ternaire est une écriture comme celle-ci : [condition] ? [Si oui] : [Sinon].

Dans notre cas nous souhaitons dire que si la voiture est rouge, on marque rose à la place, sinon on laisse la couleur d’origine, soit : row2.couleur.equals('rouge') ? 'rose' : row2.couleur.

Cliquez sur OK pour fermer le tMap et exécutez le Job pour vérifier que cela fonctionne.

Sauvegardez et versionnez à nouveau votre Job. Nous allons refaire ce remplacement d’une dernière façon.

Réouvrez votre tMap.

Nous allons commencer par filtrer toutes les voitures rouges dans notre sortie. Ouvrez donc le filtre d’expression et tapez row2.couleur.equals('rouge').

Supprimez ensuite la valeur du champ couleur et tapez 'rose'.

Ainsi nous aurons dans cette sortie toutes les voitures rouges mais la valeur de leur couleur sera rose.

Le souci à cette étape est qu’il nous manque toutes les voitures qui ne sont pas de couleur rouge à la base.

Cliquez sur le « + » en haut de page pour ajouter une nouvelle sortie. Cochez « Create join table from », sélectionnez VoituresRoses et nommez-la « AutresVoitures ».

Votre nouvelle sortie apparaît en dessous de l’autre. En réalité il ne s’agit pas réellement d’une sortie à proprement parlé mais plutôt d’un complément de sortie, d’ailleurs c’est indiqué dans son nom qu’elle est liée à la sortie précédente.

Cliquez sur « Mapping auto » pour faire correspondre rapidement vos champs.

N’oublions pas que dans cette section nous ne souhaitons obtenir que les voitures que ne sont pas rouge car on les obtient déjà dans VoituresRoses, il nous faut donc les voitures ne répondant pas au critère de filtre défini plus haut.

Pour cela, cliquez sur l’icône des paramètres de la sortie jointe pour déplier son contenu et sélectionnez « true » dans « Catch output rejects ».

Comme son nom l’indique cela signifie qu’on ne va retrouver que les lignes ne passant pas le filtre avec succès, c’est-à-dire ici que les voitures qui ne sont pas rouges.

Nous avons donc d’un côté toutes les voitures rouges transformées en rose et en plus toutes les autres voitures, nous devrions donc retrouver toutes nos voitures dans leur intégralité avec les changements de couleur.

Fermez votre tMap et exécutez le Job pour vérifier que tout fonctionne. Vous devriez avoir vos 100 lignes de voiture dont les voitures rouges changées en voitures roses.

Utilisation des jointures et rejets

Nous allons maintenant refaire l'exercice du changement de marque en utilisant uniquement le tMap.

Désactivez le sous-Job précédent.

Pour avoir plus d’espace dans votre Designer, sachez qu’il est possible de réduire les sous-job en cliquant sur le « - » en haut à gauche de chaque sous-job.

Depuis vos métadonnées, faîtes glisser votre table voiture et créez un tDBInput.

Ajoutez à sa droite un tMap puis un tLogRow et reliez le tout en nommant votre sortie « NouvellesMarques ».

Nous allons maintenant ajouter notre fichier de correspondances des marques utilisé précédemment (correspondance_voitures.csv).

Ajoutez donc un nouveau tFileInputDelimited qui lit ce fichier. Pour gagner du temps vous pouvez tout simplement copier/coller le composant depuis votre Job LectureBase.

Pour rappel, voici ses propriétés :

Et son contenu :

Ajoutez ensuite un flux Main allant du fichier de correspondance jusqu’au tMap. Vous pouvez remarquer que le flux est devenu un Lookup ce qui est logique car notre flux principal est notre table voiture, notre fichier de correspondance ne servant que de référence.

Ouvrez votre tMap et observez vos 2 entrées sur la partie gauche.

Vous avez peut-être remarqué que lors de la création d’un nouveau flux, Talend le nomme automatiquement row[N°]. Cela n’est pas particulièrement gênant dans des petits Jobs, cependant lorsque l’on commence à utiliser plusieurs entrées on peut rapidement s’y perdre.

Ici elles sont assez distinctes par leur schéma et surtout elles ne sont que 2, mais imaginez-en une dizaine avec des schémas très similaires, il serait bon de savoir rapidement dans le tMap à quelle entrée se rapporte chaque élément.

Refermez votre tMap.

Positionnez-vous sur le nom de votre premier flux et cliquez dessus une seconde fois pour pouvoir le renommer en « Voitures ».

Faîtes de même avec votre second flux et nommez-le « Marques ».

Ouvrez à nouveau votre tMap.

Les éléments d’entrée sont plus reconnaissables.

Créez votre schéma dans NouvellesMarques pour qu’il soit identique à Voitures, puis faîtes correspondre vos colonnes immat et couleur.

Nous avons ensuite besoin de spécifier que la colonne marque présente dans nos Voitures doit correspondre à la colonne ancienne de nos Marques.

Pour cela, faîtes glisser votre colonne marque dans le champ Clé d’expr. de votre colonne ancienne (il est également possible de marquer directement Voitures.marque dans la valeur du champ).

Vous voyez qu’une jointure a été faîte entre les deux colonnes.

Dépliez la fenêtre de paramétrage de vos Marques.

Vous pouvez ici gérer vos paramètres de jointure. Nous laissons tout par défaut car nous souhaitons bien effectuer une jointure externe gauche pour ne pas perdre de ligne et nous souhaitons une correspondance unique puisque notre fichier ne contient de toute façon pas de doublons dans les marques.

Il reste encore à spécifier dans notre sortie NouvellesMarques que nous souhaitons récupérer la bonne valeur. Nous allons utiliser une condition ternaire pour dire que si nous avons une correspondance avec le fichier nous souhaitons afficher cette nouvelle marque, sinon nous affichons la marque de base, ce qui se traduit en Java par :

Marques.nouvelle != null ? Marques.nouvelle : Voitures.marque

Vous pouvez faire glisser vos champs directement ou passer par l’éditeur d’expression pour ne pas avoir à écrire cette formule en toutes lettres.

Observez que vos champs sont à présent bien liés à votre sortie.

Fermez votre tMap en cliquant sur OK puis propagez les changements pour récupérer votre schéma dans le tLogRow.

Exécutez votre Job et vérifiez le résultat dans la console.

Enregistrez et versionnez votre Job.

Dans certains cas, nous voudrons mettre en place des jointures internes pour n’obtenir que les lignes qui ont une correspondance. Pour cela, réouvrez votre tMap et sélectionnez Inner Join comme paramètre de vos Marques.

Sachant que nous aurons toujours une correspondance, vous pouvez également modifier la valeur de votre colonne marque en sortie pour afficher dans tous les cas la valeur du Lookup.

Nous n’aurons maintenant en sortie que les voitures ayant une marque présente dans le fichier de correspondance.

Si nous souhaitons tout de même récupérer également les voitures avec une marque inchangée, nous allons devoir récupérer les rejets de cette jointure.

Nous souhaitons avoir toutes les voitures en une seule sortie, créez donc une nouvelle table de jointure comme vu précédemment et appelez-là « PasDeModif ».

Cliquez ensuite sur Mapping auto pour faire correspondre vos champs.

Dépliez à présent la fenêtre de paramétrage de PasDeModif.

Durant l’exercice précédent nous avions vu le Catch output reject pour récupérer les lignes ne répondant pas aux filtres, et bien voyez qu’il existe juste en dessous le même paramètre pour les jointures internes. Mettez donc la valeur de Catch lookup inner join reject à true.

Si nous avions souhaité avoir les rejets dans une sortie séparée, il aurait tout à fait été possible de créer une seconde sortie et de mettre ce paramètre à vrai également pour pouvoir récupérer ces lignes.

Cliquez sur OK pour fermer votre tMap et exécutez à nouveau votre Job. Le résultat devrait être identique à celui obtenu précédemment.

Utilisation des variables internes au tMap

Dans cette partie, nous allons produire plusieurs sorties ayant une variable commune générée à la volée dans le tMap.

Créez un nouveau Job nommé « FiltreAge ».

Créez un tDBInput depuis votre table personne et acceptez d’ajouter votre groupe de contextes de connexion à votre base de données.

Ajoutez un tMap puis 3 tLogRow à sa droite.

Créez respectivement 3 sorties :

• « Mineurs»
• « Majeurs»
• « Tous»

Ouvrez votre tMap puis copiez vos colonnes d’entrée dans chacune des sorties.

Premièrement nous souhaitons différencier les personnes mineures et majeures.

Nous avons vu qu’il est possible d’utiliser des filtres directement sur les sorties en dépliant la fenêtre prévue à cet effet. Dans les faits, nous pourrions ajouter un filtre sur la sortie Majeurs en lui spécifiant que la date de naissance doit remonter à plus de 18 ans par rapport à aujourd’hui et copier-coller le même code en inversant la comparaison pour les Mineurs.

Mais imaginons si nous avions besoin d’une vingtaine de sortie, cela signifiera copier-coller le même code 20 fois. Imaginons ensuite que l’on veuille adapter ce code pour les Etats-Unis ou la majorité est à 21 ans, nous devrions modifier 20 fois l’âge dans les critères de filtre.

Pour centraliser tout cela, le tMap nous offre la possibilité de créer des variables dans la colonne encore inutilisée dans notre composant : celle de milieu, entre nos entrées et nos sorties.

Cliquez sur le « + » pour ajouter une variable de type boolean et nommez-la « estMajeur ».

Ouvrez l’éditeur d’expression en cliquant sur le « … », puis cherchez dans la catégorie TalendDate la fonction diffDate prenant 3 paramètres et double cliquez dessus pour la faire apparaître dans l’éditeur.

Nous souhaitons avoir la différence d’années entre aujourd’hui et la date de naissance de la personne et savoir si cette différence est supérieure à 18. Pour obtenir la date d’aujourd’hui nous utiliserons la fonction getCurrentDate également présente dans la catégorie TalendDate.

Modifiez donc les paramètres comme ceci :

TalendDate.diffDate(TalendDate.getCurrentDate(),row1.date_de_naissance, 'yyyy') > 18

Cette expression renverra automatiquement vrai si la condition est vérifiée et faux au cas contraire.

Notez que pour pousser la maintenabilité nous aurions pu utiliser une variable de contexte pour stocker l’âge à vérifier.

Fermez l’éditeur en cliquant sur OK.

Nous avons besoin d’appeler cette nouvelle variable dans les filtres des sorties Mineurs et Majeurs. Pour cela, faîtes simplement glisser la variable dans les filtres de ces deux sorties, puis dans le filtre des Mineurs, ajoutez un « ! » devant le nom de la variable.

En Java comme dans beaucoup d’autres langages, le « ! » permet d’inverser un booléen. C’est-à-dire que « !estMajeur » veut littéralement dire « n’est pas majeur », donc mineur dans le cas présent.

Vous pouvez voir en suivant les flèches que la date de naissance est bien utilisée dans la variable et qu’ensuite la variable est utilisée dans les filtres d’expression.

Nous allons ensuite ajouter un champ d’identifiant supplémentaire dans chacun de nos schémas de sortie au-dessus de l’id de base, qu’on appellera « super_id » et de type Integer. A savoir que vous pouvez modifier l’ordre des champs avec les flèches en dessous du schéma.

Cet identifiant sera généré à la volée, sachant que nous souhaitons qu’une même personne ait le même identifiant entre les sorties. Nous connaissons la fonctions Numeric.sequence utilisée au tout début des exercices pour générer des identifiants, nous allons donc l’utiliser.

Si nous mettions cette fonction directement dans les champs super_id, nous ne pourrions pas avoir le même identifiant pour une même personne entre les sorties car les sorties Majeurs et Mineurs ne vont pas s’incrémenter en même temps que la sortie Tous puisque des filtres sont appliqués, le compteur montera donc moins.

La solution revient une fois de plus à utiliser une variable.

Créez une nouvelle variable « superId » de type Integer.

Ouvrez l’éditeur d’expression pour trouver la fonction séquence ou tapez :

Numeric.sequence('superId',1,1)

Le premier paramètre représente le nom de la séquence. Jusqu’ici nous avions laissé la valeur par défaut mais il peut être utile de lui donner un nom notamment lorsque l’on manipule plusieurs séquences.

Faîtes maintenant glisser votre variable dans la valeur de chacun de vos super_id.

Fermez votre tMap en cliquant sur OK, propagez vos changements aux tLogRow et lancez votre Job.

Vérifiez vos 3 sorties dans la console.

Utilisation de jointures multiples 

Dans cette dernière partie nous allons voir comment réaliser un état complet des propriétaires avec leur voiture.

Souvenez-vous que dans le Job tJoin précédent nous n’avions pas réussi à afficher les propriétaires avec toutes leurs voitures à cause des limites du composant tJoin. Vous devriez vous doutez maintenant que le tMap peut réaliser cette tâche sans soucis.

Créez un nouveau Job nommé « EtatComplet ».

Depuis vos métadonnées, ajoutez vos 3 tables personne, personne_voiture et voiture en tant que tDBInput puis ajoutez un tMap suivi d’un tLogRow.

Reliez le tout en positionnant personne en tant que flux principal et vos 2 autres tables en tant que Lookup. Créez une sortie dans le tMap vers le tLogRow nommée « EtatComplet ».

Nommez également vos entrées pour y voir plus clair.

Ouvrez votre tMap, puis faîtes correspondre vos clés de jointure.

Vous pouvez voir qu’il est possible d’enchaîner plusieurs jointures.

N’oubliez pas de modifier vos paramètres de jointure. Une personne peut avoir plusieurs voitures et donc être présente plusieurs fois dans la table de jointure, il faut donc bien préciser qu’on veut toutes les correspondances dans le Match Model et que certaines personnes n’ont pas de voiture donc qu’on veut une jointure externe gauche pour le Join Model.

Idem pour la jointure avec les voitures, mais on peut laisser la correspondance unique étant donné que dans tous les cas chaque voiture à une immatriculation distincte.

Dans votre sortie, ajoutez les colonnes que vous souhaitez voir depuis votre table personne et votre table voiture.

Fermez votre tMap en cliquant sur OK, propagez votre schéma dans le tLogRow et lancez votre Job.

Vous devriez voir dans la console au moins une ligne par personne, multipliée par son nombre de voiture s’il en a une ainsi que les valeurs 0 et null pour les personnes n’ayant pas de voiture.