Professional Documents
Culture Documents
Guide Utilisateur
Version 0.7
Une copie de la licence GNU Free Documentation License est fournie avec les fichiers source de cette
documentation.
Composants .......................................................................................................95
tMsgBox ............................................................................................................................96
Propriétés de tMsgBox .....................................................................................................96
Scénario test de type ‘Hello World’ .................................................................................96
tFileInputDelimited ..........................................................................................................98
Propriétés de tFileInputDelimited ....................................................................................98
Scénario: Affichage du contenu d’un fichier délimité .....................................................99
tFileInputPositional .........................................................................................................101
Propriétés de tFileInputPositional ..................................................................................101
Scénario: Transformation d’un fichier positionnel en XML ..........................................102
tFileOutputXML .............................................................................................................106
Propriétés de tFileOutputXML .......................................................................................106
Scénario: Utilisation d’un format de sortie XML .........................................................107
tLogRow ...........................................................................................................................108
Propriétés de tLogRow ...................................................................................................108
Scénario: Affichage dans la console ..............................................................................108
tFileList ............................................................................................................................109
Propriétés de tFileList ....................................................................................................109
Scénario: Itération sur un répertoire ...............................................................................109
tFTP ..................................................................................................................................112
Propriétés de tFTP ..........................................................................................................112
tFTP put ..........................................................................................................................112
A propos de ce manuel...
Remarques et Support
N’hésitez pas à nous faire part de vos remarques, suggestions ou requêtes concernant la documentation
ou le produit, et obtenez le support de notre équipe Talend, sur le forum Talend (en anglais):
http://talendforge.org/forum
Accédez à l’application Talend Open Studio dans son répertoire d’installation. Double-cliquez sur
l’exécutable Talend Open Studio pour lancer l’application.
Pour commencer, lisez et acceptez les termes de la licence GPL v2 pour continuer.
Le formulaire d’enregistrement Talend Open Studio s’affiche. Remplissez votre adresse électronique
et votre lieu de résidence pour recevoir des informations sur Talend Open Studio. Cette étape est
facultative, cliquez sur Cancel si vous ne souhaitez pas la renseigner.
Cochez Enable HTTP Proxy parameters si votre situation le requiert et renseignez les informations
de proxy appropriée. Veillez à fournir votre adresse email si vous remplissez des informations de proxy.
Vous pouvez renseigner ou modifier ces informations d’enregistrement à tout moment, en cliquant sur
Window > Preference > Talend > Install/Update.
WARNING—Soyez assuré que toutes les informations personnelles que vous fournissez à Talend, ne
sont pas transmises à des tiers et ne sont pas utilisées à d’autres fins que celles de vous informer sur
Talend et les produits Talend.
Dans cette version, votre reférentiel est conservé sur une seule machine, par conséquent sur votre
système local, appelé Local Repository.
Aucun mot de passe (Password) n’est requis puisque Talend Open Studio n’est accessible que d’une
seule machine.
Cliquez sur l’icone Refresh pour mettre à jour la liste des projets existants. Puis sélectionnez le nom
de votre projet et cliquez sur OK pour l’ouvrir.
Si vous avez déjà créé des projets avec une version précédente de Talend Open Studio, vous pouvez
les importer dans votre workspace à l’aide du bouton Import projects.
Voir également: Importation d’un projet, page 6
Si vous créez un projet pour la première fois, cliquez sur New project pour lancer l’assistant de création
de projet.
Voir également: Création d’un projet, page 5
Pour faciliter votre prise en main de Talend Open Studio, des exemples de job sont à votre disposition
via Import Demos. Le dossier de projets Demos est automatiquement installé dans votre workspace. Et
ce projet est accessible directement dans la fenêtre de connexion, dans le champ Projects.
La création d’un projet met automatiquement en place une arborescence de fichiers sur le serveur de
votre référentiel. Celle-ci correspond en tout point à l’arborescence de répertoires qui sera affiché dans
le Repository de votre projet Talend Open Studio.
Commencez par donner un Nom à votre nouveau projet. Ce champ est obligatoire pour poursuivre le
processus de création.
Selon les caractères que vous saisissez et l’endroit où vous placez le curseur, un message contextuel
s’affiche en haut de l’assistant. Il vous informe de la nature des données attendues ou, le cas échéant,
des caractères interdits.
Note: Les chiffres ne sont pas autorisés en début de nom de projet. Le nom de projet n’est pas
sensible à la casse, par conséquent MonProjet et MONPROJET sont identiques.
Le nom technique, Technical name, est utilisé par l’application pour créer le nom du fichier projet. Il
correspond généralement au nom de projet saisi, mis en majuscule et concaténé à l’aide de tirets
soulignés si nécessaire.
Le seul langage de génération de code, Generation language, disponible actuellement est Perl. Java
est fourni à titre indicatif, pour l’instant, car il devrait faire partie d’une prochaine distribution de Talend.
Sur la fenêtre de connexion, cliquez sur Import projects pour lancer l’assistant d’importation.
Cliquez sur Browse... pour sélectionner le répertoire Workspace contenant les projets à importer. Par
défaut, le workspace sélectionné est le workspace courant. Remontez l’arborescence vers le répertoire
Workspace de la version précédente et sélectionnez le.
Remarquez que la case Copy projects into workspace est cochée. Si vous souhaitez déplacer les projets
de leur emplacement initial vers le nouveau workspace, décochez la case. Mais nous vous
recommandons de conserver une version de sauvegarde.
Sélectionnez les projets à importer et cliquez sur Finish pour valider.
Sur la fenêtre de connexion, les projets importés apparaissent désormais dans la liste Projects proposée.
Sélectionnez le projet que vous souhaitez ouvrir, et cliquez OK pour lancer Talend Open Studio.
Talend Open Studio s’ouvre sur une fenêtre à zones multiples. Le reférentiel, Repository est une boîte
à outils rassemblant tous les éléments que vous créez et utilisez pour la modélisation et la conception
de vos projets. Vous pouvez définir vos préférences de propriétés d’affichage pour les adapter à vos
besoins.
• Dans le menu Window de la fenêtre principale de Talend Open Studio, cliquez sur Preferences.
• Puis dans l’arborescence Preferences, cliquez sur Talend. Si le répertoire d’installation Perl ne
s’affiche pas par défaut, saisissez le chemin vers Perl.
• Vous pouvez également modifier le chemin d’accès vers les fichiers temporaires si vous le
souhaitez. Par défaut, le chemin est défini sur le répertoire d’installation TOS.
• Développez le noeud Talend, et cliquez sur Status pour définir les propriétés principales des
éléments du Repository.
• Le panneau Main des propriétés d’un élément du référentiel regroupe toutes les données
générales telles que: Nom, Purpose, Description, Author, Version et Status de l’élément
sélectionné. La plupart de ces champs sont en saisie libre, à l’exception du champ Status qui est
une liste déroulante.
• Alimentez la liste Status avec les valeurs appropriées à vos besoins d’entreprise. Notez que le
Code ne peut dépasser trois caractères et le Libellé est obligatoire.
Talend fait une différence entre deux types de statuts: Technical status et Documentation status
La liste de statuts techniques affiche les codes de classification des éléments qui sont utilisés lors de
l’excéution de jobs, de définition de métadonnées ou de routines.
La liste de statuts Documentation permet de classer les éléments du référentiel qui sont utilisés pour
documenter les models/jobs. Cette liste de statuts n’est disponible que pour les Business Models et la
Documentation.
Une fois la définition des Status terminée, cliquez sur OK pour enregistrer les paramètres.
Désormais la liste Status vous permet d’appliquer vos paramètres de classfication personnalisés à vos
éléments du référentiel.
Repository
Le référentiel, Repository, regroupe les éléments techniques disponibles pour la description des
Business models et la conception des Job designs. Le Repository vous donne accès à ces Business
models et Job designs ainsi qu’à toutes les routines et documentations réutilisables pour leur
conception.
Ce référentiel centralise et conserve localement tous les éléments contenus dans un projet.
Business Models
Tous les schémas des processus métier d’un projet sont regroupés sous le noeud Business
Models. Double-cliquez sur le nom du schéma pour l’ouvrir dans l’espace de modélisation
graphique, appelé workspace.
Voir également : Conception d’un Business Model, page 19
Job Designs
Le dossier Job designs rassemble tous les jobs du projet courant. Double-cliquez sur le nom
d’un graphique pour l’ouvrir dans l’espace de modélisation.
Voir également : Conception d’un Job Design, page 31
Code
La bibliothèque de Code rassemble les routines ainsi que les snippets (fonctionnalité à venir)
disponibles pour ce projet. Vous pouvez ainsi mutualiser ce code et le réutiliser dans divers
composant ou jobs.
Cliquez sur une entrée de l’arborescence pour ouvrir le fichier de code correspondant.
Voir également : Conception d’un Job Design, page 31
Routines
Une Routine est un morceau de code plus ou moins complexe généralement utilisé de
façon itérative dans un ou plusieurs jobs techniques.
Sous Routines dans le référentiel, un dossier System regroupe toutes les routines Talend
prédéfinies. Développez ce noeud, les fichiers de routine comprennent notamment Dates,
Misc et String.
Double-cliquez sur l’un des fichier, l’Editeur de routines s’ouvre dans un nouvel onglet.
Vous pouvez déplacer cet onglet dans le workspace en le glissant simplement à l’aide de la
souris vers l’emplacement souhaité.
Utilisez ces modèles de routines comme références pour en construire de nouvelles ou
copiez la routine qui vous convient vers le champ propriété de votre job pour l’utiliser.
Pour créer une nouvelle routine, cliquez-droit sur un entrée du répertoire Routines du
référentiel. Puis sélectionnez Create a routine dans le menu contextuel. L’éditeur de
routines s’ouvre sur un fichier Template contenant par défaut des morceaux de code tels
que:
sub printTalend {
print "Talend\n"
Remplacez ce modèle par votre propre morceau de code et refermez le fichier pour
enregistrer. La nouvelle routine apparaît dans le Repository sous la forme d’un nouveau
noeud sous Routines.
Vous avez également la possibilité d’organiser vos routines dans des dossiers.
Note: Le dossier System, ainsi que son contenu est en lecture seule.
Snippets
Les snippets sont des petits morceaux de code réutilisables (par duplication) dans les
composants et les jobs pour automatiser les transformations par exemple. Cette
fonctionnalité sera bientôt disponible.
Documentation
Le répertoire Documentation regroupe tout type de documents de tout format, tels que des
spécifications ou la description d’un format technique particulier d’un fichier. Double-cliquez
pour ouvrir le document dans l’application appropriée.
Voir également : Conception d’un Job Design, page 31
Metadata
Le répertoire Metadata centralise les fichiers que vous souhaitez réutiliser tels que les schémas
et les propriétés d’un ou plusieurs jobs.
Voir également : Définition des schémas de métadonnées, page 45
Recycle bin
Glissez déposez le ou les éléments inutiles ou obsolètes du Repository vers la corbeille ou
appuyez sur la touche del de votre clavier pour les supprimer.
Note : les éléments supprimés sont conservés sur votre système, dans la corbeille, tant que vous
la videz pas. Cliquez-droit sur la corbeille et sélectionnez Empty Recycle bin pour supprimer
définitivement son contenu.
Espace de modélisation
Le Graphical workspace ou espace graphique de modélisation est l’éditeur de schéma des jobs de
Talend Open Studio qui vous permet de concevoir graphiquement les business models (processus
métier) mais également les jobs designs (processus techniques).
Les jobs design et business models ouverts dans l’éditeur graphique sont organisés dans un système
d’onglets.
Une Palette est rattachée à l’éditeur graphique pour vous permettre d’accéder rapidement à tous les
éléments graphiques (formes ou composants techniques) répondant à vos besoins.
A partir de la Palette, selon que vous travaillez sur un business model ou un job design, cliquez et
déposez les formes, branches, notes ou composants techniques dans l’éditeur graphique. Puis
définissez et formattez les éléments graphiques à l’aide des paramètres de propriétés de la vue
Properties en bas de la fenêtre.
Voir également:
• Conception d’un Business Model, page 19
• Conception d’un Job Design, page 31
Les onglets Properties, Run Job et Logs regroupent toutes les informations relatives aux éléments
graphiques sélectionnés dans l’espace de modélisation ou à l’exécution elle-même du job complet.
Properties
Ces paramètres de propriétés peuvent être de tout type. Le contenu de l’onglet Properties varie
selon l’élément graphique sélectionné.
Par exemple, lorsque vous ajoutez une forme à un schéma de business model, l’onglet
Properties met à votre disposition toute une gamme d’outils de formattage, vous permettant de
personnaliser et ainsi améliorer la lisibilité de votre business model.
Dans le cas où vous travaillez à la conception d’un job, l’onglet Properties vous permet de
configurer les paramètres de fonctionnement des composants et par conséquent de contrôler
chaque étape de votre implémentation technique.
Logs
Les Logs sont généralement utiles lors de l’éxécution des jobs techniques, car ils affichent les
éventuelles erreurs d’exécution.
Note: Mais, l’onglet Log a également une fonction informative, notamment pour
indiquer qu’un module Perl est en cours de fonctionnement par exemple.
Run Job
L’onglet Run Job, comme son nom le suggère, affiche l’exécution du job technique courant.
Cet onglet prend le role d’une console de log pour afficher le résultat d’une exécution.
Pour plus d’informations sur l’exécution d’un job, voir Exécution d’un job, page 90
Les onglets Modules et Scheduler font partie du même groupe de vues que Properties, Logs et
Run Job. Les vues Modules et Scheduler n’ont pas d’impact ni ne sont influencés par les jobs
ouverts dans le workspace, que ces derniers soient actifs ou non.
Modules
L’utilisation de certains composants requiert l’installation de modules spécifiques Perl.
Consultez la vue Modules pour vérifier les modules présents ou manquants pour l’exécution
de vos jobs.
Si l’onglet Modules ne s’affiche pas dans votre workspace, cliquez sur le menu Window >
Show View... > Talend, puis sélectionnez Modules sous le noeud Talend.
Cette vue indique quel module est nécessaire et/ou requis pour l’utilisation du composant
correspondant.
La colonne Status indique si les modules répertoriés sont ou non installés sur votre système. Le
triangle d’avertissement montre que le module est recommandé mais pas requis pour
l’utilisation de ce composant.
Par exemple, le module DBD::Oracle n’est requis que si vous utilisez tDBSQLRow avec une
base Oracle. De la même façon, DBD::Pg n’est requis que pour une utilisation de PostgreSQL.
Mais tous peuvent devenir nécessaires dans leur contexte d’utilisation respectif.
Le cercle rouge à croix blanche signifie que le module est indispensable à l’utilisation du
composant en regard.
Si la colonne Component n’est pas renseigné pour un module particulier, ce module est alors
requis pour l’utilisation générale de TOS.
Lors de la construction de votre job, if un composant requiert un module non installé, un
message d’erreur est généré et s’affiche dans l’onglet Problems.
Pour installer les modules Perl indiqués manquants, consultez le guide d’installation (en
anglais) sur http://talendforge.org/wiki/
Open Scheduler
Open Scheduler est un outil de planification d’exécution basé sur la commande crontab,
couramment utilisée sous Unix et systèmes d’exploitation similaires. Cette commande cron
peut également être installée sur Windows.
Open Scheduler génère des entrées compatibles cron vous permettant d’exécuter une tâche, par
exemple : lancer un job, à un échéance définie via le crontab.
Si l’onglet Scheduler n’apparaît pas dans votre workspace, cliquez sur le menu Window >
Show View... > Talend, puis sélectionnez Scheduler sous le noeud Talend.
La zone Information se compose de deux onglets: Outline et Code Viewer, qui fournissent des
aperçus du diagramme affiché dans l’éditeur graphique (qu’il s’agisse d’un job design ou d’un
business model).
Outline
L’onglet Outline offre un aperçu rapide du diagramme du business model ou du job design
ouvert dans l’éditeur. En cliquant sur l’icone d’arborescence, vous pouvez accéder aux variables
disponibles pour les composants sélectionnés. Tout comme l’éditeur ou toute autre zone, il est
très facile de changer la position de l’aperçu Outline et de la redimensionner selon vos besoins.
Cet aperçu sert à reperer les parties d’un diagramme affichées ou invisibles dans l’éditeur. Il
donne une vue globale de la représentation graphique du job.
Code viewer
L’onglet de l’aperçu de code Code viewer fournit
les lignes de code générées pour le composant
sélectionné dans l’éditeur. Ce code est généré en
arrière plan du job et comprend les éléments Start,
Body et End correspondant aux phases d’execution
de ce composant.
Note: cette vue ne concerne que le code produit dans un job design. En effet aucun code n’est
généré à partir des business models.
A l’aide de l’aperçu de code en couleur, vous pouvez distinguez les diverses parties du code d’un
composant sélectionné dans l’éditeur. Cet aperçu est une vue partielle de l’onglet principal
Code, situé en bas de l’éditeur graphique, qui lui, affiche le code généré pour l’ensemble du job.
Talend Open Studio est l’outil optimal pour mettre en place une approche Top/down vous permettant
de garder le contrôle sur le processus métier de son niveau d’abstraction le plus élevé à l’étape
décisionnelle et même technique la plus pragmatique.
Ce chapître s’adresse aux reponsables métier, décisionnaires BI ou développeurs qui souhaitent
modéliser leurs besoins de gestion de flux de données à un niveau macro.
Objectifs
Un Business model est une vue non technique d’un besoin métier de gestion de flux de données.
Généralement, un business model intègre en premier lieu les systèmes stratégiques déjà mis en place et
opérationnels de votre entreprise. Puis vous ajoutez brique par brique vos besoins supplémentaires et
vous les reliez entre eux. Ces systèmes, connexions et autres besoins sont symbolisés dans Talend
Open Studio par de multiples formes et liens disponibles dans la Palette.
Toutes les formes et liens peuvent être décrits dans leur propriétés à l’aide des paramètres de
documentation et de formats que vous définissez dans le référentiel de metadonnées, ou ponctuellement
directement dans votre business model.
A partir de Talend Open Studio, vous disposez de nombreux outils vous permettant de:
• modéliser vos besoins métier
• créer des éléments dans le référentiel de metadonnées et les assigner à vos objets de Business
Model.
• définir les propriétés d’apparence de vos objets de Business Model.
Lancez Talend Open Studio suivant la procédure détaillée dans la section Accès à Talend Open Studio,
page 3.
Dans la fenêtre Talend Open Studio, cliquez sur Business Models dans l’onglet Repository pour
développer l’arborescence.
Si plusieurs onglets sont ouverts dans votre éditeur de modélisation, assurez-vous que la représentation
graphique affichée est correcte, en cliquant sur l’onglet approprié.
Note: En effet, la fenêtre Properties ainsi que les éléments des Menus affichent des
informations relative au modèle actif seulement.
Cliquez et déposez les éléments de la Palette et connectez-les à l’aide de liens. Améliorez l’aspect
visuel du diagramme à l’aide de l’outil Zoom in et out.
Cette Palette offre des représentations graphiques des objets constituant un business model.
Le terme objets couvre tous les systèmes stratégiques, les éléments intermédiaires de transformation, de
routage, les étapes décisionnelles, jusqu’au type de terminaux du flux de données en sortie. Chacun
tenant un rôle spécifique dans votre business model selon la description, la définition et les affectations
(assignment) que vous lui attribuez.
Tous les objets sont représentés par des formes dans la Palette et toutes ces formes
peuvent être incluses dans une représentation graphique du processus.
Note: Si les formes ne s’affichent pas dans la Palette, cliquez sur l’icone du
répertoire business pour dérouler la librairie de formes.
Sélectionnez la forme correspondant à l’objet que vous souhaitez inclure dans votre
business model.
Double-cliquez dessus ou cliquez sur la forme dans la Palette et déposez la dans
l’espace de modélisation.
Alternativement, la barre d’accès rapide aux formes apparaît lorsque vous
conservez votre curseur immobile quelques instants sur l’espace de modélisation.
Par exemple, si votre business model inclut une étape de décision, sélectionnez la forme losange
dans la Palette.
Note: Passez le pointeur de votre souris au dessus de la barre d’accès rapide, pour faire
apparaître les bulles contextuels de chacune des formes.
Puis cliquez une fois dans l’espace de modélisation pour la faire apparaître graphiquement.
La forme déposée est entourée d’un cadre noir dont les points d’angle vous
permettent de la redimensionner selon vos besoins.
En outre, une zone de saisie bleue vous permet d’apposer un libellé sur la forme
en sélection. Donnez un nom parlant qui vous permettra ensuite d’identifier
rapidement le rôle de cette forme dans le processus.
Deux flèches opposées apparaissent sur cette forme, quis vous permettent de créer des connexions
vers d’autres formes. Vous pouvez ainsi rapidement définir une séquence et des dépendances entre
les éléments formant votre processus. Voir également: Connexions, page 23.
Libellé Description
Decision Représente une condition if dans le flux de données.
Permet de prendre des mesures contextuelles.
Action L’action peut être de toute nature, notamment,
transformation, traduction ou format par exemple.
Terminal Tout type de terminal de sortie
Data Tout type de donnée, numérique ou alphanumérique.
Document Ajoute un objet document qui peut servir en entrée ou en
sortie pour fournir les données à traiter.
Input Ajoute un objet entrée permettant à l’utilisateur de saisir
ou de fournir manuellement les données à traiter.
List Répertorie les données extraites sous la forme d’une
liste. Cette liste peut être paramétrée pour ne contenir qe
les données d’une certaine nature.
Database Ajoute un objet base de données qui peut servir en entrée
ou en sortie du traitement des données.
Connexions
Une des phases essentielle de la conception d’un business model consiste à mettre en place les
relations entre les formes, source et cible.
Plusieurs solutions s’offrent à vous :
Note: La direction de la flèche n’a pas beaucoup d’importance à ce stade, car aucun code
n’est généré et cette connexion représente donc essentiellement une relation simple
entre deux formes.
Les outils suivants de la Palette vous permettent de personnaliser votre business model:
Libellé Description
Select Sélectionnez et déplacez les formes et relations dans
l’espace de modélisation du Modeler.
Zoom Zoomer sur une partie de la représentation graphique
pour en voir le détail. Pour zoomer arrière, appuyez sur
la touche Maj et cliquez sur l’espace de modélisation.
Note/Text/Note Permet d’ajouter des commentaires, des notes afin de
attachment conserver toute information utile concernant tout ou
partie du processus.
Propriétés
Les informations de propriétés sont affichées dans la vue Properties et correspondent à la sélection
en cours dans l’éditeur, le cas échéant. Les propriétés peuvent concerner l’ensemble du processus
ou seulement une partie du processus selon la sélection. Si rien n’est sélectionné dans l’éditeur, les
propriétés fournissent des informations générales concernant l’espace de modélisation lui-même.
L’onglet Properties comporte différents types d’informations concernant:
• Rulers and Grid (Règles et grille)
• Appearance (Format)
• Assignment (Affectation)
Cochez les cases pour afficher la Règle (Ruler), ou la grille (Grid) ou les deux.
Grid in front place la grille devant toutes les formes du processus. Définissez l’unité de la règle
en Centimeters (centimètres), inches (pouces) ou pixels. Vous pouvez également sélectionner
la couleur ainsi que le style des lignes de la grille ou restaurer les valeurs par défaut.
Vue Appearance
A partir de l’onglet Appearance (Formats), vous pouvez appliquer des couleurs de remplissage
et de bordures, changer l’apparence des formes et des liens afin de personnaliser votre business
model et le rendre plus lisible.
L’onglet Properties inclut les paramètres suivants :
• remplir la forme avec la couleur sélectionnée.
Vue Assignment
Le tableau des affectations affiche des informations détaillées sur les attributs du Répository
(référentiel) affectés à la forme ou à la connexion sélectionnée.
Pour afficher les informations d’affectation, sélectionnez une forme ou une connexion dans la
vue active.
Vous pouvez modifier certaines informations ou lier un commentaire. En outre, si vous mettez
à jour des données dans le référentiel, les informations d’affectation sont automatiquement mis
à jour.
Pour plus d’informations sur comment mettre en place des affectations, voir Affectation
d’éléments à un Business Model, page 29
La vue Assignment répertorie les éléments sélectionnés dans le Repository et qui ont été affectés à un
élément du Business Model.
Eléments Description
Job designs Si la représentation graphique d’un job est
disponible, elle peut être réutilisée comme
métadonnée du business model actif.
Metadata Toute donnée descriptive conservée dans le
référentiel peut être affectée à un objet de la vue. Il
peut s’agir par exemple, des coordonnées de
connexion à une base de données.
Business Model Vous pouvez réutiliser comme métadonnées tout
business model conservé dans le référentiel de ce
projet.
Documentation Tout type et format de document. Il peut s’agir de
documentation technique, de spécifications en
format texte ou d’une simple description de vos
bases de données.
Routines Si vous avez développé des routines,
d’automatisation de tâches, par exemple, vous
pouvez les affecter à votre business model.
Pour plus d’informations concernant les éléments du Repository, voir également: Conception d’un Job
Design, page 31
Suivez la procédure qui convient au type de modification que vous souhaitez effectuer :
Cliquez sur le libellé du business model courant dans le Repository pour afficher les Propriétés
principale correspondantes, dans l’onglet Main.
Apportez vos modifications dans le champ Name. Le libellé est automatiquement changé dans le
référentiel et apparaîtra dans l’onglet du processus au niveau de l’espace de modélisation la
prochaine fois que vous l’ouvrez.
Dans Repository > Business model, cliquez droit sur le libellé du business model que vous
souhaitez copier, et sélectionnez Copy dans le menu contextuel, ou utilisez le raccourci clavier
Ctrl+c.
Puis cliquez droit à l’endroit où coller le business model et sélectionnez Paste.
Pour déplacer un business model d’un emplacement à un autre dans votre répertoire Business
models sélectionnez un business model dans l’arborescence Repository > Business Models.
Puis glissez-déposez le à son nouvel emplacement. Alternativement, cliquez droit sur le libellé du
business model et sélectionnez Move dans le menu contextuel.
Cliquez droit sur le libellé du business model à supprimer, et sélectionnez Delete dans le menu
contextuel.
Alternativement, sélectionnez le business model dans l’arborescence du référentiel et simplement
glissez et déposez le dans la corbeille ( Recycle bin) du Repository .
Pour sauvegarder un business model, cliquez sur File > Save ou utilisez le raccourci clavier Ctrl+s. Le
modèle est sauvegardé sous le nom que vous lui avez donné au moment de sa création.
Un astérisque apparaît au niveau de l’onglet du nom de la vue métier dans l’éditeur graphique pour
indiquer que des modifications ont été apportées à la vue courante mais elles ne sont pas encore
enregistrées.
Ce chapître s’adresse aux programmeurs et responsables Informatique qui souhaitent mettre en place les
aspects techniques d’un job basé (ou non) sur un business model.
Talend Open Studio vous aide à développer et mettre en application votre job d’extraction, de
transformation et de chargement de flux de données.
Objectifs
Un job est la couche d’exécution ou l’implémentation technique d’un business model. Il traduit les
besoins métier en code et se charge d’exécuter ce dernier. En d’autres termes, le job met en place votre
flux de données.
Le Job Design est la représentation graphique fonctionnelle de ce processus technique.
A partir de Talend Open Studio, vous pouvez:
• mettre en place les actions de votre job à l’aide d’une bibliothèque de composants techniques.
• changer les paramètres par défaut des composants ou créer de nouveaux composants ou famille
de composants qui correspondent au mieux à vos besoins.
• paramétrer les connexions et relations entre composants afin de définir la séquence et la nature
des actions.
• accéder au code généré du programme ou des composants pour le modifier ou le documenter.
• créer et ajouter des éléments au Repository (référentiel) à des fins de réutilisation et de partage
(avec d’autre projets ou d’autre processus ou à moyen terme avec d’autres utilisateurs).
Lancez Talend Open Studio suivant la procédure décrite dans la section Accès à Talend Open Studio,
page 3.
Dans la fenêtre Talend Open Studio, cliquez sur Job Designs pour développer l’arborescence des jobs.
Vous pouvez créer des répertoires via le menu contextuel afin de faciliter la gestion de vos jobs. Cliquez
droit sur le noeud Job Designs de l’arborescence du référentiel, et sélectionnez Create folder.
Renseignez le champ Nom et cliquez OK.
Si vous avez déjà créé des jobs que vous souhaitez déplacer dans ce nouveau répertoire, simplement
glissez et déposez les dans le répertoire.
Champs Description
Name Saisissez un nom pour le nouveau job. Un message d’erreur s’affiche si vous
saisissez des caractères interdits.
Purpose Saisissez toute information que vous jugerez utile concernant l’utilisation du
job.
Description Saisissez une description si nécessaire.
Author Ce champ est en lecture seule car il reprend par défaut le login utilisateur
courant.
Version La version indiquée est en lecture seule. Vous pouvez cependant incrémenter
manuellement la version à l’aide des boutons M et m.
Status Vous pouvez définir le statut du processus dans vos préférences TOS. Par
défaut aucun statut n’est défini. Pour les définir, cliquez sur le menu Window
> Preferences > Talend >Status.
Le Designer s’ouvre sur un onglet de modélisation vide, indiquant simplement le nom du nouveau
job.
Note: Vous pouvez créer autant de jobs que vous le souhaitez. Un système d’onglets en haut
de l’éditeur vous permet de naviguer facilement entre tous les jobs ouverts.
Le Designer est composé des vues suivantes:
• L’éditeur graphique Talend Open Studio
• Une Palette de composants et de connexions spécifique à la conception de job designs.
• Un onglet Properties présente toutes les informations spécifiques sur tout ou partie de la
représentation graphique du job.
Si vous concevez un job pour la première fois dans Talend Open Studio, l’espace de modélisation
s’ouvre sur un éditeur vide.
Si vous ouvrez un job existant, l’éditeur graphique s’ouvre sur la dernière vue sauvegardée du job.
Pour commencer, cliquez sur un Component de la Palette. Puis cliquez à nouveau pour le déposer
dans l’espace de modélisation et ainsi l’ajouter à votre job design.
Si la Palette n’est pas visible, voir Afficher/Cacher la palette, page 34.
Afficher/Cacher la palette
La Palette contient les éléments plus ou moins complexes fournis par défaut et rassemblés en
famille. Par défaut, la palette est cachée sur le côté droit de l’espace de modélisation (Designer).
Si vous souhaitez que la Palette soit visible en permanence, cliquez sur la flèche de gauche
dans le coin supérieur droit du designer.
Dans une utilisation avancée de Talend Open Studio, vous serez capable d’ajouter ou de
dupliquer et modifier les composants de cette palette.
Pour connaître les propriétés spécifiques de chacun des composants, voir Composants,
page 95.
Vous pouvez déplacer tous les onglets de Talend Open Studio selon vos besoins.
Cliquez sur la bordure ou sur l’onglet, maintenez le bouton de la souris enfoncé pendant que vous
déplacez la fenêtre vers l’emplacement cible, puis relachez.
Cliquez sur la croix pour faire disparaître une fenêtre de la vue.
Pour restaurer une fenêtre fermée, cliquez sur Window > Show View > Talend. Puis cliquez sur le
nom de la fenêtre que vous souhaitez restaurer dans la vue courante de votre job ou consultez
Raccourcis clavier, page 93.
Lorsqu’un composant n’est pas correctement configuré ou si une connexion vers un autre
composant manque, une croix blanche sur fond rouge ou un signe attention apparaît.
Placez le pointeur de la souris sur le composant pour faire apparaitre les messages d’erreurs et
d’avertissement. Cette aide contextuelle vous informe sur les données manquantes ou le statut du
composant.
Il existe divers types de connexions qui définissent soit la donnée à traiter soit l’enchainement logique
du job. Cliquez droit pour choisir le type de connexion qui convient au composant sélectionné. Une fois
que vous avez sélectionner un type de connexion, le pointeur de la souris change dans l’éditeur
graphique.
Lorsque vous glissez le pointeur du composant source vers le composant cible, une prise
électrique symbolise le branchement en cours et un signe interdit indique que le composant cible
n’est pas valide. Le cercle barré ne disparait qu’une fois le composant valide atteint.
Types de connexion
Seule les connexions autorisées pour le composant sélectionné dans l’éditeur graphique sont
proposées dans la liste du menu contextuel.
Main row
La connexion Row de type Main est la connexion la plus courante. Elle transmet les flux
de données d’un composant à l’autre, bouclant sur chacune des lignes pour lire ou extraire
les données selon la définition des propriétés du composant.
Les données transférées à travers les connexions de type Row sont caractérisées par une
définition de schéma qui décrit la structure des données dans le fichier d’entrée.
Note: Vous ne pouvez pas connecter deux composants d’entrée à l’aide d’une
connexion de type main Row.
Note: Une seule connexion entrante de type Row est possible par composant. Dans
certains cas, la seconde connexion Row se transforme en connexion Lookup
automatiquement. Mais de manière générale, vous ne pourrez pas relier deux
fois le même composant cible avec une connexion main Row.
Pour en savoir plus sur les cas spécifiques de connexions Row multiples, voir Job à
entrées/sorties multiples, page 39.
Lookup row
La connexion de type Lookup est une connexion Row reliant un composant d’un flux
secondaire à un composant d’un flux principal. Cette connexion est uniquement disponible
dans le cas d’utilisation de flux multiples.
Vous pouvez transformer une connexion de type Lookup en connexion de type main Row,
et inversement vous pouvez changer une connexion Lookup en Main Row. Pour ce faire,
cliquez droit et sélectionnez Set this connection as.
Voir également : Job à entrées/sorties multiples, page 39.
Output row
La connexion de type Output est une connexion Row, traitant donc de la donnée, et qui
relie un composant (généralement de transformation) à un composant de sortie. Les sorties
d’un job pouvant être multiples, une boîte de dialogue s’affiche pour vous demander de
nommer chacune des connexions.
Note: Le système se souvient également du nom des connexions de sortie
supprimées (ainsi que des propriétés définies). Dans la liste des connexions
outputs suggérées, vous retrouvez ainsi les connexions supprimées. Cette
fonctionnalité vous permet de ne pas avoir à resaisir toutes les informations
de propriétés.
Voir également : Job à entrées/sorties multiples, page 39.
Si vous avez besoin de manipuler des données de sources multiples et/ou vers des sorties multiples,
et que vous souhaitez tout integrer en un seul processus de transformation, il est préférable d’utiliser
le composant de mapping, tMap qui est conçu pour ce type de besoin.
Pour plus d’informations concernant le mapping et la transformation de donnée, voir Mapping de
données page 70.
Pour plus d’informations concernant le composant tMap et son utilisation, voir tMap page 131..
Les informations de l’onglet Properties fournissent des données détaillées sur le processus en sélection.
L’onglet Main rappelle notamment des informations relatives à l’auteur ainsi qu’au nom de processus
que vous avez défini lors de la création. Les autres onglets permettent de paramétrer plus précisément
le processus ou le composant sélectionné.
Onglet Main
Cet onglet fournit des informations générales sur le composant sélectionné. Les valeurs de champs
sont fournies par le composant lui-même et seront utilisées dans le code généré du processus.Par
conséquent, tous ces champs sont en lecture seule, à l’exception de la case d’activation, Activate.
Champs Description
Unique Name Identifiant unique. affecté automatiquement par le
système afin d’être réutilisé dans le code du processus.
Version Version du composant, indépendante de la version du
produit dans son ensemble.
Family Famille des composants dont la fonction est proche. Ce
champ peut être modifié et de nouvelles familles de
composants peuvent ainsi être créées.
Activate Cochez cette case pour activer et désactiver le
composant sélectionné ainsi que ses processus liés.
tStatCatcher Cochez cette case pour autoriser le composant
tStatCatcher à aggréger les données de traitement tel
que défini dans les propriétés du composant
tStatCatcher, page 177
La case Activate active la fonction du composant ainsi que le sous-job auquel il appartient, afin que
du code soit généré lors de son exécution.
Si la case Activate n’est pas cochée, aucun code ne peut être généré pour ce composant mais
également pour toutes les branches liées directement à lui dans le processus.
Pour plus d’informations concernant l’activation et la désactivation, voir Activation/Désactivation
d’un job ou sous-job, page 84.
Onglet View
L’onglet View de la fenêtre Properties vous permet de changer le format d’affichage par défaut
d’un composant dans l’éditeur graphique.
Champ Description
Label format Libellé librequi s’affiche au niveau de l’éditeur graphique. Des variables
peuvent être utlisées pour retrouver et afficher des valeurs d’autres champs.
L’aide contextuelle de ce champ fournit généralement la variable
correspondante où la valeur du champ est stockée.
Hint format Bulle contextuelle apparaissant lors que vous passez la souris au dessus du
composant.
Show hint Cochez cette case, pour activer la fonctionnalité d’indication contextuelle.
Vous pouvez personnaliser les textes des Label et Hint à l’aide des balises HTML suivantes :
• Gras: <b> LibelléOuBulle </b>
• Italique: <i> LibelléOuBulle </i>
• Retour chariot: LibelléOuBulle <br> ContinueLigneSuiv
• Couleur: <Font color= ‘#RGBcolor’> LibelléOuBulle </Font>
Pour changer vos préférences de cet onglet View, cliquez sur
Window>Preferences>Talend>Designer.
Onglet Documentation
N’hésitez pas à ajouter tout commentaire ou morceau de texte que vous jugerez utile dans Comment.
Le contenu de ce champ Comment sera formaté à l’aide du markup Pod et sera intégré au code
généré sous forme de commentaires.
Vous pouvez visualiser votre commentaire sous l’onglet Code de l’éditeur graphique.
Vous pouvez également ajouter le contenu de votre commentaire, ou documentation, dans l’aide
contextuelle d’un composant en utilisant la variable associée (_COMMENT_).
Pour une utilisation avancée de la fonction Documentations, il est préférable d’utiliser la partie
Documentation du référentiel, qui vous permet de conserver et réutiliser tout type de documentaiton.
Onglet Properties
Chaque composant possède des propriétés spécifiques qui rassemblées sous l’onglet Properties de
la fenêtre Properties.
Voir la section Composants, page 95 pour plus d’informations sur les champs à renseigner.
Pour tous les composants, vous pouvez centraliser les informations de propriétés dans des fichiers
de metadonnées, placés dans le répertoire Metadata du Repository. Sélectionnez Repository dans
le champ Property type et désignez le fichier de métadonnées comportant les paramètres
appropriés. Voir également : Définition des schémas de métadonnées, page 45.
Pour tous les composants en entrée, de type Input, vous pouvez définir le schéma décrivant les
données à traiter. Tout comme, les informations de propriétés, ce schéma peut être ponctuel ou local
(built-in) ou centralisé dans le Repository.
Vous pouvez récupérer le schéma ponctuel d’un fichier d’entrée pour alimenter le schéma de
sortie. Pour ce faire, cliquez sur le bouton Sync columns dans les propriétés du composant
Output.
Vous pouvez apporter des modifications au schéma répository que vous utilisez pour votre
processus. Cependant, notez que le schéma devient alors ponctuel, et ses propriétés changent
automatiquement en built-in, et il sera rattaché au job courant.
Note: Vous ne pouvez pas modifier le schema distant à partir de cette fenêtre. Pour
apporter une modification, accédez au fichier de métadonnées à partir du
référentiel
Voir également : Définition des schémas de métadonnées, page 45
Le composant Start est le composant de début de processus qui a pour rôle de déclencher ce dernier. Il
peut y avoir plusieurs composants Start dans un job design si plusieurs traitements de flux s’exécutent
en parallèle. Mais pour un même flux ainsi que les flux secondaires connectés, un seul composant peut
être Start.
Cliquez et déposez un composant dans l’éditeur graphique. Tous les composants susceptibles d’être un
composant Start, prennent une couleur d’arriere plan distinctive (vert). Vous pouvez remarquer que la
plupart des composants peuvent être des composants Start et débuter un processus.
Seuls certains composants ne peuvent être start, notamment le composant tMap, par exemple.
Pour identifier quel composant d’un processus débutera le processus, distinguez d’abord le flux
principal des flux secondaires de votre job.
• Le flux principal doit connecter un composant à un autre, à l’aide d’une connexion de type Row
main. Le composant Start est alors automatiquement défini sur le premier composant du flux
principal (icone dont l’arrière plan est vert).
• Les flux secondaires sont connectés à l’aide de connexion de type Row lookup et non plus main.
Cette connexion Lookup tient lieu de référence, qui enrichit le flux principale de nouvelles
données.
Vous pouvez changer le statut du composant Start et par conséquent le flux principal et secondaire, en
modifiant une connexion Row Main en connexion Lookup, simplement via un simple clic droit sur la
connexion.
Voir également :
• Connexion des composants, page 36
• Activation/Désactivation d’un job ou sous-job, page 84
Talend Open Studio est une solution orientée métadonnées, et de ce fait, peut vous aider à garantir
l’homogéneité et la qualité des données traitées par votre job design.
Deux étapes principales vous permettent de mettre en place des schémas de métadonnées à partir de
fichiers ou de bases de données.
Dans un premier temps, configurez la connexion vers un fichier ou une base de données. Puis définissez
le schéma basé sur une ou plusieurs tables de la base de données ou sur les métadonnées du fichier.
Pour créer un fichier de schémas basés sur une base de données, suivez la procédure en deux phases,
décrite ci-dessous.
Cliquez droit sur Db Connections puis sélectionnez Create connection dans le menu contextuel.
Cliquez Next une fois terminé, l’étape suivante vous permet de renseigner les données de
connexion à la BDD.
Etape 2: Connexion
Sélectionnez le type de Base de données, champ DB type, à laquelle vous souhaitez vous
connecter. Certains champs sont activés et d’autres grisés selon la nature de la connexion.
Renseignez les informations requises pour la connexion et vérifiez votre connexion à l’aide de
la fonction Check.
Si nécessaire, remplissez les Propriétés de base données, dans la zone Database Properties.
C’est tout pour la première phase de configuration d’une connexion Base de données. Cliquez
sur Finish pour valider.
A présent, cliquez droit sur la connexion nouvellement créée, et sélectionnez Create schema
dans le menu contextuel.
Les métadonnées de type File Delimited peuvent être utilisées à la fois pour définir les propriétés
des composants InputFileDelimited mais également InputFileCSV car tous deux sont basés sur la
même structure.
WARNING—La création de schémas de fichier est similaire pour tous les types de fichiers: Delimited
(délimités), Positional (positionnels), Regex (Expr. Régulières), XML ou Ldif.
Dans le référentiel (Repository), cliquez droit sur File Delimited dans l’arborescence, et
sélectionnez Create file delimited dans le menu contextuel.
Sélectionnez le Format du système d’exploitation dans lequel le fichier a été créé. Cette
information est utilisée pour pré-remplir les champs des étapes suivantes. Si la liste ne propose
pas le format approprié, ignorez ce champ.
Le File viewer donne un instantané du fichier chargé. Il vous permet de vérifier la cohérence
du fichier, la présence d’un en-tête et plus généralement la structure du fichier.
Cliquez sur Next pour passer à l’étape 3.
Paramétrez l’Encoding, ainsi que les séparateurs de champs et de lignes (Field separator et
Row separator) dans les paramètres Delimited File.
En fonction de votre type de fichier (csv ou delimited), vous pouvez également paramétrer des
caractères d’inclusion et d’exclusion (respectivement Text Enclosure et Escape character).
Si l’aperçu du fichier indique un message d’entête, vous pouvez exclure cet entête de l’analyse.
Indique le nombre de lignes d’entête à ignorer. En outre, si le fichier contient des information
de pied de page, indiquez que le nombre de lignes à ignorer.
Le champ Limit of rows vous permet de restreindre l’étendue du fichier qui fait l’analyse.
Dans le panneau File Preview, vous pouvez visualiser l’impact de votre paramétrage.
Cochez la case Set heading row as column names pour transformer la première ligne analysée
en libellés des colonnes du schéma. Notez que le nombre de lignes d’entête à ignorer (champ
Rows to skip) est incrémenté de 1.
Cliquez sur Refresh dans le panneau d’aperçu, afin de les modifications de paramétrage
prennent effet.
Si le fichier délimité sur lequel est basé le schéma est modifié, utilisez le bouton Guess pour
re-générer le schéma. Notez que si vous personnalisez le schéma, la fonctionnalité Guess ne
retiendra pas ces modifications.
Cliquez Finish pour valider. Le nouveau schéma apparaît dans l’arborescence du Repository,
sous le noeud de la connexion File Delimited appropriée.
Dans le Repository, cliquez droit sur File Delimited dans l’arborescence, puis sélectionnez Create
file positional dans le menu contextuel.
Procédez de la même manière que pour une connexion au fichier délimité. Cliquez droit sous
Metadata dans le Repository, puis sélectionnez Create file positional.
L’aperçu du fichier donne un instantané du fichier et vous permet de placer les marqueurs de
position.
Cliquez sur l’aperçu du fichier et définissez la position des marqueurs sur la règle. Une flèche
de couleur orange vous aide à affiner la position du marqueur.
Le séparateur de champ (Field Separator) répertorie une série de chiffres séparés par des
virgules. Ces chiffres correspondent aux nombres de caractères entre les marqueurs.
L’astérisque symbolise tous les caractères restants jusqu’a la fin de la ligne, à partir du marqueur
précédant.
La position de champ (Field Position) indique la position exacte du marqueur sur la règle. Vous
pouvez affiner la position du marqueur en saisissant la valeur exacte de position.
Vous pouvez placer autant de marqueurs que nécessaire. Pour retirer un marqueur, faites le
glisser vers la règle.
Cliquez sur Next pour continuer.
Les schémas de fichier Regex servent pour manipuler les fichiers dont les information sont
redondantes, tels que les fichiers log.
Procédez de la même façon que pour les connexion de fichier délimité ou positionnel. Cliquez droit
sur Metadata dans le Repository et sélectionnez Create file regex.
Comme pour la création d’un schéma Delimited File, le format est demandé pour pré-remplir
des champs des étapes suivantes. Si le système d’exploitation de création du fichier n’est pas
proposé dans la liste, ignorez ce champ.
L’aperçu de fichier fournit un instantané du fichier chargé Next pour définir la structure du
schéma.
Puis cliquez sur Refresh preview pour que les modifications soient prises en compte. Le bouton
change d’apparence en Wait jusqu’a ce que l’aperçu soit rafraichi.
Cliquez sur Next une fois le paramétrage terminé. La dernière étape génère un schéma de fichier
Regex.
Les fichiers LDIF sont des fichiers annuaires distincts par leurs attributs. Les métadonnées FileLDIF
centralisent ces fichiers de type Ldif ainsi que leur description d’attributs.
Procédez de la même façon que pour les connexions de fichier délimité ou positionnel. Cliquez droit
sur Metadata dans le Repository et sélectionnez Create file ldif.
Note: Assurez-vous que les modules Perl requis pour l’utilisation de cette fonctionnalité
sont bien installés. Pour plus d’infos, visitez http://talendforge.org/wiki/doku.php.
Cliquez sur Refresh Preview pour prendre en compte dans l’aperçu du fichier, les attributs
sélectionnés.
Note: DN est volontairement omis de la liste des attributs proposés car cet attribut clé
est automatiquement inclus dans l’aperçu de fichier, par conséquent dans le
schéma généré.
Centralisez vos requêtes XPath de fichier XML défini et regroupez les valeurs récupérées.
Procédez de la même façon que pour les connexions de fichier délimité ou positionnel. Cliquez droit
sur Metadata dans le Repository et sélectionnez Create file XML.
Dans le champ XPath loop expression, saisissez l’expression de Xpath absolu du noeud qui fait
l’objet de l’itération. Vous pouvez saisir l’expression entière ou appuyez sur Ctrl+Space pour
utiliser la liste d’autocomplétion.
Alternativement, glissez et déposez le noeud sélectionné dans la structure source vers le champ
XPath du schéma cible.
Note: Le champ Xpath loop expression est obligatoire.
Vous pouvez également définir une limite de boucle dans le champ Loop limit, pour restreindre
le nombre de noeuds à itérer. Un lien de couleur verte est ainsi créé.
Définissez les champs à extraire en glissant et déposant les noeuds sélectionnés vers le champ
Relative or absolute XPath expression.
A l’aide du signe Plus, ajoutez des lignes à la table et sélectionnez autant de champs à extraire
que vous souhaitez. Appuyez sur Ctrl ou Maj pour la sélection multiple des noeuds qu’ils soient
groupés ou non. Puis glissez et déposez les sur la table.
Dans le champ Tag name, nommez les libellés de colonnes quis’afficheront dans la vue d’aperçu
du schéma (Schema preview).
Le lien de la sélection s’affiche de couleur bleue, tous les autres liens sont gris. Vous pouvez
imposer un ordre dans les champs à extraire à l’aide des flèches haut et bas.
Cliquez sur Refresh preview pour afficher l’aperçu du schéma. Les champs apparaissent ainsi
dans l’aperçu du schéma dans l’ordre imposé.
SQLBuilder vous permet de construire des requêtes SQL et de contrôler les modifications et écarts entre
tables de base de données et tables de métadonnées (stockées dans le référentiel ou intégrées en
“built-in” directement dans les propriétés du composant). Cet éditeur est disponible pour tDBInput et
tDBOutput.
Renseignez les informations de connexion DB et sélectonnez l’entrée de référentiel approprié si vous
l’avez défini.
Supprimez la déclaration de requête présentée par défaut dans le champ Query des propriétés du
composant. Puis ouvrez l’éditeur de requête SQL.
Dans la vue Database structure, s’affichent toutes les tables stockées dans l’entrée de métadonnées
DB Connection du Repository ou, dans le cas d’un schéma de type built-in, les tables de la base de
données elle-même.
Note: la connexion à la base de données, dans l’usage d’un schéma en built-in ou dans le cas
d’une opération de rafraichissement du schéma de repository, peut prendre du temps.
Cliquez sur l’icone de rafraîchissement pour afficher les différences entre les tables de métadonnées
d’une DB connection, et les tables de la base de données elle-même.
Les icones de la colonne Diff indique la présence de différence ou d’écarts entre les tables.
Développez l’arborescence d’une table pour identifier la colonne exacte présentant des différences.
Le surlignage rouge indique que le contenu de la colonne comporte des différences ou que cette
colonne n’est pas présente dans la table équivalente de la base de données elle-même.
Le surlignage bleu indique que la colonne est présente dans la base de données elle-même mais
qu’elle n’est pas présente dans la table de la métadonnée.
L’éditeur de requête est un système multi-onglets vous permettant de construire autant de requêtes
que vous le souhaitez.
Pour construire une nouvelle requête, vous pouvez cliquer-droit sur la table ou sur une colonne de
la table et sélectionnez Generate Select Statement dans le menu contextuel. Ou cliquez sur l’onglet
vide présenté par défaut et saisissez votre requête.
La bulle informative affiche le détail de l’objet sélectionné, par exemple, le chemin d’accès complet
à la table ou section de table. Une fois que votre requête est terminée, exécutez la à l’aide du bouton
Execute symbolisé par un homme qui court.
La barre d’outils de l’éditeur de requête vous permet d’accéder rapidement aux commandes usuelles
telles que : exécuter (execute), ouvrir (open), enregistrer (save) et supprimer (clear).
Dans la vue de résultats de la requête, s’affichent les résultats de la requête courante.
La barre d’état en bas de la fenêtre de l’éditeur fournit des informations concernant les temps
d’exécution et le nombre de lignes récupérées.
Mapping de données
Pour gérer des flux multiples en entrée et/ou en sortie, ainsi que les transformations et redirection de
données, il est recommandé d’utiliser le composant tMap. La section suivante présente les principes
d’usage de ce composant, pour d’autres informations ou use cases, voir tMap page 131.
tMap utilise les connexions entrantes pour préremplir les schéma d’entrée dans le Mapper. Par
conséquent, vous ne pouvez pas créer directement dans le Mapper, de nouveaux schémas d’entrée.
Par contre, il vous faut mettre en place autant de connexion de type Row entrantes que nécessaire,
pour que leur schéma s’affiche dans le Mapper.
De la même façon, créez autant de connexions de sortie que nécessaire dans l’éditeur graphique. LE
Mapper vous permet de définir le type de donnée par sortie via un outil graphique de mapping.
Note: Il ne peut y avoir une seule connexion entrante de type Main row. Toute connexion
entrante supplémentaire devient automatiquement une connexion Lookup. Voir
également: Connexions de type Row, page 36
Les connexions Lookup sont des connexions entrantes secondaires (ou de référence). Ces données
de référence peuvent dépendre directement ou indirectement du flux principal. Cette relation de
dépendance se traduit graphiquement par un Join et la création de clés d’expression.
Bien que le mapper requiert que les connexions soient mises en place pour définir les flux d’entrée
et de sortie (respectivement Input et Output), vous devez également implémenter un mapping pour
que la fonction d’aperçu de l’éditeur de mapping soit disponible dans le panneau Properties de
l’espace de modélisation.
Double-cliquez sur l’icone tMap dans l’éditeur graphique ou cliquez sur le bouton en regard du
champ Map editor dans l’onglet Properties. L’éditeur de mapping s’ouvre dans une nouvelle fenêtre.
Mapper
tMap est un composant dit avancé qui requiert plus d’informations de propriétés que les autres
composant. Par conséquent le Mapper est l’outil le mieux adapté pour définir tous les paramètres
nécessaires au mapping, à la transformation et l’aiguillage des données dans votre processus, par
l’intermédiaire de son interface graphique conviviale.
Vous pouvez réduire et restaurer la fenêtre de toutes les tables contenues dans l’éditeur de mapping,
à l’aide des boutons dans coin supérieur gauche de chacune des fenêtres.
Paramètres Input
L’ordre des tables (ou schémas) Input est essentiel.
La première table reflète la connexion du flux principal (Main
Row) et pour cette raison est traitée en priorité dans le
composant tmap.
Par conséquent vous ne pouvez pas déplacer ce schéma vers
un niveau inférieur, sans risquer de perdre les éventuelles
relations de dépendance (Join) que vous avez créées.
Vous pouvez utiliser les flèches haut et bas pour intervertir des
tables secondaires (provenant d’une connexion Lookup),
mais vérifiez qu’elles ne sont pas liées par un lien Join. Si elle
le sont, veillez à ce que le lien Join ne soit pas perdu.
Voir également: Lier des tables input, page 75.
Le contenu des connexions secondaires (Lookup) est reproduit dans les autres tables. Si
vous n’avez pas encore défini de schéma pour un composant d’entrée, la table
correspondante du Mapper est vide.
Le champ Clé (Key) est également repris du schéma défini dans les propriétés du composant
Input.
Vous pouvez réutiliser les données stockées dans la zone Variables ou utiliser les variables
globales ou contextuelles. Appuyez sur Ctrl+Space pour accéder à la liste complète des
variables combinant variables de contexte et variables globales. La liste de variables
proposée varie selon le contexte et s’accroit au fur et à mesure des nouvelles créations.
Seules les variables valides pour le mapping en cours, sont affichées dans la liste
d’auto-complétion.
Une fenêtre de métadonnées est annexée à la liste de semi-complétion des variables. Elle
fournit des informations concernant la colonne sélectionnée.
Voir également: Mapping de variables, page 77
Joins Inner
Le join Inner es un Join standard sur une table définie comme table d’Inner Join. Ce Join
se distingue des autres Joins par la façon dont le rejet est effectué. Si les données de la table
définie en tant que table d’Inner Join ne peuvent être reprises, en d’autres termes, le Join
Inner ne peut être établi, quelle qu’en soit la raison, dans ce cas, les données demandées sont
rejetées vers la table de sortie définie comme table de rejet du Join (Join Reject).
En pratique, créez un Join entre la table d’entrée du flux principal (Main) et une table
secondaire (Lookup) puis cochez la case Inner Join, pour définir cette table lookup comme
table d’Inner Join.
Note: Assurez-vous que la table d’Inner Joint (comme toute autre table Join)
contient un champ Key défini. Dans le cas contraire, des erreurs d’exécution
peuvent se produire.
Dans la zone Output, cliquez sur le bouton Inner Join Reject, pour définir la sortie de rejet
d’Inner Join.
Note: Une table de Join Inner doit toujours être couplée à une table Inner Join
Reject.
Mapping de variables
La table Variables regroupe toutes les variables de mapping, qui peuvent être utilisées à
différents endroits du mapper.
Vous pouvez également utiliser le champ Expression de la table Var pour réaliser les
transformations, en y saisissant des commandes Perl.
Les variables vous permettent de gagner du temps et vous évitent d’avoir à ressaisir plusieurs
fois les mêmes données.
Sélectionnez une entrée dans la zone Input ou appuyez sur la touche Maj, pour effectuer une
sélection multiple.
Appuyez sur la touche Ctrl pour sélectionner des entrées dispersées dans une table ou pour
sélectionner des entrées de diverses tables. Lorsque vous sélectionnez plusieurs entrées, la
première sélection peut prendre une couleur grisée.
Maintenez la touche Ctrl enfoncée pour glisser-déposer toutes les entrées en une fois. Une bulle
d’aide contextuelle vous indique le nombre d’entrées sélectionnées.
Puis déposez la sélection vers la table Var. Plusieurs types de glisser-déposer sont possibles,
notamment:
Paramètres Output
Dans l’espace de modélisation de Talend Open Studio, la création d’une connexion Row à
partir du composant tMap vers des composants en sortie, a pour effet d’ajouter les schémas
Output correspondants dans la zone Output du Mapper.
Vous pouvez également ajouter un schéma Output, dans votre Mapper, à l’aide du signe plus de
la barre d’outils de la zone Output.
A la différence de la zone Input, l’ordre des tables de schémas Output n’a pas une grande
importance, car il n’existe aucune relation de subordination (Join) entre les sorties.
Une fois que vous avez créé toutes les connexions de sortie, et de ce fait, toutes les tables Output,
vous pouvez sélectionner et organiser les données de ces sorties.
Glissez-déposez une ou plusieurs entrées à partir de la zone Input directement vers la table
Output appropriée.
Appuyez sur Ctrl ou Maj pour une sélection multiple.
Ou vous pouvez utiliser des expressions de la zone Var par glisser-déposer dans la table Output
avec les données réutilisables appropriées.
Notez que si vous apportez des modifications à la colonne Input de l’éditeur Schema, une boîte
de dialogue vous demande de confirmer la propagation des modifications sur toutes les entrées
Input/Variables/Ouput concernées.
Action Résultat
Glisser-déposer vers des expressions Concatène l’expression sélectionnée, vers des
existantes expressions existantes.
Glisser-déposer vers une ligne Insère une ou plusieurs nouvelle entrée en début ou en
d’insertion fin de table ou entre deux lignes existantes.
Glisser-déposer + Ctrl Replaces highlighted expression with selected
expression.
Glisser-déposer + Maj Ajoute les champs sélectionnés à toutes les
expressions en surbrillance. Insère de nouvelles lignes
si nécessaire.
Glisser-déposer + Ctrl + Maj Remplace toutes les expressions en surbrillance par les
champs sélectionnés. Insère de nouvelles lignes si
nécessaire.
Vous pouvez ajouter des filtres et un rejet pour personnaliser vos sorties.
Filtres
Les conditions de filtre vous permettent de sélectionner les champs et les envoyer vers les
sorties appropriées.
Cliquez sur le bouton plus pour ajouter une ligne de filtre.
Vous pouvez saisir librement vos conditions de filtre à l’aide d’opérateurs et de fonctions
Perl.
Glissez-déposez des expressions d’une zone Input ou d’une zone Var vers l’entrée de Filtre
de la table Output appropriée.
Un lien graphique de couleur orange apparaît. Ajoutez l’opérateur Perl nécessaire pour
finaliser votre formule de filtre.
Vous pouvez créer plusieurs filtres sur différentes lignes. L’opérateur AND est la
conjonction logique de toutes les filtres formulées.
Rejets
L’option Reject définit la nature d’une table Output particulière.
Cette table de rejet rassemble toutes les données qui ne satisfont pas un ou plusieurs des
filtres définis dans les tables Output régulières. Notez que par table régulière sont désignées
toutes les tables qui ne sont pas des tables de rejet.
Ainsi les données rejetées des tables de sortie régulières sont regroupées dans une ou
plusieurs tables dédiées, vous permettant par conséquent d’identifier les erreurs ou les cas
imprévus.
Le principe de rejet (Reject) concatène tous les filtres des tables non-rejet et les définit
comme formulation ELSE.
Créez une table dédiée et cochez la case Reject pour la définir comme contrepartie Else des
tables régulières.
Vous pouvez définir plusieurs tables Reject, afin d’affiner les sorties multiples. Pour
différencier les variantes de rejets ajouter des lignes de filtre en cliquant sur le point
d’interrogation. Le signe plus ajoute un noveau filtre, le signe moins en retire.
Une fois qu’une table est définie comme table de rejet, le processus de vérification des
données, commencera par les tables régulières avant de prendre en considération les filtres
possibles des tables de rejet.
Les données ne sont pas exclusivement traitées vers une seule sortie. Même si une donnée
satisfait le filtre d’une sortie et qu’elle est donc routée vers elle, elle est également vérifiée
contre les autres filtres et peut également être routée vers d’autres sorties.
Pour configurer un flux de sortie (Output) en conteneur des données de rejet d’un Inner Join,
cliquez déposez un nouveau composant Output dans votre job design. Connectez le tMap à
ce nouveau composant. Dans le Mapper, ce nouveau flux de sortie apparaît dans la zone
Output. Cliquez sur le bouton Join Reject pour définir cette table comme table de rejet Inner
Join.
Expression editor
Toutes les formulations d’expressions (Input, Var ou Output) et de filtres peuvent être
visualisées et modifiées à partir de l’éditeur d’expression. Cet éditeur fournit le confort d’une
fenêtre dédiée pour écrire des fonctions ou des commandes de transformation.
Sélectionnez l’expression à modifier. Cliquez sur l’onglet Expression editor.
Saisissez le code Perl approprié pour l’opération à effectuer. La colonne Expression de la table
correspondante est automatiquement mise à jour.
Note: Les fonctions et opérateurs Perl sont décrits en détail dans la documentation Perl
installée en même temps que les fichiers ActivPerl.
Schema Editor
L’éditeur de schémas fournit les informations concernant les champs d’une table sélectionnée.
Utilisez la barre d’outils placée sous la table de schéma pour ajouter, déplacer et supprimer des
colonnes du schéma.
Vous pouvez également charger un schéma à partir du référentiel ou exporter le schéma courant
vers un fichier.
Métadonnées Description
Column Nom de colonne tel que défini dans le schéma du Mapper et dans le
schémas du composant Input ou Output correspondant.
Key La clé indique si la valeur de la clé d’expression devrait être utilisée
pour retrouver les données d’une autre table à travers un lien Join. Si
cette case est décochée, la relation Join est désactivée.
Type Type de données: chaine de caractères ou entier
Length -1 indique qu’aucune valeur de longueur a été définie dans le schéma.
Precision Précise la valeur de longueur de chaine, si spécifiée.
Nullable Décochez cette case si vous ne souhaitez pas autoriser les valeurs de
champs nulles.
Default Indique les valeurs par défaut, si elles sont définies.
Comment Champ texte libre. Saisissez tout commentaire que vous jugerez utile.
Note: Les schémas Input et les schémas Output sont indépendants les uns des autres.
Vous pouvez par exemple changer le libellé d’une colonne Output dans que le
libellé du schéma Input ne change.
Cependant toutes modifications apportées au schéma sont immédiatement reportées sur le
schéma correspondant de la zone Input ou Output appropriée, mais également au niveau des
propriétés elles-mêmes du composant Input ou Output concerné.
Un arrière-plan rouge s’affiche lorsqu’un caractère non valide a été saisi. La plupart des
caractères spéciaux sont interdits pour réduire les risques de mauvaises interprétation dans le
code. Les caractères autorisés sont : les minuscules et majuscules, les chiffres (à l’exception du
caractère de début de chaine).
Passez la souris sur le champ de couleur rouge, un bulle info affiche un message d’erreur.
Passez la souris au-dessus du champ invalide pour faire apparaitre le message d’erreur
correspondant.
Vous pouvez activer ou désactiver un composant et par ce biais, un processus entier ou un processus
secondaire (subprocess) directement connecté au composant sélectionné. Par défaut le composant est
activé.
Dans la fenêtre de propriétés Main du composant sélectionné, cochez ou décochez la case Activate.
Dans le cas où un composant Start est désactivé, les composants de tout type ainsi que les
connexions de toute nature, reliés directement et indirectement à lui, seront désactivés également.
Lorsque vous décochez la case Activate d’un composant standard (non Start), seuls le composant
en question et ses connexions directes sont désactivés.
Si un lien direct vers un composant désactivé est une connexion Row main (principale) vers un
processus secondaire, tous les composants de ce sous-job seront également désactivés.
Les contextes vous donnent la possibilité de gérer différemment vos jobs selon les conditions
d’utilisation.
Par exemple, vous pouvez intégrer dans votre cycle de validation plusieurs phases de test avant que vous
job design soit mis en production. Talend Open Studio vous offre la possibilité de mettre en place
plusieurs environnements similaires afin d’éviter de renseigner plusieurs fois les propriétés de tous les
composants.
Vous pouvez donc dédier un contexte au développement et un autre à la production. La seule différence
entre les deux contextes étant certaines valeurs de champs sensibles et l’échelle d’utilisation. Le
contexte de production serait par conséquent une simple reproduction du contexte de développement à
quelques différences près.
Cliquez dans l’éditeur graphique sans cliquer sur un composant, pour afficher le panneau de
configuration des contextes. Le panneau Context apparaît en bas de la fenêtre, au niveau de
l’emplacement des Properties généralement.
Pour modifier le nom d’un contexte, cliquez sur Rename et saisissez le nouveau nom de contexte
dans la boîte de dialogue qui s’affiche.
Pour ajouter un nouvel onglet, cliquez sur Copy. Le contexte par défaut est ainsi dupliqué dans un
nouvel onglet. Saisissez un nom pour le contexte qui vient d’être créé.
Lorsque vous copiez un contexte, la totalité des informations de contexte est copiée vers le nouveau
contexte. Il vous suffit donc d’apporter les modifications nécessaires à la nouvelle utilisation.
Un contexte est caractérisé par des paramètres. Ces paramètres sont des variables basées sur le
contexte qui seront ajoutées à la liste des variables disponibles pour réutilisation dans les propriétés
spécifique d’un composant, via la combinaison des touches Ctrl+Espace.
Ajoutez une ligne de paramètre à la table en cliquant sur Add puis renseignez les données générales
du job. Vous pouvez ajouter autant de paramètres que vous souhaitez. Le champ Script code indique
la variable correpondante qui sera créée. Sa valeur suit un script standard tel que
$_context{YourParameterName}.
Cochez la case Ask for confirmation?, si vous souhaitez avoir la possibilité de confirmer
l’utilisation de ce paramètre lors de l’exécution du processus. Cette option peut se revéler utile au
moment de la mise en production, lorsque le processus est prêt a passer d’un contexte de
développement au contexte de production, par exemple.
Si vous cochez la case Prompt, à côté de l’entrée de la variable, vous pourrez modifier la variable
lors de l’exécution d’un processus utilisant une variable de ce contexte.
Fields Description
Prompt Cochez cette case, si vous souhaitez que la variable soit modifiable au moment
d’exécuter le processus.
Name Nommez à la variable. Une variable de contexte est généralement utilisée par
différents composants, vous évitant ainsi d’avoir à resaisir les mêmes données.
Prompt message Si vous avez coché la case Prompt, renseignez ce champs pour personnaliser le
message de la boite de dialogue.
Type Sélectionnez le type de données, dans la liste.
Default Saisissez la valeur par défaut de cette variable. Vous pouvez utiliser ce champ pour
mettre à jour la variable ou pour mettre à jour toutes les propriétés appelant cette
variable.
Comment Ce champ est un commentaire libre.
Script code Ce champ est en lecture seule. Un code script est généré selon le nom de paramètre
saisi. Ce format de variable apparaît dans la liste des variables accessible via
Ctrl+Espace, à partir des propriétés d’un composant.
Notez que la variable ou le nom de paramètre suit des règles de saisie, notamment liées au caractères
interdits, tels que l’espace.
Variables et alias
Dans tous les champs de l’onglet Properties définissant les propriétés d’un composant, vous pouvez
utiliser une variable globale définie ou des variables de contexte.
Appuyez sur les touches Ctrl+Space pour afficher la liste complète des variables globales des
variables de contexte utilisées dans les functions Perl prédéfinies. Les variables de contexte sont
créées par l’utilisateur pour un contexte d’utilisation particulière, tandis que les variables globales
sont des variables système.
La liste s’allonge au fur et à mesure des créations de variables de contexte (ou variables utilisateur).
Voir également : Définition d’un contexte et de variables de job, page 85
• Donnez un nom (Name) à cette nouvelle variable et renseignez la zone Comment ainsi
que le Type.
• Saisissez la question de confirmation (Prompt) à afficher pour confirmer l’utilisation de
cette variable lors de l’exécution du job courant.
• Cochez la case Prompt for value pour afficher le champ en mode édition. Si vous avez
renseigner déjà le champ correspondant dans la vue Properties du composant, cette
valeur est automatiquement reprise dans le champ Default Value.
• Cliquez sur Finish pour valider. Cliquez dans l’espace de modélisation de votre job,
l’onglet Properties du job entier s’affiche. Remarquez que la liste des paramètres de
contexte intègre la variable nouvellement créée.
Requêtes StoreSQL
StoreSQLQuery est une variable de contexte spécifique, dans le sens où elle est configurée par
l’utilisateur et non par le système. Cette variable est dédiée principalement au débogage.
StoreSQLQuery diffère des autres variables de contexte dans le fait qu’elle sert principalement
de paramètre pour une variable globale spécifique, dîte Query. Elle vous permet d’alimenter
dynamiquement la variable globale de requête.
La variable globale Query est disponible dans la liste d’autocomplétion (Ctrl+Espace) des
propriétés des composants de type DB input.
Pour plus d’informations sur le paramétrage de StoreSQLQuery, voir Composants page 95.
Vous pouvez sélectionner le contexte dans lequel vous souhaitez exécuter votre job.
vous avez coché la case Prompt lors de la définition du contexte, une boîte de dialogue s’affiche
pour vous demander de confirmer ou modifier la valeur de la variable utilisée pour cette exécution.
Pour rendre permanente une modification de valeur de variable, vous devez la changer dans le
paramètre de contexte correspondant. Voir également : Définir les paramètres de contexte, page 86.
Vous disposez de plusieurs manières pour exécuter votre processus. Le choix du type d’exécution
dépend de l’objectif ainsi que de votre niveau Perl (ou celui de l’utilisateur).
Si vous avez un niveau Perl avancé et souhaitez exécuter votre projet pas à pas, consultez la section
Exécuter en mode debug, page 92.
Si vous n’avez pas de connaissances Perl avancées et souhaitez exécuter votre job en mode normal,
consultez la section Exécuter en mode normal, page 90 .
Veillez à sauvegarder votre job avant de l’exécuter afin que toutes les propriétés puissent être prises
en compte.
• Cliquez sur l’onglet Run Job pour accéder au panneau.
• Dans la zone Context, sélectionnez le contexte approprié pour ce processus. Vérifiez
également les valeurs de variables si necéssaire.
Si vous n’avez pas défini de contexte d’exécution, le tableau des paramètres de contexte est vide et
le contexte est défini sur default.
Voir également: Définition d’un contexte et de variables de job, page 85
• Cliquez sur Run pour lancer l’exécution.
• Sur le même panneau, la console de log affiche la progression de l’exécution. La log inclut
les messages d’erreurs ainsi que les messages de début et de fin de processus. Elle affiche
également le résultat du processus si le composant terminal le prévoit, par exemple
tLogRow.
Avant d’exécuter à nouveau un processus, vous pouvez vider le contenu de la log, en cliquant sur
la case à cocher Clear before run. A chaque exécution, la log sera désormais vidée.
Si pour une raison quelconque, vous souhaitez stopper la progression du job, cliquez simplement sur
le bouton Kill. Vous devrez cliquer sur Run à nouveau pour reprendre l’exécution du job.
Talend Open Studio offre d’autres fonctionnalités informatives, telles que Stastistics ou Traces, qui
facilitent la supervision du job ainsi que le travail de débogage.
Sont indiqués le nombre de lignes traitées et la vitesse de traitement en ligne par seconde. Vous
pouvez ainsi plus facilement repérer d’éventuels goulots d’étranglement dans le traitement de
votre flux de données.
Note: Cette option est disponible pour tous les composants à l’exception des composants
externes qui ne peuvent offrir cette fonctionnalité que si leur conception le prévoit.
Cochez la case Statistics pour activer la fonction stats et décochez la case pour la désactiver.
Le calcul des statistiques ne commence qu’au début de l’exécution du processus et s’arrête
lorsque l’exécution s’arrête.
Cliquez sur le bouton Clear pour effacer les stats affichées. Cochez la case Clear before Run
pour que la fonction de statistiques se réinitialise automatiquement avant chaque exécution.
Note: Les statistiques peuvent ralentir sensiblement les performances d’exécution du
processus car le processus doit envoyer ces données à l’application afin qu’elle
soient affichées.
Cette fonctionnalité vous permet de superviser tous les composants d’un job, sans avoir besoin
de passer en mode Debug, et par conséquent sans avoir besoin de connaissances Perl
particulières.
La fonction Traces affiche le contenu des lignes traitées dans un tableau. Cochez la case Clear
before Run pour que la fonction de trace se réinitialise automatiquement avant chaque
exécution.
Note: Les composants externes ne peuvent offrir cette fonctionnalité que si leur
conception le prévoit.
Cochez la case Traces pour activer la fonction de suivi du traitement et décochez pour la
désactiver.
La fonction trace ne s’exécute qu’à l’exécution du job, et ne s’arrête qu’à la fin de celui-ci.
Cliquez sur Clear pour effacer les traces affichées.
Note: Le tableau est limité horizontalement, néanmoins si vous passez votre souris
au-dessus du tableau, la totalité des informations s’affiche. A contrario, il n’existe
aucune limitation verticale de ce tableau. Cela peut poser problème si le tableau
est très long.
Avant d’exécuter un job en mode Debug, vérifiez que le module EPIC est installé.
Dans un premier temps nous vous recommandons d’ajouter des points de pause au niveau des étapes
principales de votre processus.
Lorsque vous fermez l’application Talend Open Studio, une boîte de dialogue vous demande de
sauvegarder les jobs courants si vous ne l’avez pas déjà fait.
Cochez la case correspondant aux jobs que vous souhaitez sauvegarder. Le job est enregistré dans
le dossier du projet dont il fait partie, dans le répertoire Workspace.
Vous pouvez également cliquer sur menu File > Save ou appuyer sur Ctrl+S pour enregistrer vos
jobs.
A l’aide de la fonction Export de Talend, vous pouvez conserver et archiver vos fichiers script de
vos jobs dans un fichier d’archivage.
Cliquez-droit sur le job correspondant dans le Repository et sélectionnez Export Job Scripts.
Sélectionnez les fichiers que vous souhaitez ajouter à votre archive, et donnez un nom à ce fichier
zip. Cliquez sur Finish lorsque vous avez terminé.
Le fichier créé est une archive que vous pouvez stocker, envoyer et redéployer selon vos besoins. Il
contient les run.bat et les run.sh requis pour l’exécution des scripts.
Raccourcis clavier
Le tableau ci-dessous rassemble tous les raccourcis clavier utilisés dans TOS :
Quel que soit le paramètre de propriétés du job, vous pouvez utiliser Ctrl+Space pour paramétrer la
valeur du champ comme variable de contexte.
Composants
Ce chapître détaille les propriétés des composants principaux fournis en standard dans Talend Open
Studio. Chaque composant possède sa propre liste de propriétés et de paramètres, éditables dans l’onglet
Properties du panneau Properties.
Cliquez sur l’un des liens suivants pour consulter sa fiche technique:
tMsgBox tFileInputDelimited
tFileInputPositional tFileOutputXML
tLogRow tFileList
tFTP tSendMail
tPerl tSystem
tFileInputRegex tDBInput
tMap tRowGenerator
tAggregateRow tSortRow
tUniqRow tFileInputXML
tCatcher, tWarn & tDie tDBOutput
tFileInputMail tFileOutputLDIF
tStatCatcher tRunJob
tMsgBox
Propriétés de tMsgBox
Le scénario suivant crée un job à composant unique où tMsgBox est utilisé pour afficher le pid
(Process id unique généré par le système) en lieu et place du tradionnel message “Hello World!”.
• Cliquez et déposez un composant tMsgBox dans le workspace
• Définissez les propriétés d’affichage du message
• ‘My Title’ est le titre de la boîte de message, vous pouvez utiliser une variable Perl.
• Dans le champ Message, saisissez le texte entre guillemets simples concaténé à l’aide de la
variable scalaire Perl ($$) contenant le pid.
• Appuyez sur F6 pour exécuter le job et passer à l’onglet Run Job de la console.
Le message affiche le texte défini précédemment et requiert une action de l’utilisateur pour
disparaître.
Après que l’utilisateur a cliqué sur le bouton OK, le log de l’onglet Run Job est mis à jour.
Voir également: Exécution d’un job, page 90
tFileInputDelimited
Propriétés de tFileInputDelimited
Le scénario suivant est un job de deux composants ayant pour objectif de lire les lignes d’un fichier,
de sélectionner des données délimitées et d’afficher la sortie dans la console (onglet Run Job).
• Renseignez le chemin d’accès au fichier dans le champ File Name. Ce champ est obligatoire.
• Définissez le séparateur de lignes dans le champ Row Separator afin d’identifier la fin
d’une ligne. Puis définissez le séparateur de champs dans Field Separator pour délimiter les
champs composant une ligne.
• Dans ce scénario, l’entête (Header) et le pied de page (Footer) n’ont pas besoin d’être
définis. Et la limite de lignes lues (Limit) est de 50 pour cet exemple.
• Vous pouvez charger et/ou éditer le schéma à l’aide de la fonction Edit Schema.
Voir également : Paramétrage d’un schéma built-in et Paramétrage d’un schéma repository, page
43.
• Assurez-vous que la case Skip empty rows est cochée afin d’ignorer les lignes vierges.
• Saisissez l’encodage utilisé dans le fichier d’entrée défini. Ce paramètre permet d’assurer
l’homogénéité de l’encodage dans tous les fichiers d’entrée et de sortie.
• Sélectionnez le composant tLogRow et définissez le séparateur de champs de la sortie
affichée. Voir également: tLogRow, page 108
• Passez sur l’onglet Run Job et cliquez sur Run pour exécuter le job.
Le fichier est lu ligne à ligne et les champs extraits sont affichés dans la console, tel que défini dans
les Properties des composants.
tFileInputPositional
Propriétés de tFileInputPositional
Le scénario suivant construit un job à deux composants, qui a pour objectif de lire les données d’un
fichier positionnel en entrée et de rendre en sortie des données sélectionnées (selon leur position)
dans un fichier XML.
• Renseignez le chemin d’accès au fichier dans le champ File Name. Ce champ est obligatoire.
• Puis définissez le pattern de délimitation des champs dans une ligne, dans le champ Pattern.
Le pattern est une série de longueurs correspondant aux valeurs de champs du fichier en
entrée. Les valeurs doivent être saisies entre guillemets simples et séparées par une virgule.
Veillez à ce que les valeurs saisies correspondent aux longueurs de champs du schéma défini.
• Dans ce scénario, les champs entête (Header), pied de page (Footer) et limite (Limit) n’ont
pas besoin d’être définis.
• Sélectionnez le type de Schéma, dans ce cas Built-in, et définissez les données à transmettre.
Vous pouvez charger et/ou modifier le schéma via la fonction Edit Schema. Pour ce schéma,
définissez trois colonnes, respectivement Contracts, CustomerRef et InsuranceNr
correspondant aux trois valeurs de longueurs définies.
• Saisissez une (ou plusieurs) balise racine (Root tag) pour envelopper la structure en sortie
XML, dans ce cas, la balise est ContractList.
• Définissez la balise de ligne (Row tag) qui définit chaque ligne. Dans ce cas, la balise de
ligne est ContractRef.
• Cochez la case Column name as tag name pour réutiliser le libellé des colonnes du schéma
d’entrée comme nom de balises de la structure de sortie. A défaut, le nom de balise est field
quel que soit le type de valeur dans les colonnes.
• Saisissez un encodage (Encoding) standard du fichier d’entrée.
Note: Remarque: Pour l’instant, la vérification d’encodage n’est pas fonctionnemllement
supportée.
• Sélectionnez le type de schéma, dans Schema type. Si vous avez déjà mis en place le lien
de connexion entre composant d’entrée et de sortie du job, la propagation de schéma est
automatique. Si besoin est, cliquez sur Sync columns pour les synchroniser.
• Passez à l’onglet Run Job et cliquez sur Run pour exécuter le job.
Le fichier est lu ligne à ligne et divisé en champs basés sur les longueurs définies précédemment
dans le champ Pattern. Vous pouvez l’ouvrir dans n’importe quel éditeur XML standard.
tFileOutputXML
Propriétés de tFileOutputXML
Un scénario utilisant le composant tFileOutputXML est décrit dans Scénario: Transformation d’un
fichier positionnel en XML, page 102.
tLogRow
Propriétés de tLogRow
Un cas d’utilisation utilisant un composant tLogRow est décrit dans la section: Scénario: Affichage
du contenu d’un fichier délimité, page 99.
tFileList
Propriétés de tFileList
Le scénario suivant décrit un job de trois composants, qui a pour objectif de répertorier les fichiers
d’un répertoire défini, de lire chaque fichier par itération, de sélectionner les données délimitées et
d’afficher ces données dans la sortie standard de l’onglet Run Job.
• Dans le champ Directory, parcourez votre système de fichier jusqu’au répertoire d’itération.
• Pour faire apparaître ce chemin d’accès dans le job lui-même, utilisez le nom de champ
(__Directory__) qui apparaît en bulle info lorsque vous passez la souris sur le champ
Directory. Saisissez cette reférence de le champ Label Format de l’onglet View.
• Dans l’onglet Properties, indiquez un masque de fichier dans le champ FileMask. Utilisez
les caractères joker si besoin est.
• Définissez le champ Case sensitive sur Yes pour ce scénario pour prendre en compte la
casse.
• Cliquez sur le second composant (tFileInputDelimited) pour en définir les propriétés :
• Saisissez un nom de fichier dans File Name à l’aide d’une variable contenant le chemin
d’accès au fichier, tel que vous l’avez renseigné dans les propriétés du tFileList. Appuyez
sur Ctrl+Espace pour accéder à la liste d’autocomplétion des variables et obtenir facilement
la variable globale d’itération.
• Renseignez les autres champs comme pour un fichier délimité standard. Voir également:
tFileInputDelimited, page 98.
tFTP
Propriétés de tFTP
tFTP put
Objectif tFTP put copie des fichiers sélectionnés à partir d’un répertoire local
vers un répertoire FTP distant.
Local directory Chemin d’accès à l’emplacement source des fichiers.
Remote directory Chemin d’accès au répertoire de destination des fichiers.
Filemask Noms de fichiers ou chemin d’accès aux fichiers à transférer.
Note: Si vous saisissez un chemin d’accès dans le champ Filemask, il est dans ce cas, inutile
de renseigner le champ du répertoire local.
tFTP get
Objectif tFTP get récupère les fichiers sélectionnés d’un répertoire FTP distant
et les dépose dans un répertoire local.
Local directory Chemin d’accès à l’emplacement de destination des fichiers
Remote directory Chemin d’accès du répertoire source où les fichiers sont récupérés.
Filemask Noms de fichiers ou chemin d’accès aux fichiers à transférer.
Note: Si vous saisissez un chemin d’accès dans le champ Filemask, il est dans ce cas, inutile
de renseigner le champ du répertoire local.
tFTP rename
Objectif tFTP rename renomme ou déplace des fichiers d’un système à distance.
Local directory Inutilisé pour cette action.
Remote directory Répertoire source où se trouvent les fichiers à renommer ou à déplacer.
Filename Noms de fichiers ou chemin d’accès aux fichiers à renommer.
New name Saisissez le nouveau nom de fichier.
Note: Si vous saisissez un chemin d’accès dans le champ Filemask, il est dans ce cas, inutile
de renseigner le champ du répertoire local.
tFTP delete
Note: Si vous saisissez un chemin d’accès dans le champ Filemask, il est dans ce cas, inutile
de renseigner le champ du répertoire local.
Ce scénario est constitué d’un seul composant et a pour objectif de déposer des fichiers spécifiés sur
un serveur distant.
• Cliquez et déposez un composant tFTP de la Palette de composants vers l’espace de
modélisation.
• Dans l’onglet Properties de ce composant, définissez ses propriétés FTP.
• Renseignez l’adresse IP source dans Host, le port d’écoute dans Port ainsi que le reste des
informations de connexion.
• Renseignez les informations de répertoire local si tous les fichiers sont présents dans le
même répertoire. Vous pouvez renseigner cette information pour chaque fichier dans les
divers masques de fichiers (Filemask) du champ Files.
• Renseignez les informations de connexion au serveur distant dans Remote directory.
• Sélectionnez l’action à effectuer, dans cet exemple, une action Put.
• Cliquez-droit dans la zone Files pour ajouter des lignes nouvelles et renseignez les masques
de fichiers si besoin est.
• Appuyez sur F6 pour exécuter le job.
Les fichiers désignés dans le champ Filemask, sont ainsi copiés sur le répertoire défini du serveur
distant.
tSendMail
Propriétés de tSendMail
Ce scénario est constitué de trois composants et a pour objectif d’envoyer un email aux destinataires
en cas d’erreur sur le job.
• Saisissez l’adresse des destinataires (To) et de l’expéditeur (From), ainsi que l’objet du mail
(Subject).
• Saisissez un message contenant par exemple, le code erreur produit en utilisant la variable
globale appropriée. Accédez à la liste d’autocomplétion des variables via Ctrl+Espace.
• Ajoutez les éventuelles pièces à joindre ainsi que l’adresse IP du serveur SMTP.
Dans ce scénario, le fichier en entrée est introuvable. tSendMail est donc chargé d’envoyer un mail
de notification d’erreur aux destinataires définis.
tPerl
Propriétés de tPerl
Ce scénario est constitué de trois composants affichant dans la console le nombre de lignes traitées
en sortie XML.
• Cliquez et déposez trois composants de la Palette des composants dans l’espace de
modélisation : tFileInputDelimited, tFileOutputXML et tPerl.
• Cliquez-droit sur le composant tFileInputDelimited et connectez-le au composant de sortie
tFileOutputXML par un lien Row > Main.
• Cliquez-droit à nouveau sur le composant d’entrée, et reliez-le au composant tPerl à l’aide
d’un lien déclencheur, Trigger > Run Before. Ce lien signifie que le composant
tFileInputDelimited s’exécutera avant le composant tPerl.
• Définissez les propriétés du composant d’entrée tFileInputDelimited.
• Les propriétés n’étant pas stockées dans le Repository, elles sont définies de façon unique
pour ce job, par conséquent de type Built-in.
• Saisissez un chemin d’accès ou parcourez votre système de fichiers jusqu’au fichier
contenant les données à traiter. Dans cet exemple, le fichier contient deux champs: les noms
et leur adresse email respective.
• Définissez les séparateurs de lignes et de champs. Pour ce scénario, les lignes sont délimitées
par un retour à la ligne et les champs par un point-virgule.
• La première ligne du fichier contient les libellés des colonnes, qui devront donc être ignorés
dans le traitement. Définissez l’entête (Header) à 1.
• Aucun pied de page (Footer) ni limite ne sont définis pour ce scénario.
• Comme les propriétés, le type de schéma est built-in pour ce scénario. Cliquez sur Edit
Schema pour décrire le contenu du fichier d’entrée: Deux colonnes libellées Names et
Emails de type chaîne de caractères (String).
• Sélectionnez le composant tFileOutputXML dans votre job, et définissez les données en
sortie.
• Créez une balise racine (Root tag) et nommez-la List, et créez une balise ligne (Row tag)
que vous nommez Entry. Cliquez sur Sync Columns pour dupliquer le schéma d’entrée en
sortie.
• Puis définissez le sous-job tPerl afin d’obtenir le nombre de lignes transférées vers la sortie
XML définie précédemment.
• Dans l’onglet Properties, saisissez la commande Perl print pour obtenir la variable
contenant le nombre de lignes lues dans le fichier d’entrée. Pour accéder à la liste des
variables globales, appuyez sur Ctrl+Espace.
• Ajoutez une ligne de signes égal avant et après les lignes de commande, pour améliorer la
lisibilité des résultats dans la console. Notez également que les commandes, chaînes de
caractères et variables sont de couleurs différentes.
• Passez à l’onglet Run Job et exécutez le job.
Le job s’exécute et, comme prévu, crée un fichier XML correspondant au schéma défini. Dans la
console, le résultat de la commande Perl indique le nombre de lignes traitées.
tSystem
Propriétés de tSystem
Ce scénario est constitué de deux composants et a pour objectif d’afficher un message dans la
console de log sans utiliser le composant tLogRow.
• Cliquez et déposez un composant tSystem et tPerl dans l’espace de modélisation.
• Cliquez-droit sur le composant tSystem, et sélectionnez le déclencheur Trigger > Run
Before link et reliez les deux composants. Lors de l’exécution du job, le premier composant
s’exécutera avant le second.
• Cliquez sur tSystem et sélectionnez l’onglet Properties:
• Saisissez une commande Perl pour afficher la valeur de sortie du tSystem dans la console.
• Passez à l’onglet Run Job et exécutez le job.
Le job exécute une commande echo telle que définie dans le tSystem, stocke le résultat de cette
commande dans une variable qui s’affiche dans la sortie standard Run Job via la commande du
composant tPerl.
tFileInputRegex
Propriétés de tFileInputRegex
Le scénario suivant est formé de deux composants et a pour objectif de lire les données d’un fichier
d’entrée basé sur des expressions régulières et transformant les données ainsi délimitées en sortie
XML.
• Les propriétés de ce job sont de type built-in. Par conséquent, elles ne sont définies que pour
ce job et ne peuvent être partagées avec d’autres utilisateurs.
• Indiquez le chemin d’accès au fichier dans le champ File Name. Ce champ est obligatoire.
• Définissez le séparateur de lignes dans le champ Row separator afin d’identifier la fin d’une
ligne.
• Puis définissez l’expression régulière à utiliser pour délimiter les champs d’une ligne dans
Regular expression. Vous pouvez utiliser du code Perl et saisir une expression régulière
multiligne si vous en avez besoin.
• Assurez-vous d’inclure dans cette expression tous les sous-patterns des champs à extraire.
• Dans ce scénario, les champs entête (Header), pied de page (Footer) et limite (Limit) sont
ignorés.
• Sélectionnez le type de schéma local (Built-in) dans le champ Schema type.
• Vous pouvez créer ou charger un schéma via la fonction Edit Schema.
• Puis définissez les propriétés du second composant.
tDBInput
Propriétés de tDBInput
Le scénario suivant est constitué de deux composants et a pour objectif de lire les données d’une
base à l’aide d’une requête de BDD et de sortir les données délimitées ainsi sélectionnées dans un
fichier XML.
• Les informations de propriétés sont built-in pour ce job (stockées localement et non
partageables).
• Sélectionnez Mysql comme base de données.
• Renseignez les données de connexion à la base de données dans les champs Host, Port ainsi
que le nom de la base de données (Database name), nom d’utilisateur, et le mot de passe
(password).
• Le schéma est de type Built-In également.
• Cliquez sur Edit schema et créez un schéma de 2 colonnes conprenant les codes magasins
(shop code) et les ventes (sales) pour cet exemple.
• Saisissez la requête en vous assurant qu’elle inclut toutes les colonnes dans l’ordre défini
dans le schéma. Dans cet exemple, nous pouvons utiliser le caractère astérisque car nous
souhaitons sélectionner toutes les colonnes.
• Saisissez les informations d’encodage. Et cliquez sur le second composant tLogRow, pour
le définir.
• Saisissez le séparateur de champs. Dans ce cas, utilisez une barre verticale.
• Passez à l’onglet Run Job, et cliquez sur Run pour exécuter le job.
La base de données est parsée et les données définies dans la requête sont extraites et transmises à
la console. Vous pouvez visualiser le fichier de sortie sur la console.
StoreSQLQuery est un paramètre de variable qui peut être utilisé pour le débogage d’un scénario
tDBInput qui semble ne pas fonctionner correctement. Il vous permet d’alimenter dynamiquement
votre requête SQL définie dans le composant tDBInput.
• Reprenez le scénario 1 ci-dessus, et ajoutez un composant tPerl.
• Connectez le composant tDBInput au composant tPerl à l’aide d’un déclencheur Run
before, afin que l’exécution du composant tPerl commence immédiatement après la fin de
l’exécution du tDBInput.
• Paramétrez les deux composants tDBInput et tLogRow comme décrit dans le scénario 1.
• Cliquez dans l’espace de modélisation pour faire apparaître le panneau de propriétés de
Contexte.
• Dans la fenêtre de contexte, créez un nouveau paramètre et appelez-le exactement
StoreSQLQuery. Saisissez une valeur par défaut de 1. Cette valeur de 1 signifie que ce
paramètre est considéré exact (“true”) quand il est utilisé dans une variable globale QUERY.
• Revenez au composant tPerl et affichez ses propriétés. Saisissez la commande Print pour
afficher le contenu d’une requête et appuyez sur Ctrl+ Space pour accéder à la liste
d’autocomplétion des variables et sélectionnez la variable globale QUERY.
tMap
Propriétés de tMap
Jeux de Scénarios
• Les fichiers délimités Cars et Owners sont chargés et décrits en détails dans le
gestionnaire Metadata du Repository. Utilisez directement leur référence du
Repository dans Properties.
• Double-cliquez sur Cars, pour paramétrer les propriétés.
• Sélectionnez Repository dans les champs Property type et Schema type pour récupérer
les informations de propriétés stockées dans le référentiel. Le reste des champs est
automatiquement renseigné lorsque vous sélectionnez la métadonnée appropriée dans la
liste. Si vous n’avez pas créé de métadonnées liées aux informations de connexion à
votre fichier, vous pouvez aussi définir manuellement chacune des propriétés.
• Double-cliquez sur le composant Owners et définissez à nouveau les informations de
propriétés et de schéma, à l’aide des métadonnées si elles existent ou manuellement.
Pour plus d’informations concernant la création de métadonnées dans le Repository, voir
également Définition des schémas de métadonnées, page 45.
• Puis double-cliquez sur le composant tMap pour ouvrir le Mapper. La zone Input
(données en entrée) est déjà renseignée avec les schémas des composants d’entrée (cars
et owners) qui sont liés au tMap.
• Notez que la première table (la plus haute dans la zone) correspond au flux principal
(Main row) du job en cours tandis que l’autre table d’entrée correspond à la table
référence (Lookup) du flux secondaire.
• Remarquez également que les libellés de chacune des connexions d’entrée apparaissent
en tête des tables.
• Créez un lien Join entre les deux tables d’entrée en faisant simplement glisser le champ
ID_Owner de la table principale vers le champ équivalent de la table de référence.
• Par conséquent, glissez-déposez le champ ID_Insurance vers la ligne de filtre qui vient
d’être créée et saisissez la formule suivante d’exclusion des valeurs non définies :
$Owners_data[ID_Insurance] ne ''
• La table Reject_NoInsur est un flux de rejet standard regroupant les données qui ne
satisfont pas la condition de filtre définie. Cliquez sur la flèche orange, pour définir cette
table comme table de rejet standard.
• La troisième et dernière table est une table de rejets spécifiques pour les liens Inner Join
qui ne peuvent être établis. Il s’agit par exemple du cas où un champ Owners_ID de la
table Cars ne correspond à aucune entrée du fichier Owners.
• Cliquez sur la flèche de couleur violet pour définir cette table comme table de rejet Inner
Join.
• Cliquez sur OK pour valider et revenir à l’espace de modélisation.
• Ajoutez trois composants tFileOutputDelimited au job, et reliez les au job à partir du
composant tMap à l’aide d’un lien Row>Main.
• Reutilisez les trois libellés définis précédemment dans le Mapper.
• Puis double-cliquez sur chacun des composants de sortie afin de définir les propriétés
respectives des flux de sortie (principale, rejet et rejet Inner Join). Si vous souhaitez
qu’un nouveau fichier soit créé pour contenir une sortie, parcourez votre système de
fichiers jusqu’au dossier de destination et saisissez le nom de fichier avec son extension.
• Cochez la case Include header pour réutiliser les libellés de colonne du schéma comme
ligne d’entête du fichier de sortie.
• Appuyez sur F6 pour exécuter le job ou passez à l’onglet Run Job et cliquez Run.
• Le fichier de sortie est créé, et les fichiers de rejet également le cas échéant.
• Vous pouvez également créer une entrée de métadonnée pour conserver cette
description de fichier dans le Repository et avoir la possibilité de partager les
informations de propriétés et de schéma. Pour plus d’informations concernant la création
de métadonnées, voir Définition des schémas de métadonnées page 45.
• Double-cliquez sur le composant tMap et remarquez sur le schéma est automatiquement
ajouté à la zone des schémas d’entrée Input.
• Créez un lien Join entre le flux d’entrée principal (Row Main) et l’entrée de référence
(Lookup), Resellers. Cochez la case Inner Join pour définir le type de Join créé.
• Glissez et déposez les champs de la table Resellers vers la table de sortie principale.
Note: Lorsque deux Inner Joins sont définis, vous avez la possibilité de distinguer les
deux types de rejets à condition de créer deux tables de rejet Inner Join Reject
pour les sorties respectives. Alternativement vous pouvez rassembler les deux
types de rejets dans une seule et même table de sortie.
• Dans la zone de sorties Output, cliquez sur le signe plus pour ajouter une nouvelle table
de sortie.
• Donnez un nom à cette nouvelle connexion, Reject_ResellerID.
• Cliquez sur le bouton Inner Join Reject (flèche violette) pour définir cette nouvelle sortie
en table de rejet Inner Join.
• Glissez-déposez deux champs de la table d’entrée principale (Cars) dans cette nouvelle
table. Par conséquent, dans cet exemple, si le lien Inner Join ne peut être établi pour une
entrée, les données sélectionnées (ID_Cars & ID_resellers) seront rejetées dans le
fichier de sortie approprié et permettront d’identifier rapidement le goulot
d’étranglement.
• Appliquez maintenant un filtre sur chacune des sorties d’Inner Join Reject, afin de
distinguer les deux types de rejets.
• Dans la première table de rejet (Reject_OwnerID), cliquez sur la flèche dotée d’un signe
plus, pour ajouter une ligne de filtre et renseignez ce champ avec la formule suivante
pour ne recueillir que les rejets liés au champ OwnerID non défini: not defined
$Owners_data[ID_Owner]
• Dans la seconde table de rejet Inner Join (Reject_ResellerID), renouvelez l’opération et
utilisez la formule suivante : not defined $Resellers_data[ID_Reseller]
• Dans ce scénario, retirez du fichier Resellers.csv les lignes correspondant aux Reseller
ID 5 et 8.
• Puis exécutez le job via la touche F6 du clavier, ou à partir de l’onglet Run Job.
• Les quatre fichiers de sortie sont tous créés dans le dossier définis dans les Properties
des composants de sortie (Outputs).
• Remarquez que dans le fichier de sortie en rejet lié à l’Inner Join, NoResellerID.csv,
le champ ID_Owners correspond aux entrées du fichier Cars dont le Reseller ID est égal
5 et 8 tel que défini précédemment.
tRowGenerator
Propriétés de tRowGenerator
Le scénario suivant décrit un job de deux composants, générant 50 lignes composées de deux
champs, l’un est constitué de 5 chiffres compris entre 1 et 1000, et le champ date est défini par un
mois et une année.
• Cliquez sur OK et cliquez sur Yes pour accepter la propagation dans la table Values.
• Paramétrez le nombre de lignes à 50 pour cet exercice, dans le champ Number of rows.
• Dans la table Values, Column reprend du schéma tous les champs à générer. Dans ce
scénario, deux champs sont utilisés Code et Date.
• Dans la colonne Perl Array, saisissez la plage ou la liste de valeurs à attribuer de façon
aléatoire.
• Pour le champ défini Code, saisissez la plage de valeurs Perl telle que: '00001' .. '01000' de
sorte que des valeurs à 5 chiffres soient sélectionnées dans cette plage de façon aléatoire.
• Dans la cellule Perl Array pour le champ Date, vous pouvez utiliser une fonction Perl telle
que: sub{'2006/11/'.getRandomString(1, ['01'..'30'])}
• Mais vous avez également la possibilité d’utiliser la routine getDate pour couvrir des cas
plus complexes. Pour plus d’informations, voir Code page 12.
tAggregateRow
Propriétés de tAggregateRow
Le scénario suivant décrit un job de quatre composants. Le composant d’entrée, un fichier délimité
csv, contient des noms de pays et des valeurs de notation à trier par ordre décroissant de moyenne.
Ce composant d’entrée est connecté à un opérateur tAggregateRow qui se charge de calculer les
moyennes puis à un composant tSortRow qui se charge du tri. Le flow de sortie est dirigé dans un
nouveau fichier csv.
• Dans cet exemple, les calculs requis sont: moyenne de la notation par pays, valeur min et
max par pays étant donné que chaque pays possède plusieurs notes. Cliquez sur OK lorsque
le schéma est terminé.
• Définissez à présent les différentes opérations d’ensemble à effectuer. Dans le champ Group
By de la fenêtre Properties du composant tAggregateRow, définissez les ensembles sur
lesquels les opérations sont effectuées . En l’occurence, sélectionnez Country. Note : dans
la colonne de sortie, un champ clé doit être défini dans le schéma. La première colonne citée
comme de sortie (Output), dans la table Group By devient l’ensemble principal de calcul.
Toutes les autres sorties deviennent alors secondaires dans l’ordre d’affichage.
• Sélectionnez la colonne d’entrée (Input) dont sont extraites les valeurs.
• Puis renseignez les diverses opérations réalisées. Les fonctions utilisées dans cet exemple
sont moyenne (average), min, max. Sélectionnez la colonne d’entrée dont sont extraites les
valeurs de calcul.
• Dans ce scénario, la colonne à trier est Country, le type de tri est alphabétique et l’ordre est
ascendant.
tSortRow
Propriétés de tSortRow
Le scénario suivant décrit un job constitué de trois composants. Un composant tRowGenerator est
utilisé pour créer de façon aléatoire des entrées, qui seront envoyées au composant tSortRow afin
d’être triées selon une valeur définie. Dans ce scénario, le flux d’entrée contient des noms de
vendeurs ainsi que leur volume de vente respectif et leur nombre d’années d’ancienneté dans
l’entreprise. Le résultat de l’opération de tri est affiché dans la console Run Job.
• Dans ce scénario, chaque vendeur est classé en fonction de la valeur de ses Ventes et du
nombre d’années dans l’entreprise.
• Double-cliquez sur tSortRow pour afficher la vue Properties.
• Paramétrez la priorité de tri sur la valeur des ventes, puis en critère secondaire, sur le nombre
d’années dans l’entreprise.
• Utilisez le bouton + pour ajouter le nombre de lignes de critères requis. Paramétrez le type
de tri, dans ce cas, le tri est numérique. Enfin, étant donné que la sortie est une classification,
définissez l’ordre de tri comme descendant.
• Assurez-vous que ce flux est connecté au composant de sortie tLogRow, afin d’afficher le
résultat dans la console Run Job.
• Appuyez sur F6 pour exécuter le Job ou passez sur la vue Run Job et cliquez sur Run. Le
classement est basé d’abord sur la valeur des ventes puis sur le nombre d’années
d’ancienneté.
tUniqRow
Propriétés de tUniqRow
A partir du scénario tSortRow, ajoutez le composant tUniqRow afin de trier les entrées unifiées
dans le flux de sortie.
• Dans la vue Properties du composant tUniqRow, cliquez sur Edit Schema... pour
paramétrer la clé (Key) sur le champ Names afin de dédoublonner le flux de sortie sur ce
critère.
• Cochez la case Case Sensitive pour différencier la casse.
• Appuyez sur F6 pour exécuter le job à nouveau. La console affiche les résultats
dédoublonnés et triés.
tFileInputXML
Propriétés de tFileInputXML
Ce scénario très basique est constitué de deux composants. Un composant tFileInputXML extrait
des données du fichier xml répertoriant des adresses et le résultat de cette opération est affiché dans
la console Run Job via le composant tLogRow.
• Le fichier XML contenant les adresses a été préalablement défini dans la zone Metadata, par
conséquent récupérez ses propriétés en sélectionnant Repository dans Property type. Pour
plus d’informations sur la création de métadonnées, voir Définition des schémas de
métadonnées page 45.
• De la même manière, sélectionnez le schéma approprié dans la liste de métadonnées du
Repository. Cliquez sur Edit schema si vous souhaitez apporter des modifications au
schéma chargé. Notez que dans ce cas, le schéma est redéfini en built-in.
• Dans le champ Filename, indiquez le fichier structuré d’entrée.
• Dans le champ Loop XPath query, modifiez le noeud de boucle si nécessaire.
• Dans la table de Mapping, renseignez les champs à extraire et à afficher dans la sortie.
• Si le fichier est volumineux, paramétrez une limite (Limit) de lignes à traiter.
• Saisissez les informations d’Encoding si nécessaire. puis double-cliquez sur tLogRow pour
définir le caractère séparateur.
• Puis appuyez sur F6 ou cliquez sur Run dans la vue Run Job pour exécuter le job. Dans la
console, les champs définis sont extraits du fichier XML structuré et sont affichés.
Les deux composants tDie et tWarn sont étroitement liés au tCatcher. L’un comme l’autre sont
généralement utilisés avec un tCatcher afin de collecter les données de traitement, les encapsuler et les
transmettre au composant suivant.
Propriétés de tCatcher
Propriétés de tWarn
Propriétés de tDie
Dans ce scénario simple constitué de trois composants, un tRowGenerator crée des entrées de
façon aléatoire (id à incrémenter). Le flux d’entrée rencontre un composant tWarn qui déclenche
le sous-job tCatcher. Ce sous-job récupère le message d’avertissement ainsi que l’information
standard de log prédéfinie et transfère ces informations au composant tLogRow pour un affichage
rapide de données de log.
• Dans la vue Properties du tCatcher, cochez la case tWarn afin que le message paramétré
dans ce composant soit récupéré dans le sous-job.
• Cliquez sur Edit Schema pour visualiser le schéma utilisé en sortie.
Ce scénario utilise les composants tCatcher et tDie. Un composant tRowGenerator est connecté
à un composant de sortie tFileOutputDelimited à l’aide d’un lien Row. En cas d’erreur, le
composant tDie déclenche le sous-job du tcatcher qui affiche le contenu de la log dans la sortie
standard (Run Job).
• Cliquez et déposez tous les composants requis des divers répertoires de la Palette:
tRowGenerator, tFileOutputDelimited, tDie, tCatcher, tLogRow.
• Dans la vue Properties du tRowGenerator, définissez le paramétrage des colonnes en
entrée à traiter.
• Cliquez sur Edit schema et définissez les colonnes comme suit afin de créer des échantillons
aléatoires de données à traiter : id, name, quantity, flag et creation.
• Paramétrez le nombre de lignes (Number of rows) sur 0. Cela constituera l’erreur sur
laquelle est basé le déclenchement du tDie.
• Dans le tableau Values, définissez les fonctions Perl, dans le champ Perl array, qui
permettront d’alimenter le flux d’entrée.
• Saisissez le message Die à transmettre au tCatcher avant que l’opération kill soit exécutée.
• Séparément, cliquez et déposez un composant tCatcher et connectez-le à un composant
tLogRow.
• Définissez les propriétés du tCatcher. Assurez-vous que la case tDie est cochée afin
d’ajouter le message Die à l’information complète de log qui sera transmise au composant
final.
• Appuyez sur F6 pour exécuter le job et remarquez que la log est composé d’un message
rouge et d’un message noir.
• L’information de log de couleur noire provient du tDie et est transmise par le composant
tCatcher. Le message en rouge est le message standard d’un PerlDie qui s’affiche
habituellement lorsqu’un job se finit de façon anormale.
tDBOutput
Propriétés de tDBOutput
Schema type et Edit Un schéma est une description de ligne, i.e. il définit
Schema le nombre de champs qui seront traités et passés au
composant suivant. Le schéma est soit local (built-in)
soit distant dans le Repository.
Built-in: Le schéma sera créé et conservé
ponctuellement pour ce composant seulement. Voir
également : Paramétrage d’un schéma built-in, page
43
Repository: Le schéma existe déjà et est stocké dans
le Repository. Il peut être réutilisé dans divers projets
et job designs. Voir également : Paramétrage d’un
schéma repository, page 43.
Encoding Champ texte libre. L’encodage n’est pour l’instant pas
vérifié, mais cette fonction devrait être ajoutée à
l’avenir.
Utilisation Ce composant offre la flexibilité .des requêtes de base de données et couvre
toutes les possibilités de requête SQL.
Le scénario suivant constitué de trois composants a pour objectif de créer une nouvelle table dans
une base de données définie et de la renseigner avec des données. Le composant
tFileInputdelimited transmet le flux d’entrée au composant tDBoutput. Le contenu de la base de
données n’étant pas visualisable facilement, un composant tLogRow permet d’afficher le contenu
du flux principal dans la console Run Job.
• Et de la même façon, si votre schéma est déjà chargé dans le Repository, sélectionnez
Repository dans le champ Schema type puis l’entrée de métadonnées appropriée. Dans le
cas contraire, définissez manuellement le schéma built-in.
• Limitez l’extraction à 10 lignes, pour cet exemple.
• Puis configurez un composant tDBOutput pour définir le flux de sortie. Sélectionnez la base
de données de sortie. Notez que vous pouvez conserver les informations de connexion à la
base de données dans différentes variables de contexte. Pour plus d’information sur la
création et l’utilisation des variables de contexte, voir Définition d’un contexte et de
variables de job page 85.
• Renseignez le nom de la table dans le champ Table. Puis sélectionnez les opérations à
effectuer :
• Dans le champ Action on table, sélectionnez Drop and create table dans la liste. Cette
action permet d’écraser une table existante avec la nouvelle table. Alternativement, vous
pouvez ignorer cette étape et n’insérer que les nouvelles lignes dans la table existante à l’aide
d’une Action on data, mais notez que la gestion des doublons n’est pas gérée nativement
dans ce composant. Voir tUniqRow, page 155 pour plus d’information.
• Dans le champ Action on data, sélectionnez Insert. Le flux de données entrant est ainsi
ajouté à la table nouvellement créé.
• Pour visualiser le flux de sortie facilement, connectez le composant DBOuput au composant
tLogRow. Définissez le séparateur de champ, dans ce scénario, utilisez la barre verticale.
• Appuyez sur F6 pour exécuter le job.
• Etant donné que le traitement peut prendre un peu de temps, nous vous recommandons
d’activer la fonction Statistics dans la console Run Job.
tFileInputMail
Propriétés de tFileInputMail
Ce scénario constitué de deux composants a pour objectif d’extraire certains champs clé et d’en
afficher les valeurs dans la console Run Job.
• Entrez le fichier email à traiter. Définissez le schéma en incluant toutes les colonnes que vous
souhaitez retrouver dans le flux de sortie.
• Une fois que le schéma est défini, cliquez sur OK pour le propager dans le tableau Mail
parts
• Dans la colonne Mail part du tableau, saisissez les clés standard des parties header (en-tête)
et body (corps de message) qui seront utilisées pour retrouver les valeurs à envoyer en sortie.
• Définissez le composant tLogRow afin que les valeurs affichées soient séparées par un
retour chariot. Sous Windows, saisissez \n entre double apostrophes.
• Appuyez sur F6 pour exécuter le job et afficher le flux en sortie dans la console d’exécution.
Les valeurs clés d’en-tête sont extraites comme spécifié dans le tableau Mail parts. En effet
l’auteur, le sujet, la date de réception et le nombre de lignes sont affichés.
tFileOutputLDIF
Propriétés de tFileOutputLDIF
Ce job très simple est constitué de deux composants, et a pour objectif d’extraire les données d’une
table de base de données puis écrit les données dans un fichier LDIF de sortie.
• Alternativement, sélectionnez Built-in dans les champs Property type et Schema type et
définissez manuellement votre connexion DB et les informations de schéma.
• Puis double-cliquez sur tFileOutpuLDIF et configurez ses Properties.
• Entrez le nom ou chemin d’accès au fichier LDIF. S’il n’existe pas, le job se chargera de le
créer.
• Dans le champ Wrap, saisissez le nombre de caractères contenus sur une ligne. Les
caractères qui suivent seront ensuite automatiquement placés sur la ligne suivante.
• Sélectionnez Add dans le champ Change Type puisque, par définition, un fichier
nouvellement créé est vide. Dans le cas d’une modification, vous devrez définir la nature de
la modification que vous souhaitez effectuer dans le fichier.
• Dans le champ Schema Type, sélectionnez Built-in et cliquez sur Sync Columns pour
récupérer la définition du schéma d’entrée.
• Appuyez sur F6 pour exécuter le job.
Le fichier LDIF créé comporte les données de la table de base de données et le type de changement
effectué sur le fichier est, dans ce cas, défini comme: addition.
tStatCatcher
Propriétés de tStatCatcher
Ce scénario est constitué de quatre composants, et a pour objectif d’afficher dans la console Run
Job les informations de log standard collectées par le composant tStatCatcher lors de la génération
d’un fichier.
• Puis définissez les propriétés du composant de sortie. Dans la vue Properties du composant
tFileOutputDelimited, parcourez votre système jusqu’au fichier ou saisissez le nom du
fichier à créer. Configurez les séparateurs et l’encoding.
• Cliquez sur Edit schema et assurez-vous que le schéma de sortie correspond au schéma
d’entrée. Si nécessaire, cliquez sur Sync Columns.
• Puis cliquez sur l’onglet Main de la vue Properties, et cochez également la case
tStatCatcher Statistics pour activer la collecte d’informations de log.
• Dans le job secondaire, double-cliquez sur le composant tStatCatcher. Notez que les
informations Properties sont en lecture seule et sont fournies pour information seulement.
Le fichier de log affiche les informations de début (Begin) et de fin (End) du job lui-même ainsi que
chaque composant utilisé.
tRunJob
Propriétés de RunJob
Ce scénario est particulier dans le fait qu’il est constitué de deux jobs, un job appelé et un job
appelant. Le job appelé lit un fichier delimité basique et en affiche le contenu dans la sortie standard
Run Job. Le job appelant est constitué d’un seul composant, tRunJob, et utilise une variable de
contexte variable pour afficher un message de confirmation préalable à l’éxécution.
• Dans le champ File Name, parcourez votre système jusqu’au fichier d’entrée. Dans cet
exemple, le fichier d’entrée est de type texte et se nomme Comprehensive.
• Sélectionnez ce File Name, et appuyez sur F5 pour ouvrir la fenêtre de configuration des
variables.
• Saisissez un nom pour la nouvelle variable de contexte, par exemple, File.
• Inutile de cocher la case Prompt for value ni d’écrire un message pour ce cas car la valeur
par défaut est celle qui sera utilisée.
• Cliquez sur Finish pour valider et appuyez à nouveau sur la touche Entrée pour valider la
mise en variable du champ File Name.
• De retour dans la vue Properties, saisissez les séparateurs de champ et de ligne utilisés dans
le fichier d’entrée.
• Dans ce cas d’utilisation, aucun header ni footer n’est requis. Néanmoins limitez le nombre
de lignes à traiter, dans le champ Limit, à 50.
• Dans le champ Schema type, sélectionnez Built-in pour ce scénario. Configurez le schéma
manuellement.
• Ajoutez deux colonnes et attribuez-leur un libellé selon le nom des colonnes de votre fichier
d’entrée. Dans cet exemple, ID et Registration.
• Si vous conservez votre schéma dans le Repository, sélectionnez simplement l’entrée de
métadonnées correspondant à la structure de votre fichier d’entrée.
• Puis reliez le composant d’entrée au composant de sortie, tLogRow.
Créez ensuite le job appelant qui jouera le rôle de master job.
• Dans la vue Properties du composant tRunJob, sélectionnez le job à exécuter.
• Nous vous recommandons d’exécuter au moins une fois, au préalable, le job appelé avant de
l’exécuter via le tRunJob.
Le job appelé lit les données contenues dans le fichier d’entrée et la console Run Job en affiche
directement les résultats.
B
Breakpoint ................................................................................................................................92
Business Model ............................................................................................................12, 19, 20
Arranger .............................................................................................................................26
Ouvrir .................................................................................................................................20
Business Modeler .....................................................................................................................21
Business Models
Créer ...................................................................................................................................20
C
Code .........................................................................................................................................12
Code Viewer ............................................................................................................................17
Vue .....................................................................................................................................18
Code viewer .............................................................................................................................18
Component ...............................................................................................................................33
Composant .........................................................................................................................33, 95
Activer ...............................................................................................................................40
Start ....................................................................................................................................44
Connexion ................................................................................................................................36
Iterate .................................................................................................................................38
Lookup ...............................................................................................................................36
Main ...................................................................................................................................36
Output ................................................................................................................................36
Row ....................................................................................................................................36
Contexte .....................................................................................................................86, 90, 180
Configuration .....................................................................................................................86
Corbeille .............................................................................................................................14, 30
D
Database
tDBOutput ........................................................................................................................167
Debug mode .............................................................................................................................92
Déclencheur .............................................................................................................................39
Delimited .................................................................................................................................49
Désactivation ...........................................................................................................................84
Documentation .........................................................................................................................13
E
Edit Schema .............................................................................................................................43
Exécution d’un Job ..................................................................................................................14
Expression régulière ................................................................................................................60
G
Generation language ..................................................................................................................6
Grid ..........................................................................................................................................26
I
Iterate .......................................................................................................................................38
J
Job
Designer .............................................................................................................................33
Exécuter .......................................................................................................................89, 90
Job Design ..........................................................................................................................31, 32
Job design ................................................................................................................................12
Job script
Exportation .........................................................................................................................92
L
LDIFfile ...................................................................................................................................61
Lien ..........................................................................................................................................23
Log/error
tCatcher ............................................................................................................................160
tDie ...................................................................................................................................160
tStatCatcher ......................................................................................................................177
tWarn ...............................................................................................................................160
Logs
Vue .....................................................................................................................................14
Lookup .....................................................................................................................................37
M
Main .........................................................................................................................................30
Metadata .............................................................................................................................13, 45
Db Connection ...................................................................................................................46
File delimited .....................................................................................................................49
File positional ....................................................................................................................56
File regex ...............................................................................................................59, 61, 64
O
Objet .........................................................................................................................................22
Onglet
Appearance ........................................................................................................................27
Code Viewer ................................................................................................................17, 18
Logs ...................................................................................................................................14
Outline .........................................................................................................................17, 18
Properties ...........................................................................................................................14
Scheduler ...........................................................................................................................17
Outline ...............................................................................................................................17, 18
View ...................................................................................................................................17
Vue .....................................................................................................................................18
Output ......................................................................................................................................38
P
Palette .....................................................................................................................14, 22, 25, 34
Note ....................................................................................................................................25
Note attachment .................................................................................................................25
Select ..................................................................................................................................25
Zoom ..................................................................................................................................25
Processing
tSortRow ..........................................................................................................................152
tUniqRow .........................................................................................................................155
Projet
Nom technique .....................................................................................................................6
Properties ...........................................................................................................................22, 26
R
Recycle bin ........................................................................................................................14, 30
Référentiel ........................................................................................................4, 5, 8, 11, 19, 31
Refresh .......................................................................................................................................5
Regular Expressions ................................................................................................................60
Relationship .............................................................................................................................23
Repository ........................................................................................................4, 5, 8, 11, 19, 31
Requête
SQLBuilder ........................................................................................................................67
Routine .....................................................................................................................................12
Row ..........................................................................................................................................36
Main ...................................................................................................................................36
Rulers .......................................................................................................................................26
Run Job ........................................................................................................................14, 89, 90
S
Scheduler .................................................................................................................................17
Schéma
Built-in ...............................................................................................................................44
Schéma de métadonnées ..........................................................................................................45
Shape ........................................................................................................................................22
SQLBuilder ..............................................................................................................................67
Start ..........................................................................................................................................44
Statistics ...................................................................................................................................90
StoreSQLQuery .....................................................................................................................129
Sync columns ...........................................................................................................................43
System
tRunJob ............................................................................................................................180
T
Table d’Affectation ..................................................................................................................29
Technical name ..........................................................................................................................6
tMapper ....................................................................................................................................39
Traces .......................................................................................................................................92
Trigger
Run After ...........................................................................................................................39
V
Variable ..................................................................................................................................180
StoreSQLQuery ...............................................................................................................129
Vue
Appearance ........................................................................................................................27
W
Workspace ...............................................................................................................................14
X
XMLFile ..................................................................................................................................63