Talend User Guid - FR

Talend Open Studio
Guide Utilisateur
Version 0.7
Convient pour l’utilisation de Talend Open Studio v1.1 et ultérieure.

Copyright
Une copie de la licence GNU Free Documentation License est fournie avec les fichiers source de cette
documentation.
ii Talend Open Studio Copyright © 2007

Talend Open Studio
Guide Utilisateur................................................................................. i
A propos de ce manuel... ....................................................................................1

Historique des versions .......................................................................................................1
Remarques et Support .......................................................................................................1
Présentation de Talend Open Studio ................................................................3

Accès à Talend Open Studio ..............................................................................................3
Création d’un projet ...........................................................................................................5
Importation d’un projet .....................................................................................................6
Configuration de Talend Open Studio ..............................................................................8
Description de l’interface utilisateur ...............................................................................11
Repository .....................................................................................................................11
Business Models ...........................................................................................................12
Job Designs ...................................................................................................................12
Code ..............................................................................................................................12
Routines .....................................................................................................................12
Snippets ......................................................................................................................13
Documentation .............................................................................................................13
Metadata .......................................................................................................................13
Recycle bin ...................................................................................................................13
Espace de modélisation .................................................................................................14
Vues Properties, Run Job et Logs ..................................................................................14
Properties ......................................................................................................................15
Logs ..............................................................................................................................15
Run Job .........................................................................................................................15
Vues Modules et Scheduler ..............................................................................................15
Modules ........................................................................................................................15
Open Scheduler ............................................................................................................17
Vues Outline et Code .....................................................................................................17
Outline ..........................................................................................................................18
Code viewer ..................................................................................................................18
Conception d’un Business Model ...................................................................19

Objectifs .............................................................................................................................19
Création ou ouverture d’un business model ...................................................................19
Ouverture d’un business model ........................................................................................20
Création d’un business model ..........................................................................................20
Modélisation d’un business model ...................................................................................21
Cliquer & déposer des objets ...........................................................................................22
Connexions .......................................................................................................................23
Copyright © 2007 Talend Open Studio iii

Commentaires et réarrangement d’un Business Model ....................................................25
Ajoût d’une note ou de texte libre ................................................................................25
Réarrangement d’une vue métier ..................................................................................25
Propriétés ..........................................................................................................................26
Vue Rulers & Grid ........................................................................................................26
Vue Appearance ...........................................................................................................27
Vue Assignment ...........................................................................................................28
Affectation d’éléments à un Business Model ..................................................................29
Modification d’un Business model ...................................................................................30
Renommer un business model ..........................................................................................30
Copier et coller un business model ..................................................................................30
Déplacer un business model .............................................................................................30
Supprimer un business model ..........................................................................................30
Conception d’un Job Design ............................................................................31

Objectifs .............................................................................................................................31
Création ou Ouverture d’un job .....................................................................................31
Ouverture d’un job ...........................................................................................................32
Création d’un job ..............................................................................................................32
Conception d’un Job Design ............................................................................................33
Cliquer & Déposer des composants .................................................................................33
Afficher/Cacher la palette ................................................................................................34
Réorganiser les onglets d’un job ......................................................................................34
Avertissements et erreurs sur un composant ....................................................................35
Connexion des composants ...............................................................................................36
Types de connexion ..........................................................................................................36
Connexions de type Row ..............................................................................................36
Main row ....................................................................................................................36
Lookup row ................................................................................................................37
Output row .................................................................................................................38
Connexion de type Iterate .............................................................................................38
Connexions de type Trigger .........................................................................................39
Job à entrées/sorties multiples ..........................................................................................39
Définition des propriétés d’un Job ..................................................................................39
Onglet Main ......................................................................................................................40
Onglet View .....................................................................................................................40
Onglet Documentation .....................................................................................................41
Onglet Properties ..............................................................................................................42
Paramétrage d’un schéma built-in ................................................................................43
Paramétrage d’un schéma repository ............................................................................43
Définition du composant Start .........................................................................................44
Définition des schémas de métadonnées ..........................................................................45
Configurer une connexion DB .........................................................................................46
Etape 1: propriétés générales ........................................................................................46
Etape 2: Connexion ......................................................................................................47
iv Talend Open Studio Copyright © 2007

Etape 3: Chargement de la table ...................................................................................49
Etape 4: Définition du schéma .....................................................................................49
Configurer un schéma File Delimited ..............................................................................49
Etape 1: Propriétés générales ........................................................................................50
Etape 2: Chargement du fichier ....................................................................................50
Etape 4: Schéma final ...................................................................................................54
Configurer un schéma File Positional ..............................................................................55
Etape 1 : Propriétés générales .......................................................................................56
Etape 2 : Connexion et chargement du fichier .............................................................56
Etape 3 : Affinage du schéma .......................................................................................58
Etape 4 : Schéma final ..................................................................................................58
Configurer un schéma File Regex ....................................................................................58
Etape 1: Propriétés générales ........................................................................................59
Etape 2 : Chargement du fichier ...................................................................................59
Etape 3 : Définition du schéma ....................................................................................60
Configurer un schéma LDIF ............................................................................................61
Etape 3: Définition de schéma ......................................................................................62
Configurer un schéma File XML .....................................................................................63
Etape 4 : Schéma final ..................................................................................................67
Création de requêtes à l’aide de SQLBuilder .................................................................67
Comparaison des structures de base de données ..............................................................69
Construction d’une requête ..............................................................................................69
Mapping de données .........................................................................................................70
Présentation du fonctionnement tMap ..............................................................................71
Mapper .............................................................................................................................72
Paramètres Input ..........................................................................................................74
Renseigner les tables ..................................................................................................74
Lier des tables input ...................................................................................................75
Joins Inner ..................................................................................................................76
Retirer des entrées de la table Input ...........................................................................77
Mapping de variables .................................................................................................77
Accéder aux variables globales et contextuelles .......................................................79
Supprimer des variables .............................................................................................79
Paramètres Output .......................................................................................................79
Filtres .........................................................................................................................80
Rejets .........................................................................................................................81
Rejets Inner Join ........................................................................................................81
Copyright © 2007 Talend Open Studio v

Retirer des entrées de la table Output ........................................................................82
Expression editor ..........................................................................................................82
Schema Editor ..............................................................................................................82
Activation/Désactivation d’un job ou sous-job ...............................................................84
Désactiver un composant Start .........................................................................................84
Désactiver un composant non-Start ..................................................................................84
Définition d’un contexte et de variables de job ..............................................................85
Ajouter ou renommer un contexte ....................................................................................85
Définir les paramètres de contexte ...................................................................................86
Variables et alias ............................................................................................................87
Création rapide de variables de contexte ......................................................................87
Requêtes StoreSQL ......................................................................................................89
Exécuter un job dans un contexte défini ..........................................................................89
Exécution d’un job ............................................................................................................90
Exécuter en mode normal .................................................................................................90
Afficher les statistiques ................................................................................................90
Afficher les traces .........................................................................................................91
Exécuter en mode debug .................................................................................................92
Enregistrement ou Exportation de jobs ..........................................................................92
Enregistrement d’un Job ...................................................................................................92
Exportation de job scripts .................................................................................................93
Raccourcis clavier .............................................................................................................93
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
vi Talend Open Studio Copyright © 2007

tFTP get ..........................................................................................................................113
tFTP rename ...................................................................................................................113
tFTP delete .....................................................................................................................113
Scénario: Charger des fichiers sur un serveur distant ....................................................113
tSendMail .........................................................................................................................115
Propriétés de tSendMail .................................................................................................115
Scénario: Envoi de notification d’erreur par email ........................................................115
tPerl ..................................................................................................................................118
Propriétés de tPerl ..........................................................................................................118
Scénario: Affichage du nombre de lignes traitées ..........................................................118
tSystem .............................................................................................................................121
Propriétés de tSystem .....................................................................................................121
Scénario: Affichage message dans sortie système .........................................................121
tFileInputRegex ...............................................................................................................123
Propriétés de tFileInputRegex ........................................................................................123
Scénario: Transformation de fichier Regex en XML .....................................................124
tDBInput ..........................................................................................................................127
Propriétés de tDBInput ...................................................................................................127
Scénario 1: Transformation de données de Bdd en XML ..............................................128
Scénario 2: Utilisation de StoreSQLQuery ....................................................................129
tMap .................................................................................................................................131
Propriétés de tMap .........................................................................................................131
Jeux de Scénarios ...........................................................................................................131
Scénario 1 : Mapping simple ......................................................................................131
Scénario 2 : Mapping avancé .....................................................................................137
Scénario 3 : Mapping de join en cascade ...................................................................143
tRowGenerator ................................................................................................................144
Propriétés de tRowGenerator .........................................................................................144
Scénario: Génération aléatoire de fichiers de test ..........................................................145
tAggregateRow ................................................................................................................147
Propriétés de tAggregateRow .........................................................................................147
Scénario: Aggrégation de valeurs et tri des données .....................................................148
tSortRow ..........................................................................................................................152
Propriétés de tSortRow ...................................................................................................152
Scénario: Tri de données ................................................................................................153
tUniqRow .........................................................................................................................155
Propriétés de tUniqRow .................................................................................................155
Scénario: Dédoublonnage d’entrées ...............................................................................155
tFileInputXML ................................................................................................................157
Propriétés de tFileInputXML .........................................................................................157
Scénario: Extraction d’adresses XML ............................................................................158
tCatcher, tWarn & tDie ..................................................................................................160
Propriétés de tCatcher ....................................................................................................161
Propriétés de tWarn ........................................................................................................161
Propriétés de tDie ...........................................................................................................162
Copyright © 2007 Talend Open Studio vii

Scénario1: warning & log sur un flux entrant ................................................................162
Scénario 2: log & kill un job ..........................................................................................164
tDBOutput .......................................................................................................................167
Propriétés de tDBOutput ................................................................................................167
Scénario: Affichage d’une sortie DB ............................................................................168
tFileInputMail .................................................................................................................171
Propriétés de tFileInputMail ...........................................................................................171
Scénario: Extraction des champs clé d’un email ............................................................171
tFileOutputLDIF .............................................................................................................174
Propriétés de tFileOutputLDIF .......................................................................................174
Scénario: Ecriture de données dans un fichier LDIF .....................................................175
tStatCatcher .....................................................................................................................177
Propriétés de tStatCatcher ..............................................................................................177
Scénario: Affichage des informations de log d’un job ..................................................177
tRunJob ............................................................................................................................180
Propriétés de RunJob ......................................................................................................180
Scénario: Exécution d’un job distant .............................................................................180
viii Talend Open Studio Copyright © 2007

A propos de ce manuel...
Historique des versions
Ce manuel s’adresse aux utilisateurs et administrateurs de Talend Open Studio.
Historique des versions
Le tableau ci-dessous liste les modifications apportées au Guide Utilisateur.
Version Date Historique

v 0.5.1 10/25/06 Distribution de la version française de Talend Open Studio Guide
Utilisateur
v 0.5.5 1/21/07 Suite à la distribution de Talend Open Studio version 1.1.0, mise à
niveau des informations générale du guide utilisateur FR avec celles
du guide Eng.
Ajoût de composants et mise à jour de composants.
v 0.7 3/5/07 Mise à niveau des composants. Version 0.7 du Guide Utilisateur
anglais.
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
Copyright © 2007 Talend Open Studio 1

Remarques et Support
2 Talend Open Studio Copyright © 2007

—Chapter 1—
Présentation de Talend Open Studio
Accès à Talend Open Studio
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.

Accès à Talend Open Studio
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.

Création d’un projet
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.
Création d’un projet
Commencez par donner un Nom à votre nouveau projet. Ce champ est obligatoire pour poursuivre le
processus de création.

Importation d’un projet
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.

Configuration de Talend Open Studio
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.

Description de l’interface utilisateur
Talend Open Studio s’ouvre sur une fenêtre à zones multiples.
Talend Open Studio est composé des vues suivantes:

• Reférentiel (Repository)
• Espace de modélisation et conception des business models et job designs (Workspace)
• Propriétés (Properties), Execution (Run Job) et Logs
• Aperçu Schema (Outline) et Aperçu du code (Code Viewer)
Les différentes vues et leurs fonctionnalités associées sont décrites dans la suite de ce manuel.
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.
Le bouton de rafraîchissement vous permet de mettre à jour

l’arborescence avec les dernières modifications
Cliquez pour importer des projets créés avec des versions

précédentes de TOS.
Sauvegardez toutes vos données dans les divers dossiers

projets (Business Models et Job Designs) et de métadonnées
(Routines, snippets, DB/File connections, toute
Documentation significative...)
L’arborescence du Repository rassemble les éléments suivants :
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.
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.
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
Vues Properties, Run Job et Logs
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.

Voir également: Vues Modules et Scheduler, page 15
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
Vues Modules et Scheduler
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.
Paramétrez l’heure et la date complète d’exécution de cette tâche.

Open Scheduler génère automatiquement la commande correspondante qui sera fournie au
programme crontab.
Vues Outline et Code
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.
La représentation graphique visible dans l’éditeur

est mise en évidence dans un rectangle bleu.
Cliquez sur la zone bleue du visionnage et
déplacez-la pour sélectionner une autre partie du
processus.
Remarquez que la vue dans l’éditeur se déplace de
la même manière.
L’aperçu Outline peut également afficher les
variables disponibles pour les composants utilisés
dans le diagramme. Développez le noeud d’un
composant pour afficher les variables appropriées
disponibles.
Pour passer d’un aperçu à l’autre, cliquez sur l’une
des icones situées en haut à droite de l’onglet.
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.

—Conception d’un Business Model—
Conception d’un Business Model
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.
Création ou ouverture d’un 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.

Création ou ouverture d’un business model
Cliquez droit sur Business Models et sélectionnez l’option

Expand/Collapse, pour afficher tous les modèles existants,
s’il en existe déjà.
Ouverture d’un business model
Double-cliquez sur le nom du business model que vous

souhaitez ouvrir.
Le business model sélectionné s’ouvre dans l’éditeur de
modélisation, généralement placé à droite du référentiel.
Création d’un business model
Cliquez droit sur Business Models et sélectionnez Create

Business Model.
L’assistant de création vous guide dans les étapes de creation
d’un Business Model.
Sélectionnez le répertoire de destination où vous souhaitez conserver votre nouveau model.
Puis donnez un Nom a ce Business Model dans le champ Name. Le nom que vous associez au fichier
apparaît au niveau de l’onglet du Business Model, dans l’espace de modélisation.
Le Modeler, ou espace graphique de modélisation, s’ouvre sur un espace de conception vide.
Vous pouvez créer autant de business models que vous le souhaitez. Un système d’onglets en haut
de l’éditeur vous permet de naviguer facilement entre tous les processus ouverts.

Modélisation d’un business model
Le Modeler est composé des vues suivantes :

• L’éditeur graphique de Talend Open Studio
• Une Palette de formes et de connexions spécifiques à la modélisation métier
• Un onglet de propriétés présentant toutes les informations spécifiques sur tout ou partie du
diagramme.
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.
Cliquer & déposer des objets
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.

Les formes disponibles comprennent :
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 :
• Sélectionnez l’outil Relationship de la Palette. Puis dans l’éditeur

de modélisation, tirez un lien d’une forme vers l’autre pour dessiner la
connexion.
• Ou si vous n’avez pas encore placé la forme cible de la connexion, vous pouvez créer la
relation et la cible en une fois.
Simplement placez votre souris au dessus de la forme source pour faire apparaître les double flèches.
Faites glisser l’une des flèches vers une zone vide de l’espace de modélisation, et relachez la souris
pour afficher le menu contextuel.
Sélectionnez Create Relationship puis la forme appropriée pour constituer l’élément cible ainsi
que la relation :

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.
Vous pouvez aussi créer une connexion vers un

élément déjà placé dans le processus. Sélectionnez
Existing Element dans le menu contextuel, puis
sélectionnez dans la liste l’élément cible.
La relation s’établit automatiquement entre les
deux formes sélectionnées.
La nature de cette connexion peut être décrite à
l’aide d’élements du référentiel de metadonnées et
sa mise en format peut être définie dans l’onglet
Properties.
Lors de la création d’une connexion, une zone de
saisie vous permet d’ajouter un libellé à la
connexion que vous venez de créer. Choisissez un nom significatif afin de vous aider à identifier
rapidement le type de relation créée.
Note: Vous pouvez également ajouter des notes et des commentaires à votre processus pour
permettre une reprise du modèle par la suite.
Voir également: Commentaires et réarrangement d’un Business Model, page 25.

Commentaires et réarrangement d’un Business Model
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.
Ajoût d’une note ou de texte libre

Pour ajouter une note, sélectionnez l’outil Note dans la Palette.
Alternativement cliquez droit sur la représentation graphique ou sur la forme que vous souhaitez
annoter et sélectionnez Add Note. Ou sélectionnez l’outil Note dans la barre d’accès rapide :
Une note de type Post-it apparaît sur l’espace de modélisation. Si la note est liée à un élément
particulier, un lien est automatiquement créé.
Saisissez votre commentaire dans la zone de saisie ou, si cette dernière ne s’affiche pas, saisissez
directement sur la note.
Si vous souhaitez relier votre note à une forme particulière de votre

processus, sélectionnez Note attachment dans la Palette puis glissez la
flèche noire vers une zone vide de l’éditeur. Relachez pour afficher le menu
contextuel du lien.
Vous pouvez également sélectionner la fonction Add Text pour saisir
librement du texte directement dans l’espace de modélisation. Vous pouvez
accéder à cette fonctionnalité dans le menu déroulant Note de la Palette ou
via le raccourci situé à côté de la fonction Add Note dans la barre d’accès rapide.
Réarrangement d’une vue métier

Vous pouvez adapter le look and feel de votre business model via le menu contextuel.

Placez votre curseur dans l’espace de modélisation,

cliquez droit pour afficher le menu, et sélectionnez
Arrange all. Les formes se déplacent
automatiquement pour une lisibilité optimale du
business model.
Vous pouvez également sélectionner manuellement
tout ou partie du processus.
Pour ce faire, cliquez droit n’importe où dans
l’éditeur, et choisissez Select dans le menu
contextuel.
Vous pouvez sélectionner :
• All : toutes les formes et connexions du
processus,
• All shapes : toutes les formes présentes dans
l’éditeur de modélisation,
• All connectors : toutes les connexions reliant les
formes.
A partir de ce menu, vous pouvez également zoomer avant et arrière sur une partie du modèle
et ainsi changer la vue affichée.
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)
Vue Rulers & Grid

Pour afficher l’onglet Rulers & Grid dans l’éditeur graphique, sélectionnez l’objet Select dans
la Palette, puis cliquez sur une zone vide de l’espace de modélisation pour désélectionner toute
sélection courante.
Cliquez sur l’onglet Rulers & Grid pour accéder aux paramètre de configuration des règles et
de la grille.

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.

• colorer les bordures

• ajouter du texte
• ajouter un effet dégradé
• ajouter un effet ombré
Vous pouvez également déplacer et gérer les différentes formes utilisées dans la vue de votre
business model à l’aide des outils d’édition. Cliquez droit sur une des formes, pour faire
apparaître les onglets appropriés.
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

Affectation d’éléments à un Business Model
Affectation d’éléments à un Business Model
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.
Une simple affectation (assignment) vous permet de définir et

décrire, en d’autres termes, d’ajouter des métadonnées à votre
business model, en lui associant différents types d’informations.
Vous pouvez mentionner la nature des métadonnées affectées ou
traitées, facilitant ainsi la phase de développement technique qui
interviendra ensuite.
Pour affecter un élément, glissez et déposez l’élément du
Repository vers une des formes composant votre business model
courant.
Vous pouvez également utiliser le bouton Un/Assign button pour
effectuer cette opération d’affectation.
Le tableau d’affectation, Assignment, situé sous l’espace de
modélisation est automatiquement mis à jour à l’aide les données
d’affectation de l’objet en sélection.
Vous pouvez retirer une affectation à l’aide du bouton Un/Assign.
Les types d’éléments du référentiel que vous pouvez affecter sont
les suivants:
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

Modification d’un Business model
Modification d’un Business model
Suivez la procédure qui convient au type de modification que vous souhaitez effectuer :
Renommer un business model
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.
Copier et coller un business model
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.
Déplacer un business model
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.
Supprimer un business model
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 .
Enregistrement d’un business model
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.

—Conception d’un Job Design—
Conception d’un Job Design
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).
Création ou Ouverture d’un job
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.

Création ou Ouverture d’un job
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.
Ouverture d’un job
Double-cliquez sur le libéllé du job que vous souhaitez ouvrir.

Le Designer s’ouvre sur la dernière vue enregistrée du job.
Note: Vous pouvez ouvrir autant de jobs que vous souhaitez. Un
système d’onglets en haut de l’éditeur vous permet de naviguer
très facilement entre tous les processus ouverts.
Création d’un job
Cliquez droit sur Job Designs dans le référentiel et sélectionnez

Create job dans le menu contextuel. L’assistant de création vous
guide dans les étapes de définition des propriétés de votre nouveau
job.

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.
Cliquer & Déposer des composants
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.

Plusieurs types d’icones d’information et d’avertissement peuvent s’afficher à côté du composant.

Placez le pointeur sur l’icone pour faire apparaître la bulle d’information. Ces icones s’affichent tant
que vous n’avez pas terminé de configurer correctement les propriétés de chacun des composants.
Voir également:
• Connexion des composants, page 36
• Avertissements et erreurs sur un composant, page 35
• Définition des propriétés d’un Job, page 39
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.
Réorganiser les onglets d’un job
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.
Avertissements et erreurs sur un composant
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.

Connexion des composants
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.
Les types de connexions diffèrent selon la nature du

composant et son rôle dans le job.
Les types de connexions disponibles varient également
si les données proviennent d’un ou plusieurs fichiers
d’entrée et si elles sont transmises vers un ou plusieurs
fichiers de sortie.
Sélectionnez un composant dans l’éditeur graphique et
cliquez droit pour afficher le menu contextuel. Tous les liens disponibles pour ce composant
particuliers apparaissent à l’écran.
Connexions de type Row

La connexion de type Row manipule les données elles-mêmes et leur transfert. Les liens de type
Row sont main, lookup ou output selon la nature du flux de données traité.
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.
Connexion de type Iterate

La connexion de type Iterate sert à boucler sur plusieurs fichiers d’un répertoire donné, sur les
lignes d’un fichier ou sur les entrées d’une base de données.
Un composant ne peut être la cible que d’un seul lien d’itération, Iterate. La connexion Iterate
est généralement utilisé sur le composant de début (Start) d’un flux principal ou secondaire.
Certains composants ne peuvent fonctionner avec d’autres composants qu’à l’aide d’un lien
d’itération, c’est le cas du composant tFilelist.
Note: A la différence des autres types de connexions, le nom du lien Iterate est en
lecture seule.

Définition des propriétés d’un Job
Connexions de type Trigger

Les connexions de déclenchement, trigger, aident à définir l’ordre de traitement.
La connexion utilisée met en place une relation de dépendance entre un processus principal et
ses sous-jobs. De cette manière, l’un ou l’autre des processus est déclenché en fonction de la
nature de cette connexion de déclenchement.
Il existe deux sortes de déclenchements: déclenchements chronologiques et déclenchements
contextuels.
Run Before et Run After sont des déclencheurs chronologiques, dans ce sens, où le composant
cible s’exécute avant ou après la fin de l’exécution du composant source. Ces deux connexions
déclencheurs ne peuvent être utilisées qu’avec des composants de début (Start).
Voir également : Définition du composant Start, page 44.
Run if, Run if OK et Run if Error sont trois déclencheurs contextuels. Ils peuvent être utilisés
avec n’importe quel composant source mais doivent avoir pour cible un composant Start de flux
principal ou secondaire.
• Run if OK ne déclenche l’exécution du composant cible qu’une fois, l’exécution du
composant source est terminée correctement. Il peut servir à déclencher un sous-job de
notification par exemple.
• Run if Error déclenche le sous-job ou composant cible lorsqu’une erreur a été
rencontrée dans le processus initial.
• Run if déclenche un sous-job ou composant si les conditions définies sont réunies.
Job à entrées/sorties multiples
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: LibelléOuBulle 
• Italique: LibelléOuBulle 
• Retour chariot: LibelléOuBulle ContinueLigneSuiv
• Couleur: LibelléOuBulle 
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.
Paramétrage d’un schéma built-in

Un schéma est dit ponctuel, et donc défini comme built in dans ses paramètres de propriétés,
lorsqu’il ne sert généralement qu’une fois dans un job.
Sélectionnez Built-in dans la liste, puis cliquez sur Edit Schema Puis créez votre schéma en y
ajoutant des colonnes, et en décrivant leur contenu selon la structure du fichier d’entrée.
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.
Paramétrage d’un schéma repository

Vous pouvez éviter d’avoir à recréer les mêmes schémas et leur métadonnées en créant des
fichiers de métadonnées que vous pouvez centraliser dans le répertoire Metadata du référentiel
(Repository).
Pour rappeler un fichier de métadonnées dans votre processus courant, sélectionnez Repository
dans le champ Schema type et sélectionnez le fichier approprié dans la liste. Puis cliquez sur
Edit Schema pour vérifier que les données sont appropriées.

Définition du composant Start
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
Définition du composant Start
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.

Définition des schémas de métadonnées
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.

Cette procédure diffère légèrement selon le type de

connexion choisie. Retrouvez ci-dessous les procédures
respectives pour configurer et définir plusieurs schémas.
Notez que dans tous les cas, la connexion au fichier ou à la
base de données ne sert qu’à copier les métadonnées sur
lesquelles sera basé le schéma stocké dans votre référentiel
(par extension, votre système de fichiers).
Cliquez sur Metadata dans le Repository pour développer
l’arborescence.
Chacun des quatre noeuds regroupe différents types de
connexions à configurer.
Configurer une connexion DB
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.
Etape 1: propriétés générales

Un assistant de connexion s’ouvre. Renseignez les propriétés générales du schéma, notamment
les champs Name et Description. Le champ Status est un champ personnalisé que vous pouvez
définir dans les Préférences (Window > Preferences > Talend).

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.

Etape 3: Chargement de la table

Un nouvel assistant s’ouvre sur la première étape. La liste des tables proposent toutes les tables
présentes sur la connexion définie précédemment. Il peut s’agir de n’importe quel type de BDD.
Sélectionnez une ou plusieurs tables dans la liste, pour les charger sur votre système de fichier
Référentiel. Vos schémas de Repository seront basés sur ces tables.
Si aucun schéma n’est visible dans la liste, cliquez sur Check connection, pour vérifier le statut
de la connexion à la base de données.
Cliquez Next une fois la sélection terminée. Sur la fenêtre suivante, quatre panneaux de
configuration vous permettent de définir les schémas à créer.
Etape 4: Définition du schéma

Par défaut, le schéma affiché dans le panneau Schema est basé sur la première tbale sélectionnée
dans la liste des schémas chargés (à gauche). Vous pouvez modifier le nom du schéma et selon
vos besoins, vous pouvez également personnaliser la structure du schéma.
En effet, la barre d’outils vous permet d’ajouter, d’enlever ou déplacer les colonnes de votre
schéma. Vous avez également la possibilité de charger un schéma xml ou exporter le schéma
courant en xml.
Pour restaurer un schéma basé sur l’une des tables chargées, sélectionnez le schéma de la table
dans la liste déroulante et cliquez sur Retrieve schema. Notez que le schéma ainsi chargé écrase
le schéma courant et ne retient aucune des modifications ponctuelles.
Cliquez sur Finish pour terminer la création des schémas de base de données. Tous les schémas
ainsi créés apparaissent sous le noeud de connexion de base de données.
Configurer un schéma File Delimited
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.

A la différence de l’assistant de connexion DB, l’assistant de connexion Delimited File regroupe,

en une seule procédure à quatre étapes, les deux phases: connexion au fichier et la définition de
schéma.
Etape 1: Propriétés générales

Pour la première étape, renseignez les informations générales du schéma, notamment les
champs Name et Description.
Les champs génériques étant identiques pour tous les schémas, pour plus d’informations,
voir Configurer une connexion DB page 46.
Etape 2: Chargement du fichier

Renseignez l’adresse IP du serveur, où le fichier est conservé. Et cliquez sur Browse... pour
définir le chemin d’accès au fichier, dans le champ File path.

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.

Dans cette vue, vous pouvez affiner la description de vos données et les paramètres de fichier.
Cliquez sur les rectangles verts pour des informations spécifiques.

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.
Etape 4: Schéma final

La dernière étape affiche le schéma de fichier délimité généré. Vous pouvez personnaliser le
tableau.

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.
Configurer un schéma File Positional
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.
Etape 1 : Propriétés générales

Renseignez les informations générales du schéma tel que décrit dans la section Configurer une
connexion DB, page 46.
Etape 2 : Connexion et chargement du fichier

Puis définissez les paramètres de connexion au fichier positionnel, en renseignant les champs
Server IP address et File path.
Comme pour la création d’un schéma Delimited File, le format est demandé pour pré-remplir
des champs dans 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 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.
Etape 3 : Affinage du schéma

L’étape suivante ouvre la fenêtre de paramétrage du schéma. De la même manière que pour le
schéma de fichier délimité, vous pouvez affiner la définition du schéma en précisant les
séparateurs de champs et de lignes (Field separator et Row separator), le nombre de ligne du
message d’entête, si besoin est.
A ce stade, l’aperçu affiche le fichier delimité par la position des marqueurs. Si la fichier
contient des libellés de colonn, cochez la case Set heading row as column names.
Etape 4 : Schéma final

L’étape 4 affiche le schéma généré final. Remarquez sur tout caractère du fichier pouvant être
mal interprété par la suite, par le programme, est remplacé par un caractère neutre. Par exemple,
les tirets soulignés remplacent les asterisques.
Vous pouvez ajouter un nom personnalisé (par défaut, metadata) et apporter des modifications
à l’aide de la barre d’outils.
Vous pouvez également restaurer ou mettre à jour le schéma du fichier positionnel en cliquant
sur Guess. Notez cependant que toute modification ou personnalisation du schéma n’est pas
conservée lorsque vous cliquez sur Guess.
Configurer un schéma File Regex
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.
Etape 1: Propriétés générales

Renseignez les informations générales du schéma tel que décrit dans la première étape de la
section Configurer une connexion DB, page 46.
Etape 2 : Chargement du fichier

Puis définissez les paramètres de connexion au fichier Regex, en renseignant les champs Server
IP address et File path.

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.
Etape 3 : Définition du schéma

Cette étape ouvre la fenêtre de paramétrage du schéma. en précisant les séparateurs de champs
et de lignes (Field separator et Row separator), le nombre de ligne du message d’entête, ou
autre...
Dans le panneau de paramétrage des expressions régulières, Regular Expression settings,
saisissez l’expression régulière utilisée pour délimiter le fichier.
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.

Vous pouvez ajouter un nom personnalisé (par défaut, metadata) et apporter des modifications
à l’aide de la barre d’outils.
Vous pouvez également restaurer ou mettre à jour le schéma du fichier Regex en cliquant sur
Guess. Notez cependant que toute modification ou personnalisation du schéma n’est pas
conservée lorsque vous cliquez sur Guess.
Cliquez sur Finish pour valider. Le nouveau schéma apparaît dans le référentiel, sous le noeud
correspondant à la connexion Regex appropriée.
Configurer un schéma LDIF
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.


Pour commencer, renseignez les informations génériques telles que Schema Name et
Description.

Puis définissez les paramètres de connexion au fichier Ldif, en renseignant le champ File path.
Note: La fonctionnalité de connexion à un serveur distant n’est pas opérationnel pour

l’instant pour la récupération de fichier Ldif.
L’aperçu de fichier affiche les 50 premières lignes du fichier.
Etape 3: Définition de schéma

La liste des attributs du fichier de description s’affiche en haut de la fenêtre. Cochez les cases
correspondant aux attributs que vous souhaitez extraire du fichier de description Ldif.

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

Le schéma généré affiche les colonnes du fichier de description. Vous pouvez le personnaliser
selon vos besoins ou recharger le schéma oroginal à l’aide du bouton Guess.
Cliquez sur Finish. Le nouveau schéma s’affiche comme une nouvelle entrée de l’arborescence
du Repository sous le noeud de connexion Ldif approprié.
Configurer un schéma File XML
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.

Pour commencer, renseignez les informations génériques telles que Schema Name et
Description.

Renseignez le chemin d’accès au fichier XML à charger, puis renseignez le champ Encoding
si le système l’a pas détecté automatiquement.
L’aperçu de fichier affiche la structure XML.
Cliquez sur Next pour continuer.

Renseignez les paramètres à prendre en compte pour la définition du schéma.

La fenêtre de définition de schéma se compose de quatre vues:

• Source Schema: arborescence du fichier XML
• Target Schema: Information d’extraction et d’itération
• Preview: aperçu du schéma cible
• File viewer: fenêtre d’aperçu des données brutes

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.

Création de requêtes à l’aide de SQLBuilder
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é.
Etape 4 : Schéma final

Le schéma généré affiche les colonnes sélectionnées dans le fichier XML. Vous pouvez
personnaliser ce schéma selon vos besoins ou recharger le schéma d’origine à l’aide du bouton
Guess.
Cliquez sur Finish. le nouveau schéma s’affiche dans le Repository sous le noeud File XML
approprié.
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.
L’éditeur de requêtes SQL est composée de quatre vues :

• Database structure : arborescence de la base de données
• Query editor :Editeur de requêtes SQL
• Query results view : Résultats des requêtes de l’éditeur
• Schema view : Vue du schéma
La structure de la base de données indique les tables pour lesquelles un schéma a été défini, soit dans
une entrée du Repository, soit directement dans votre connexion des propriétés built-in de votre
composant.
La vue Schema view (bas droite de la fenêtre) fournit une description des colonnes.

Comparaison des structures de base de données
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.
Construction d’une requête
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.

Mapping de données
Accédez à la liste d’auto-complétion par Ctrl+Espace.

L’outil d’aide à la complétion vous propose une liste de déclarations SQL courantes (Select, From,
And, Groupby...) ainsi les colonnes de la table qui peuvent faire l’objet d’une 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.

Mapping de données
Présentation du fonctionnement tMap
tMap permet de réaliser les opérations suivantes :

• multiplexage et démultiplexage des données
• transformation des données sur tout type de champs
• concaténation et inversion de champs
• filtrage de champs à l’aide de filtres
• gestion des rejets de données
Etant donné que toutes ces opérations de transformation et/ou routage sont réalisées par le tMap, ce
composant ne peut être ni un composant Start ni un composant End dans un Job Design.
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

Mapping de données
que la fonction d’aperçu de l’éditeur de mapping soit disponible dans le panneau Properties de
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.

Mapping de données
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.

Mapping de données
Le Mapper est composé des panneaux suivants :

• La zone Input sur le coté gauche de l’éditeur. Les tableaux Input offrent une représentation
structurée (schémas) de tous les flux entrants (main et lookup). Les données sont regroupées
dans plusieurs colonnes des schémas Input. Notez que le nom de la table reflète le nom du
lien Main ou Lookup dans l’espace de modélisation graphique du job.
• La zone Variable est au centre de l’éditeur. Ce tableau de variable permet de centraliser des
informations redondantes et de réaliser les transformations.
• La zone Output est située à droite de la fenêtre. Les tableaux Output permettent d’aiguiller
les données et les champs provenant des schémas Input et des variables vers les schémas de
sortie Output.
• Les deux panneaux situés en bas de la fenêtre sont les descriptions des schémas d’entrée et
de sortie. L’onglet Schema editor détaille les schémas des tables Input et Output
sélectionnés.
• L’onglet Expression editor est l’outil de rédaction des clés d’expression des schémas
Input/Output, des variables ou des conditions de filtre.
Le nom des schémas Input/Output dans l’éditeur de mapping reflète le nom des connexions
entrantes et sortantes du composant tMap.
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.
Renseigner les tables

Pour renseigner les tables Input définissez d’abord les
schémas de tous les composants d’entrée connectés au
composant tMap.
Le contenu de la connexion main Row entrante, est reproduit
dans la première table de la zone Input du Mapper.

Mapping de données
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
Lier des tables input

Etant donné que des données Main et Lookup (provenant respectivement d’un flux principal
et d’un flux secondaire) peuvent être liés à l’aide des clés d’expression (expression keys),
l’ordre des tables a de l’importance.
En effet, un lien Join vous permet de sélectionner des données d’une table input via une
autre table input.
Glissez et déposez le nom de colonne d’une table vers sa table subordonnée, afin de créer
un Join entre les deux tables. Vous pouvez ainsi appeler des données à partir d’entrées
multiples.
Vous pouvez créer des Joins directs entre la table principale et les tables secondaires. Mais
vous pouvez également créer des Joins indirects à partir d’une table principale vers une
table secondaire, elle-même reliée à une autre table secondaire, afin d’accéder aux données
de cette seconde table.

Mapping de données
La relation Join se traduit graphiquement par un lien violet.

Note: Vous ne pouvez pas créer un Join à partir d’une table subordonnée vers une
table de niveau supérieur.
Le champ Expression key est renseigné par glisser-déposer des données en Join. Ce champ
est modifiable dans la table de la zone Input, ou à partir de la vue Schema.
Le nom des colonnes n’est par contre modifiable qu’à partir du panneau Schema,
correspondant à la table Input sélectionnée.
Lors de votre glisser-déposer vers la colonne Expr.key, vous avez la possibilité soit d’insérer
les données sélectionnées dans une nouvelle entrée ou de remplacer une entrée existante, le
cas échéant, ou encore de concaténer une selection multiple dans une seule cellule.
Pour plus d’informations concernant les types de

glisser-déposer possibles, voir Paramètres Output, page 79.
Les icones dans le coin supérieur droit des tables Input vous
permettent de réduire ou restaurer la taille des tables dans la
zone Input.
Notez que même si vous reduisez la taille d’une table dans
la zone Input, les Joins éventuels restent visibles.
La création d’un Join assigne automatiquement une clé au
niveau du nom de champ de la table reliée.
Lorsque vous supprimez un lien Join entre deux tables, une boite de dialogue vous demande
de confirmer la suppression de la clé du champ cible du lien Join.
WARNING—Si vous décidez de conserver la clé sur le champ cible, sans que le champ Expr. Key soit
renseigné, sachez que l’exécution du code peut provoquer des erreurs.
La clé (Key) est indiquée sur le schéma Input au niveau de la table ou au niveau du panneau
Schema, qui vous permet également de décocher la case Key pour la désactiver.
Voir également: Schema Editor, page 82
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

Mapping de données
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.
Voir également : Rejets Inner Join, page 81
Retirer des entrées de la table Input

Pour enlever des entrées Input, cliquez sur la croix de couleur rouge dans l’éditeur Schema
de la table sélectionnée. Appuyez sur Ctrl ou Maj pour réaliser une sélection multiple de
champs/colonnes à retirer de la table.
Note: Vous pouvez enlever des entrées Input d’un schéma d’entrée dans le Mapper,
cependant cette suppression est également effectuée dans la définition du
schéma au niveau des propriétés du composant en entrée.
Mapping de variables
La table Variables regroupe toutes les variables de mapping, qui peuvent être utilisées à
différents endroits du mapper.

Mapping de données
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.
Il existe plusieurs possibilités pour créer des variables :

• Saisissez librement vos variables en Perl. Saisissez les chaines de caractères entre
guillemets simples ou concaténez plusieurs fonctions à l’aide de l’opérateur Perl
approprié.
• Ajoutez de nouvelles lignes à la table à l’aide du bouton plus et retirez des lignes à l’aide
du bouton moins; Puis appuyez sur Ctrl+Space to retrieve existing global and context
variables.
• Glissez et déposez une ou plusieurs entrées Input dans la table Var.
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:

Mapping de données
Comment faire pour... Actions associées

Insérer toutes les entrées sélectionnées Faites simplement un glisser-déposer vers la table Var.
comme variables séparées. Des flèches latérales vous indiquent où la nouvelle
entrée Var peut être insérée. Chacune des Input est
insérée dans une cellule séparée.
Concaténer toutes les entrées Glissez-déposez vers l’entrée Var à concaténer, elle se
sélectionnées avec une entrée Var met alors en surbrillance. Toutes les entrées sont
existante. concaténées dans une seule cellule. Ajoutez les
opérateurs requis à l’aide des signes opérateurs Perl
approprié. Le point permet la concaténation.
Ecraser une entrée Var par les entrées Glissez-déposez vers l’entrée Var appropriée qui se
Input sélectionnées, et les concaténer. met alors en surbrillance. Puis appuyez sur Ctrl et
relâchez. Toutes les entrées sélectionnées sont
concaténées et écrasent la variable sélectionnée.
Concaténer les entrées Input Glissez-déposez vers des Var existantes puis appuyez
sélectionnées, avec plusieurs entrées Var sur Maj. Les premières entrées sont concaténées avec
mises en surbrillance. Créer de nouvelles les entrées Var en surbrillance, et si nécessaire, de
lignes en cas de besoin. nouvelles lignes sont créées pour contenir les entrées
restantes.
Accéder aux variables globales et contextuelles

Appuyez sur Ctrl+Space pour accéder à la liste de semi-complétion des variables globales
et de contexte.
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.
Supprimer des variables

Pour retirer une entrée Var sélectionnée, cliquez sur la croix rouge. La ligne entière est
supprimée ainsi que tous les liens avec des tables Input ou Output.
Utilisez les touches Ctrl ou Maj pour effectuer une selection multiple, puis cliquez sur la
croix rouge pour supprimer l’ensemble des lignes sélectionnées.
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.

Mapping de données
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.

Mapping de données
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.
Rejets Inner Join

L’Inner Join est un Join Lookup (de table secondaire). La table de rejet Inner Join un type
particulier de table de rejet de sortie. Elle regroupe les données rejetées d’une table de flux
principal après qu’un Inner Join n’a pas pu être établi.

Mapping de données
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.
Retirer des entrées de la table Output

Pour retirer des entrées d’une table Output, cliquez sur le signe moins dans l’éditeur de
Schema de la table sélectionnée.
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.

Mapping de données
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.

Activation/Désactivation d’un job ou sous-job
Passez la souris au-dessus du champ invalide pour faire apparaitre le message d’erreur
correspondant.
Activation/Désactivation d’un job ou sous-job
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.
Alternativement, cliquez droit sur le composant et sélectionnez la commande Activate/Deactivate qui

s’affiche en fonction du statut courant du composant.
Si vous désactivez un composant, aucun code ne sera généré et vous ne pourrez ni ajouter ni modifier
de liens à partir de ce composant vers des composants actifs ou nouveaux.
Voir également: Définition du composant Start, page 44.
Désactiver un composant Start
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.
Désactiver un composant non-Start
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.

Définition d’un contexte et de variables de job
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.
Ajouter ou renommer un contexte
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.

La liste déroulante Default Context propose tous les

contextes créés pour ce job design.
Vous avez la possibilité de changer de contexte par
défaut en sélectionnant un nouveau contexte dans la
liste.
Notez qu’il est impossible de supprimer un contexte
par défaut car l’exécution d’un processus requiert un
contexte. Ce contexte peut s’appeler Default mais
peut également porter un autre nom de votre choix.
Définir les paramètres de contexte
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
Création rapide de variables de contexte

Créez rapidement vos variables de contexte à l’aide de la touche F5:
• Placez votre curseur sur le champ que vous souhaitez entrer en paramètres de contexte.
• Appuyez sur F5 pour afficher la boîte de dialogue de création des paramètres de
contexte.

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

Vous pouvez modifier la variable à n’importe quel moment.
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.
Exécuter un job dans un contexte défini
Vous pouvez sélectionner le contexte dans lequel vous souhaitez exécuter votre job.
Cliquez sur l’onglet Run Job, et dans la partie Context, sélectionnez le

contexte approprié.
Si vous n’avez pas créé de contexte, seul le contexte par défaut, Default,
est proposé dans la liste.
Toutes les variables de contexte que vous avez créées pour le contexte en
sélection, ainsi que leur valeur associée apparaissent dans un tableau. Si

Exécution d’un 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 .
Exécuter en mode normal
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.
Afficher les statistiques

La fonction Statistics affiche le taux de performance de chacun des composants, sous son icone
dans l’éditeur graphique.

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.
Afficher les traces

La fonctionnalité de suivi est relativement simple dans TOS, pour l’instant. Mais cette
fonctionnalité devrait être améliorée à l’avenir.
Cette option fournit un aperçu ligne à ligne du comportement du composant et affiche le résultat
dynamique de cette vue à côté de la connexion Row.
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.

Enregistrement ou Exportation de jobs
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.
Exécuter en mode debug
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.
De cette manière, le processus s’arrêtera automatiquement régulièrement, vous

permettant ainsi de vérifier pas à pas les composants et leurs variables respectives et
de corriger les bugs éventuels.
Pour ajouter des pauses (breakpoints) au niveau d’un composant, cliquez droit sur le
composant dans l’espace de modélisation puis sélectionnez Add breakpoint dans
le menu contextuel.
L’icone pause d’affiche à gauche du composant dans l’éditeur graphique.
Pour passer en mode debug, cliquez sur le bouton Debug dans le panneau Run Job. Talend Open
Studio ouvre l’éditeur en mode de débogage.
Vous pouvez exécuter le job pas à pas et vérifier le comportement de chacun des composants ainsi
que les valeurs des variables utilisées.
Pour revenir en mode normal Talend Open Studio, cliquez sur Window, puis Perspective et
sélectionnez Talend Open Studio.
Enregistrement ou Exportation de jobs
Enregistrement d’un Job
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.

Raccourcis clavier
Exportation de job scripts
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 :

Raccourcis clavier
Pour... Contexte Raccourci

Afficher la vue Properties Application globale F3
Afficher la vue Run Job Application globale F4
Exécuter le job courant ou afficher la vue Run Application globale F6
Job si aucun job n’est ouvert.
Afficher la vue Module Application globale Ctrl + F2
Afficher la vue Problems Application globale Ctrl + F3
Revenir à la vue Job Design courante Application globale Ctrl + H
Afficher l’onglet Code du job courant Application globale Ctrl + G
Synchroniser les templates perljet des Application globale Ctrl + Maj + F3
composants et les classes java associées
Passez en mode Debug Dans la vue Run Job F7
Créer une variable de contexte à partir d’un Dans la vue Properties d’un job F5
champ Properties
Tuer le job courant Dans la vue Run Job F8
Rafraichir le statut d’installation des Modules Dans la vue Modules F5
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—
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

Composants
tMsgBox
tMsgBox
Propriétés de tMsgBox
Famille du composant Misc

Fonction Ouvre une boîte de dialogue avec un bouton OK. Requiert une action de
la part de l’utilisateur.
Objectif tMsgBox est une pause graphique dans le cours du traitement.
Propriétés Title Le texte saisi s’affiche dans la barre de titre de la
boite de dialogue.
Buttons Liste des boutons que vous souhaitez inclure dans
la boite de dialogue. Les combinaisons de bouton
sont restreintes et ne peuvent être changées.
Icon Icone de la barre de titre de la boite de dialogue.
Message Texte libre à afficher dans la boîte de dialogue. Le
texte peut être dynamique (ex: reprendre un nom
de fichier)
Utilisation Ce composant peut etre utilisé comme étape intermédiaire du traitement
ou comme composant de début ou de fin d’un job design. Il peut être
connecté à l’aide d’un lien Row ou Iterate.
Limitation tMsgBox ne fonctionne que sur Windows OS.
Scénario test de type ‘Hello World’
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

Composants
tMsgBox
• ‘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

Composants
tFileInputDelimited
tFileInputDelimited
Propriétés de tFileInputDelimited
Famille du composant File

Fonction tFileInputDelimited lit un fichier ligne à ligne et sépare des champs simples.
Objectif Ouvre un fichier et le lit ligne à ligne afin de le diviser en champs et d’envoyer les
champs définis par le Schéma au composant suivant, via un lien Row.
Propriétés Property type Peut être Built-in ou Repository.
Built-in: Propriétés utilisées ponctuellement.
Repository: Sélectionnez le fichier de propriétés du
composant. Les champs suivants sont alors pré-remplis à
l’aide des données collectées.
File Name Nom du fichier à traiter.
Voir également :Variables et alias, page 87
Field separator Caractère, chaine ou expression régulière séparant les champs.
Row separator Caractères (ex: “\n”sur Unix) séparant les lignes
Header Nombre de lignes à ignorer au début d’un fichier.
Footer Nombre de lignes à ignorer à la fin d’un fichier.
Limit Nombre max. de lignes à traiter. Si Limit = 0, aucune ligne
n’est lue ni traitée.
Schema type et Edit Un schéma est une description de ligne, i.e. il définit le
Schema 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
design. Voir également : Paramétrage d’un schéma
repository, page 43
Skip empty rows Cochez cette case pour ignorer les lignes vides.
Extract random Cochez cette case pour définir un nombre de lignes à extraire
number of lines de façon aléatoire
Encoding Champ texte libre. Talend ne peut pour l’instant vérifier
l’encodage, mais cette fonction devrait être ajoutée à l’avenir.
Utilisation Utilisez ce composant pour lire un fichier et séparer les champs à l’aide du séparateur
spécifié.

Composants
tFileInputDelimited
Scénario: Affichage du contenu d’un fichier délimité
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).
• Cliquez et déposez un composant tFileInputDelimited de la Palette vers le workspace.

• De la même manière, cliquez et déposez un composant tLogRow.
• Cliquez droit sur le composant tFileInputDelimited et sélectionnez Row > Main dans le
menu contextuel. Puis glissez ce lien vers le tLogRow et relâchez lorsque le symbole de
prise de courant apparaît.
• Sélectionnez le composant tFileInputDelimited à nouveau et définissez ses propriétés :
• 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.

Composants
tFileInputDelimited
• 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.
La console affiche l’en-tête suivis des données lues par le job.

Composants
tFileInputPositional
Propriétés de tFileInputPositional

Fonction tFileInputPositional lit un fichier ligne à ligne et extrait les champs selon un pattern.
Objectif Ouvre un fichier qu’il lit ligne à ligne et sépare les champs tels que definis par le schéma,
puis passe ces données extraites au composant suivant via un lien Row.
Repository: Sélectionnez le fichier où sont stockées les
propriétés du composant. Les champs suivants sont alors
pré-remplis à l’aide des données collectées.
File Name Nom du fichier à traiter. Voir également:Variables et alias,
page 87
Field separator Caractère, chaîne ou expression régulière séparant les
champs.
Row separator Caractères (ex: “\n”sur Unix) séparant les lignes
Header Nombre de lignes à ignorer au début d’un fichier.
Footer Nombre de lignes à ignorer à la fin d’un fichier.
Limit Nombre max. de lignes à traiter. Si Limit = 0, aucune ligne
n’est lue ni traitée.
Schema type and Edit Un schéma est une description de ligne, i.e. il définit le
Schema 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. Il peut être réutilisé dans divers projets et job
designs. Voir également : Paramétrage d’un schéma
repository, page 43
Pattern Longueurs séparées par des virgules, interprétées comme une
chaîne de caractères entre guillemets. Vérifiez que les valeurs
saisies dans ce champ sont cohérentes avec le schéma défini.
Encoding Champ texte libre. Talend ne peut pour l’instant vérifier
l’encodage, mais cette fonction devrait être ajoutée à l’avenir.
Utilisation Utilisez ce composant pour lire un fichier et séparer les champs à l’aide du séparateur
spécifié.

Composants
Scénario: Transformation d’un fichier positionnel en XML
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.
• Cliquez et déposez un composant tFileInputPositional de la Palette de composants vers

• Cliquez et déposez un composant tFileOutputXML. Ce fichier recevra les références
structurées.
• Cliquez droit sur le composant tFileInputPositional et sélectionnez le lien Row > Main.
Glissez ce lien vers le second composant en maintenant le bouton de la souris enfoncée et
relâchez la souris lorsque le symbole de prise de courant apparaît.
• Sélectionnez le composant d’entrée à nouveau et définissez ses propriétés :
• Les propriétés de ce job sont de type built-in pour ce scénario. Par conséquent les
informations de propriétés sont renseignées pour ce job seulement et ne peuvent être
réutilisées pour un autre job, contrairement à des propriétés de type Repository.
• Renseignez le chemin d’accès au fichier dans le champ File Name. Ce champ est obligatoire.

Composants
• 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.
Puis définissez les propriétés du composant de sortie :

Composants
• 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.

Composants

Composants
tFileOutputXML
tFileOutputXML
Propriétés de tFileOutputXML

Fonction tFileOutputXML produit en sortie un fichier de données de type XML.
Objectif tFileOutputXML écrit dans un fichier XML des données séparées selon un
schéma spécifié.
Propriétés File name Nom ou chemin d’accès du fichier de sortie. Voir
également : Variables et alias, page 87
Root tag Enveloppe les données et la structure entière du
fichier de sortie
Row tag Enveloppe les données et la structure de chaque
ligne.
Column name as tag Cochez cette case pour récupérer les libellés de
name colonnes du schéma d’entrée et les utiliser comme
balise xml.
Split output in files Si le fichier XML en sortie est volumineux, vous
pouvez scinder ce fichier en plusieurs parties.
Schema type and 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 (référentiel).
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
Sync columns Cliquez pour synchroniser le schéma de sortie avec le
schéma d’entrée. La fonction Sync ne s’affiche que si
une connexion de type Row est liée au composant de
sortie.
Encoding Champ texte libre. Talend ne peut pour l’instant
vérifier l’encodage, mais cette fonction devrait être
ajoutée à l’avenir.
Utilisation Utilisez ce composant pour écrire dans un fichier XML des données
récupérées d’autres composants à l’aide d’un lien Row.
Limitation n/a

Composants
tFileOutputXML
Scénario: Utilisation d’un format de sortie XML
Un scénario utilisant le composant tFileOutputXML est décrit dans Scénario: Transformation d’un
fichier positionnel en XML, page 102.

Composants
tLogRow
tLogRow
Propriétés de tLogRow
Famille du composant GUI

Fonction Affiche les données ou les résultats dans la console Run Job.
Objectif tLogRow permet de superviser les donnés traitées.
Propriétés Separator Saisissez le séparateur qui permet de délimiter les
données dans la console.
Utilisation Ce composant peut être utilisé comme étape intermédiaire dans le flux de
données ou comme composant de fin de job. Il sert généralement à
vérifier la cohérence et la qualité des données en sortie, en vue de
d’alimenter une base de données par exemple.
Limitation n/a
Scénario: Affichage dans la console
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.

Composants
tFileList
tFileList
Propriétés de tFileList

Fonction tFileList boucle sur les fichiers d’un répertoire donné.
Objectif tFileList récupère un groupe de fichiers suivant un masque donné, et
boucle sur chacun des fichiers.
Propriétés Directory Chemin d’accès au répertoire de fichiers.
Filemask Nom de fichier ou masque de fichier utilisant un
caractère spécial (*) .
Case sensitive Crée (ou non) un filtre selon la casse des noms de
fichiers.
Utilisation tFilelist fournit une liste de fichiers à partir d’un répertoire donné, sur
lequel il boucle.
Scénario: Itération sur un répertoire
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.
• Cliquez et déposez les composants suivants: tFileList, tFileInputDelimited et tLogRow

dans l’espace de modélisation.
• Cliquez-droit sur le tFileList et tirez un lien Row > Iterate vers le composant
tFileInputDelimited. Puis tirez un lien Row > Main du tFileInputDelimited vers le
composant de sortie, tLogRow.
• Puis définissez les propriétés respectives des composants.
• Sélectionnez le composant tFileList, dans l’onglet Properties :

Composants
tFileList
• 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.

Composants
tFileList
• Sélectionnez le composant de sortie, tLogRow, et renseignez le séparateur de champs qui

s’affichera dans la console de l’onglet Run Job. Pour plus d’infos sur les propriétés du
tLogRow, voir également: tLogRow, page 108
• Passez à l’onglet Run Job et exécutez le job.
L’itération s’effectue sur le répertoire défini en entrée. Chacun des fichiers contenus dans ce
répertoire est lu. Puis les données délimitées sélectionnées sont transmises au composant de sortie
qui les affiche dans la sortie standard.

Composants
tFTP
tFTP
Propriétés de tFTP
Famille du composant Internet

Fonction Cet objet transmet des fichiers via une connexion FTP.
Objectif Les utilisations de tFTP varient selon l’action sélectionnée. .
Propriétés Host Addresse IP du site FTP
Port Port d’écoute du site FTP
Username and Données d’authentification FTP de l’utilisateur
Password
Local directory Chemin d’accès au fichier. L’usage de ce champ
dépend de l’action sélectionnée.
Remote directory Chemin d’accès au fichier. L’usage de ce champ
dépend de l’action sélectionnée.
Action Liste des actions disponibles pour transférer des
fichiers. Voir également : tFTP put, tFTP get,
tFTP rename, tFTP delete, page 113.
Files Masque de fichier et Nouveau Nom en cas de
renommage d’une action. Caractère jocker (*)
peut être utilisé pour transférer un groupe de
fichiers. Ou cliquez droit pour ajouter des lignes
au tableau.
Utilisation Ce composant est généralement utilisé seul comme sous-processus mais
peut également servir de composant de fin ou de sortie.
Limitation tFTP ne peut pas gérer en même temps, une action Get et une action Put.
Afin de pouvoir réaliser les deux actions en parallèle, il est recommandé
de dupliquer le composant tFTP dans le job et de les paramétrer chacun
pour une action.
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.

Composants
tFTP
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.
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.
tFTP delete
Objectif tFTP delete supprime des fichiers d’un système distant

Local directory Inutilisé pour cette action.
Remote directory Répertoire source où se trouvent les fichiers à supprimer.
Filename Noms de fichiers ou chemin d’accès aux fichiers à supprimer.
Scénario: Charger des fichiers sur un serveur distant
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.

Composants
tFTP
• 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.

Composants
tSendMail
tSendMail
Propriétés de tSendMail
Famille du composant Internet

Fonction tSendMail envoie des emails et des pièces jointes aux destinataires
spécifiés.
Objectif tSendMail a pour objectif de notifier les destinataires d’un état
particulier du job ou de possibles erreurs.
Propriétés To Adresse email du destinataire principal.
From Adresse email du serveur d’envoi
Cc Copie carbone destinataire
Subject Entête du message
Message Corps du message de l’email. Appuyez sur
Ctrl+Espace pour afficher la liste des variables
disponibles.
Attachment Masque de fichier ou chemin d’accès au fichier à
envoyer en pièce jointe, le cas échéant.
SMTP server Adresse IP du serveur SMTP d’envoi de mails.
Utilisation Ce composant est généralement utilisé comme sous-processus mais peut
également servir de composant de sortie ou de fin. Il peut être connecté
à d’autres composants à l’aide de connexion Row ou Iterate.
Limitation Les envois d’emails avec ou sans pièce jointe requièrent des modules
Perl différents.
Scénario: Envoi de notification d’erreur par email
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.
• Cliquez et déposez les composants suivants de la Palette vers l’espace de modélisation :

tFileInputDelimited, tFileOutputXML et tSendMail

Composants
tSendMail
• Définissez les propriétés du composant d’entrée tFileInputDelimited. Voir également:

tFileInputDelimited, page 98
• Cliquez droit sur ce composant et sélectionnez Row > main pour connecter le composant
d’entrée avec le composant de sortie tFileOutputXML. Relâchez la souris lorsque le
symbole de prise de courant apparaît.
• Définissez les propriétés du composant de sortie tFileOutputXML; Voir également:
tFileOutputXML, page 106
• Cliquez-droit à nouveau sur le composant tFileInputDelimited en entrée, et sélectionnez un
lien Trigger, Run if Error et connectez -le au composant tSendMail.
• Définissez les destinataires du mail, les informations de transmission.
• 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.

Composants
tSendMail
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.

Composants
tPerl
tPerl
Propriétés de tPerl
Famille du composant Processing

Fonction tPerl transforme toute donnée saisie en argument de commande Perl.
Objectif tPerl est un éditeur Perl qui peut être utilisé comme un outil très flexible
dans un job.
Propriétés Code Saisissez le code Perl approprié selon la
commande et les tâches que vous souhaitez
effectuer. Pour plus d’informations concernant la
syntaxe des fonctions Perl, voir Talend Open
Studio online Help, sous Talend Open Studio
User Guide > Perl.
Utilisation Sert généralement au debogage mais peut également servir à afficher le
contenu de variables.
Limitation Ce composant requiert un niveau de connaissance Perl avancé et est
généralement utilisé plutôt de façon ponctuelle. Il n’est pas conçu pour
une utilisation avec une connexion de type Row.
Scénario: Affichage du nombre de lignes traitées
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.

Composants
tPerl
• 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.

Composants
tPerl
• 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.
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.

Composants
tSystem
tSystem
Propriétés de tSystem
Famille du composant System

Fonction tSystem exécute une ou plusieurs commandes système.
Objectif tSystem appelle d’autres commandes de traitement, qui peuvent être déjà
mises en place et opérationnelles dans un job plus important.
Propriétés Command Saisissez la commande système. Note : la
vérification syntaxique n’est pas prise en charge.
Output Sélectionnez le type de sortie de la donnée traitée.
to console: Sortie standard qui transmet les
données pour affichage dans la console.
to global variable: Les données sont placées
dans une variable de sortie liée au composant
tsystem
Utilisation Ce composant est généralement utilisé lorsqu’une entreprise a déjà mis
en place des applications qu’elle souhaite intégrer au flux de traitement
dans Talend.
Limitation n/a
Scénario: Affichage message dans sortie système
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:

Composants
tSystem
• Saisissez la commande echo et la chaîne de caractères “Hello World!” dans le champ

Command.
• Sélectionnez l’option To global variable dans le champ Output pour intégrer la valeur de
sortie de la commande dans une variable.
• Puis sélectionnez le composant tPerl
• Saisissez une commande Perl pour afficher la valeur de sortie du tSystem dans la console.
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.

Composants
tFileInputRegex
tFileInputRegex
Propriétés de tFileInputRegex

Fonction Puissante fonctionnalité qui peut remplacer bon nombre des composants File.
Requiert des connaissances avancées en rédaction d’expressions régulières.
Objectif Ouvre un fichier et le lit ligne à ligne afin de le diviser en champs à l’aide
d’expressions régulières et d’envoyer les champs définis dans le Schéma, au
composant suivant, via un lien Row.
composant. Les champs suivants sont alors
File Name Nom du fichier à traiter. Voir également : Variables et
alias, page 87
Row separator Chaînes de caractères (ex: “\n”sous Unix) pour
distinguer les lignes.
Regex Ce champ est compatible Perl et peut contenir
plusieurs lignes. Intégrez à vos expressions
régulières le subpattern correspondant aux champs à
extraire.
Header Nombre de lignes à ignorer en début de fichier.
Footer Nombre de lignes à ignorer en fin de fichier.
Limit Nombre de ligne max.à traiter. Si Limit = 0, aucune
ligne n’est lue ni traitée.
Schema type and Edit Un schéma est une description de ligne, i.e. il définit
composant suivant. Le schéma est soit local (built-in)
soit distant (Repository).
43

Composants
tFileInputRegex

Utilisation Ce composant sert à lire un fichier et à en séparer les champs selon les Regex
définies.
Limitation n/a
Scénario: Transformation de fichier Regex en XML
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.
• Cliquez et déposez un composant tFileInputRegex et tFileOutputXML de la Palette dans

• Cliquez-droit sur le composant tFileInputRegex et sélectionnez Row > Main. Faites glisser
ce lien vers le composant tFileOutputXML et relachez lorsque le symbole approprié
apparaît.
• Sélectionnez tFileInputRegex à nouveau, et définissez les informations de l’onglet
Properties:
• 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.

Composants
tFileInputRegex
• 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.
• Saisissez le chemin d’accès au fichier de sortie

• Saisissez le standard d’encodage dans le champ Encoding. Notez que pour l’instant, la
vérification de l’homogénéité de l’encodage d’un job n’est pas supportée.
• Sélectionnez le type de schéma dans Schema type.Dans cet exemple, le schéma est built-in,
cliquez sur Sync columns pour récupérer en sortie le schéma d’entrée.
• Passez à l’onglet Run Job, et cliquez sur Run pour exécuter le job.
Le fichier d’entrée est lu ligne à ligne puis divisé en champs délimités selon la valeur de l’expression
régulière définie. Vous pouvez ouvrir le fichier de sortie avec tout éditeur XML standard.

Composants
tFileInputRegex

Composants
tDBInput
tDBInput
Propriétés de tDBInput
Famille du composant Database

Fonction tDBInput lit une base de données et en extrait des champs basés sur une requête.
Objectif tDBInput exécute une requête BDD dont l’ordre exact doit correspondre à la
définition de schéma. Puis la liste des champs est transmise au composant
suivant via un lien Row Main.
composant. Les champs suivants sont alors pré-remplis
à l’aide des données collectées.
DB driver SGBD tels que MySQL, MS SQL ou PostgreSQL
Host Addresse IP du serveur de BDD.
Port Port d’écoute du serveur BDD.
Database Nom de la base de donnée
Username and Données d’authentification BDD utilisateur
Password
Schema type and Edit Un schéma est une description de ligne, i.e. il définit le
Schema nombre de champs qui seront traités et passés au
soit distant (Repository).
43
Repository. Il peut être réutilisé dans divers projets et
job designs. Voir également : Paramétrage d’un
Query Saisissez votre requête de BDD en faisant attention à
ce que l’ordre des champs corresponde à celui défini
dans le schéma.
Utilisation Ce composant offre l’avantage de la flexibilité des requêtes de BDD et couvre
toutes les requêtes SQL possibles.

Composants
tDBInput
Scénario 1: Transformation de données de Bdd en XML
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.
• Cliquez et déposez un composant tDBInput et tLogRow de la Palette de composants dans

• Cliquez-droit sur un composant tDBInput et sélectionnez le lien Row > Main. Liez-le au
composant tLogRow.
• Sélectionnez le composant tDBInput à nouveau et dans l’onglet Properties, définissez les
paramètres du composant :
• 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.

Composants
tDBInput
• 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.
Scénario 2: Utilisation de StoreSQLQuery
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.

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

• La requête saisie dans le composant tDBInput affiche les résultats dans la console:

Composants
tMap
tMap
Propriétés de tMap

Fonction tMap un composant avancé qui s’intègre à Talend Open Studio
comme un plugin. Ce composant est un composant d’aiguillage et
de transformation et, pour cette raison, ne peut commencer ni
terminer un job.
Objectif tMap transforme et dirige les données à partir d’une ou de
plusieurs sources et vers une ou plusieurs destinations.
Propriétés Preview L’aperçu est un instantané des données du
Mapper. Il n’est visible que lorsque les propriétés
Mapper sont renseignées. La synchronisation de
l’aperçu ne prend effet qu’après la sauvegarde
des modifications.
Map editor Le Mapper ou tMap editor est un éditeur
graphique. Il vous permet de définir les propriétés
aiguillage et de transformation des données.
Utilisation Plusieurs utilisations sont possibles, de la simple réorganisation
des champs de données aux transformations les plus complexes,
telles que multiplexage et demultiplexage des données,
concaténation, inversion, filtrage etc...
Limitation L’utilisation du composant tMap requiert un niveau moyen de
connaissances Perl afin d’exploiter au mieux les fonctionnalités de
ce puissant composant.
Note: Pour plus d’informations, voir Mapping de données page 70.
Jeux de Scénarios
Les scénarios suivants sont des exemples d’utilisation du composant tMap.
Scénario 1 : Mapping simple

Le job décrit ci-dessous a pour objectif de lire des données d’un fichier csv stocké dans le
Repository, de rechercher des données d’un fichier de référence distant puis d’extraire des
données de ces deux fichiers en fonction de filtres et d’envoyer ces données vers le fichier de
sortie et de rejet.
• Cliquez sur File dans la Palette des composants, sélectionnez tFileInputCSV et
déposez-le dans l’espace de modélisation. Changez le libellé en Cars (véhicules), soit en
double-cliquant sur le libellé directement dans le workspace, soit via l’onglet View du
panneau Properties.

Composants
tMap
• Répétez cette opération et renommez ce second composant d’entrée en Owners

(propriétaires).
• Cliquez sur Processing dans la Palette de composants et cliquez-déposez le composant
tMap dans le workspace.
• Reliez les deux composants d’entrée, owners et cars au composant tMap et renommez
les libellés des connexions respectives.
• 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.

Composants
tMap
• 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.
• Définissez le lien en Inner Join en cochant la case correspondante.

• Cliquez sur le signe Plus dans la zone Output (sortie) du Mapper et ajoutez trois tables
de sortie: Insured, Reject_NoInsur, Reject_Inner.

Composants
tMap
• Glissez et déposez le contenu de la table principale d’entrée vers la première table de

sortie. Pour plus d’informations concernant le mapping de données, voir Mapping de
données page 70.
• Cliquez sur la flèche dotée d’un plus pour ajouter une ligne de filtre. La table Insured
rassemble les données des tables Cars et Owners qui intègrent un ID Insurance.

Composants
tMap
• 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.

Composants
tMap
• 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.

Composants
tMap
• Le fichier de sortie est créé, et les fichiers de rejet également le cas échéant.
Scénario 2 : Mapping avancé

Ce scénario, basé sur le scénario 1, requiert l’ajoût d’un fichier d’entrée, Resellers, contenant
les informations revendeurs ainsi que des champs supplémentaires dans le fichier de sortie
principal. Deux filtres sur des connexions internes, Inner Joins, permettent de récupérer les
rejets spécifiques.
• Cliquez sur File dans la Palette de composants et déposez un composant tFileInputCSV
sur le workspace.
• Connectez ce nouveau composant au mapper, et ajoutez un libellé à cette connexion:
Resellers.
• Double-cliquez sur le composant Resellers, pour en définir les propriétés d’entrée.

Composants
tMap
• Parcourez votre système de fichier jusqu’au Resellers.csv. Editez le schéma et ajoutez

les colonnes pour refléter la structure du fichier d’entrée.
• 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éé.

Composants
tMap
• 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.

Composants
tMap
• 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]
• Cliquez sur OK pour valider et fermer le Mapper.

• Cliquez-droit sur le composant tMap, cliquez sur Row et sélectionnez
Reject_ResellerID dans la liste.
• Connectez le flux principal du Mapper vers le composant de sortie Reseller

Composants
tMap
• 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.

Composants
tMap
• 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.

Composants
tMap
Scénario 3 : Mapping de join en cascade

Un troisième scénario plus avancé, basé sur le scénario 2, requiert l’ajoût d’une nouvelle entrée
contenant les informations d’assurance par exemple.
Mettez en place un lien Inner Join entre les deux tables de référence (Lookup) des flux
secondaires, Owners et Insurance dans le Mapper afin de gérer les références en cascade et par
conséquent de récupérer les informations de la table Insurance via les données de la table
Owners.

Composants
tRowGenerator
tRowGenerator
Propriétés de tRowGenerator
Famille du composant Misc

Fonction tRowGenerator génère autant de lignes et de champs que vous souhaitez
alimentés par des valeurs prises de façon aléatoire dans une liste définie.
Objectif Peut être utilisé à des fins de test, pour créer un flux d’entrée dans le
cadre de jeux de tests en cas limite.
Propriétés Schema type and Un schéma est une description de ligne, i.e. il
Edit Schema définit 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.
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 design. Voir également :
Paramétrage d’un schéma repository, page 43
Number of rows Paramétrez le nombre de lignes à générer. La
valeur est de type entier.
Values tRowGenerator affecte à chaque champ une
valeur prise aléatoirement dans une liste
paramétrée.
Columns: Champs repris du schéma défini (qu’il
soit de type Built-in ou Repository)
Perl array: réunit la plage de valeurs parmi
lesquels une valeur est reprise de façon aléatoire.
Ex: 'foo', 'bar' donnera pour résultat un mélange
aléatoire de 'foo' et de 'bar'.
1..10 permet de choisir de façon aléatoire un
chiffre entre 1 et 10. Pour plus d’infos sur les
formules concises, voir les fiches de ref rapides
Perl.
vérifier l’encodage, mais cette fonction devrait
être ajoutée à l’avenir.
Utilisation tRowGenerator peut prendre la place d’un composant start d’un job. Il
alimente le job avec un flux de données qui peut être de toute taille ou
de toute nature.
Limitation n/a

Composants
tRowGenerator
Scénario: Génération aléatoire de fichiers de test
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 et déposez un composant tRowGenerator et tLogRow sur le workspace.

• Cliquez droit sur le composant tRowGenerator et sélectionnez le lien Row > Main. Faites
glisser ce lien jusqu’au composant tLogRow.
• Double-cliquez sur le composant tRowGenerator pour afficher le panneau Properties.
• Pour ce scénario, le schéma est de type built-in. Mais vous pouvez également créer une
entrée de métadonnées dans le Repository et charger ainsi le schéma dans les propriétés de
schéma du composant tRowGenerator de votre job.
• Cliquez sur Edit Schema pour définir les champs à générer.
• 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.

Composants
tRowGenerator
• 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.

Composants
tAggregateRow
tAggregateRow
Propriétés de tAggregateRow

Fonction Reçoit un flux de données, et en fait l’aggrégation basée sur une ou
plusieurs colonnes. Pour chacune des lignes en sortie, une clé
d’aggrégation et le résultat de l’opération d’ensemble appropriée (min,
max, sum...) sont fournis.
Objectif Permet d’établir des métriques et des statistiques basées sur des valeurs
ou des calculs.
Propriétés Schema type et Edit Un schéma est une description de ligne, i.e. il
Schema définit le nombre de champs qui seront traités et
built-in, page 43
divers projets et job design. Voir également :
Group by Définit les ensembles d’aggrégation, dont les
valeurs sont utilisées pour les calculs.
Output Column: Sélectionnez le libellé de
colonne dans la liste fournie basée sur la structure
de schéma que vous avez définie. Vous pouvez
ajouter autant de colonnes de sortie que vous
souhaitez afin d’affiner les aggrégations.
Ex: Sélectionnez Pays, pour calculer la moyenne
des valeurs pour chaque pays ou sélectionnez
Pays et Région pour comparer les résultats des
régions d’un pays par rapport aux régions d’un
autre pays.
Input Column: Faites la correspondance entre le
libellé des colonnes d’entrée avec ceux des
colonnes de sortie, dans le cas où vous souhaitez
que les libellés du schéma de sortie soient
différents du schéma d’entrée.
Operations Sélectionnez le type d’opération à effectuer ainsi
que la valeur à utiliser pour le calcul et le champ
de sortie.
Output Column: Sélectionnez le champ de
destination dans la liste.

Composants
tAggregateRow
Function: Sélectionnez l’opérateur parmi :

count, min, max, avg
Input column: Sélectionnez la colonne d’entrée
à partir de laquelle les valeurs sont collectées
pour l’aggrégation.
Utilisation Ce composant est un composant intermédiaire car il traite un flux de
données, par conséquent il requiert des composants en entrée comme en
sortie. Généralement, l’utilisation du composant tAggregateRow est
combinée au composant tSortRow.
Limitation n/a
Scénario: Aggrégation de valeurs et tri des données
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.
• A partir de la Palette, cliquez et déposer un composant tFileInputCSV.

• Cliquez sur le libellé du composant et renommez-le en Countries. Ou passez dans l’onglet
View pour le changer.
• Dans l’onglet Properties, définissez le chemin d’accès ainsi que les critères de délimitation.
Ou sélectionnez l’entrée de métadonnée correspondant à votre fichier d’entrée, si vous en
avez défini une.
• Cliquez sur Edit schema... et paramétrez les colonnes : Countries et Points correspondant
à la structure du fichier. Si la description du fichier est conservée dans les Metadata du
Repository, le schéma est automatiquement chargé lorsque vous cliquez sur Repository
dans le champ Schema type.

Composants
tAggregateRow
• Puis dans le dossier Processing de la Palette, sélectionnez un composant tAggregateRow.

Renommez-le en Calculation.
• Cliquez-droit et connectez Countries à Calculation à l’aide d’un lien Row > Main.
• Double-cliquez sur Calculation (composant tAggregateRow) pour définir les propriétés.
Cliquez sur Edit schema et définissez le schéma de sortie. Vous pouvez ajouter autant de
colonnes que vous voulez selon le nombre d’opérations d’ensemble que vous souhaitez
obtenir en sortie.
• 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.

Composants
tAggregateRow
• Cliquez et déposez un composant tSortRow dans le workspace. Pour plus d’informations

sur ce composant, voir tSortRow, page 152
• Connectez-le au composant tAggregateRow à l’aide d’un lien Row>Main.
• Dans l’onglet Properties du composant tSortRow, Définissez la colonne de tri, le type ainsi
que l’ordre de tri.
• Dans ce scénario, la colonne à trier est Country, le type de tri est alphabétique et l’ordre est
ascendant.

Composants
tAggregateRow
• Ajoutez un composant de sortie à ce job. Cliquez et déposez un composant

tFileOutputDelimited et paramétrez-le.
• Connectez le composant tSortRow à ce composant de sortie.
• Dans la vue Properties, saisssez le chemin d’accès au fichier de sortie. Cliquez sur Edit
schema pour le configurer si nécessaire. Dans ce scénario, le fichier délimité est de type csv.
Cochez la case Include Header afin de réutiliser les libellés de colonnes du schéma dans le
flux de sortie.
• Appuyez sur F6 pour exécuter le job. Le fichier csv ainsi créé contient les résultats des
opérations d’aggrégation.

Composants
tSortRow
tSortRow
Propriétés de tSortRow

Fontion Trie les données d’entrée basées sur une ou plusieurs colonnes, selon un
type de tri et un ordre.
Objectif Permet d’établir des métriques et des tables de classification.
Cliquez sur Edit Schema pour modifier le
schéma. Notez que si vous modifiez le schéma
dans cette vue, le schéma devient
automatiquement ponctuel (built-in).
Cliquez sur Sync columns pour récupérer le
schéma à partir du composant précédent dans le
job.
built-in, page 43
divers projets et job designs. Voir également :
Criteria Cliquez sur + pour ajouter autant de lignes que
nécessaire pour mettre en place le tri. Par défaut,
la première colonne définie dans le schéma est
sélectionnée.
Schema column: Sélectionnez la colonne de
votre schéma sur laquelle vous souhaitez baser
votre tri. Notez que l’ordre est important car il
détermine la priorité de tri.
Sort type: Numérique ou Alphabetique. D’autres
types de tri sont à venir.
Order: Ordre ascendant ou descendant.
Utilisation Ce composant manipule le flux de données et par conséquent requiert un
composant en entrée et un composant en sortie. Il s’agit donc d’un
composant intermédiaire.
Limitation n/a

Composants
tSortRow
Scénario: Tri de données
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.
• Cliquez et déposez les trois composants requis pour ce scénario : tRowGenerator,

tSortRow et tLogRow.
• Connectez -les à l’aide de liens Row>Main.
• Dans l’onglet Properties du tRowGenerator, définissez les valeurs de création des entrées
aléatoires qui seront triées ensuite par le tSortRow. Pour plus d’informations concernant
l’utilisation du tRowGenerator, voir tRowGenerator page 144.
• 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.

Composants
tSortRow
• 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é.

Composants
tUniqRow
tUniqRow
Propriétés de tUniqRow

Fonction Compare les entrées et supprime la première duplication rencontrée dans
le flux d’entrée.
Objectif Assure la qualité des données en entrée ou en sortie d’un job.
job.
built-in, page 43
Case sensitive Cochez cette case pour prendre en compte la
casse (majuscule, minuscule).
Utilisation Ce composant manipule le flux de données et par conséquent requiert un
composant en entrée et un composant en sortie. Il s’agit donc d’un
composant intermédiaire.
Limitation n/a
Scénario: Dédoublonnage d’entrées
A partir du scénario tSortRow, ajoutez le composant tUniqRow afin de trier les entrées unifiées
dans le flux de sortie.

Composants
tUniqRow
• 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.

Composants
tFileInputXML
tFileInputXML
Propriétés de tFileInputXML

Fonction tFileInputDelimited lit un fichier structuré et en extrait les données ligne à
ligne.
Objectif Ouvre un fichier structuré XML et le lit ligne à ligne pour le scinder en
champs et envoie les champs tels que définis dans le Schéma au composant
suivant du job, via un lien Row.
Schema type et Edit Un schéma est une description de ligne, i.e. il définit
soit distant dans le Repository.
Cliquez sur Edit Schema pour modifier le schéma.
Notez que si vous modifiez le schéma dans cette vue,
le schéma devient automatiquement ponctuel
(built-in).
Cliquez sur Sync columns pour récupérer le schéma
à partir du composant précédent dans le job.
43
et job design. Voir également : Paramétrage d’un
File Name Nom du fichier à traiter.
Voir également :Variables et alias, page 87
Loop XPath query Noeud de l’arborescence sur lequel la boucle est
basée.
Mapping Column: Colonnes à mapper. Elles reflètent le
column/XPath Query schéma défini par le champ Schema type
XPath Query: Saisissez les champs à extraire de
l’entrée structurée.
Limit Nombre de ligne maximum à traiter. Si Limit = 0,
aucune ligne n’est lue ni traitée.

Composants
tFileInputXML

Limitation n/a
Scénario: Extraction d’adresses XML
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.
• Sélectionnez un composant tFileInputXML dans le dossier File de la Palette. Cliquez et

déposez également un composant tLogRow et connectez les deux composants à l’aide d’un
lien Row>Main.
• Dans la vue Properties du composant tFileInputXML, définissez les paramètres:

Composants
tFileInputXML
• 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.

Composants
tCatcher, tWarn & tDie
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.

Composants
Propriétés de tCatcher
Famille du composant Log/Error

Fonction Récupère les champs définis ainsi que les messages provenant d’un PerlDie,
tDie et/ou tWarn et transfère ces informations au composant suivant.
Objectif Fonctionne comme un outil de log qui est déclenché un PerlDie, tDie ou un
tWarn, pour collecter et transférer les données de log.
43
et job design. Voir également : Paramétrage d’un
schéma repository, page 43.
Catch PerlDie Cochez cette case pour déclencher la fonction tCatch
lorsqu’un PerlDie se produit dans le job.
Catch tDie Cochez cette case pour déclencher la fonction tCatch
lorsqu’un tDie est appelé dans un job.
Catch tWarn Cochez cette case pour déclencher la fonction tCatch
lorsqu’un tWarn est appelé dans un job.
Utilisation Ce composant est le composant start d’un job secondaire qui se déclenche
automatiquement à la fin d’un job principal.
Limitation n/a
Propriétés de tWarn

Fonction Fournit un message d’avertissement , avec niveau de priorité, au composant
suivant
Objectif Déclenche un avertissement généralement récupéré par le composant
tCatcher pour composer un fichier log exhaustif.
Warn message Saisissez un message d’avertissement
Priority Paramétrez le niveau de priorité sous la forme d’un
entier.
Utilisation Ne peut être utilisé comme composant start. Si un composant est connnecté en
sortie, un composant d’entrée doit nécessairement être connecté également.
Limitation n/a

Composants
Propriétés de tDie

Fonction Tue le job courant. Généralement utilisé aux côtés d’un tCatch afin de notifier
la fin anormale du job.
Objectif Déclenche le composant tCatcher pour composer un fichier de log exhaustif
avant de tuer le job..
Die message Saisissez le message à transmettre avant que le job ne
soit tué.
Error code Saisissez le code d’erreur si nécessaire, sous la forme
d’un entier
Priority Paramétrez le niveau de priorité sous la forme d’un
entier
Utilisation Ne peut pas être utilisé comme un composant start
Limitation n/a
Scénario1: warning & log sur un flux entrant
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.
• Cliquez et déposez un tRowGenerator, un tWarn, un tCatch et un tLogRow de la Palette

vers votre workspace
• Connectez les composants tRowGenerator et tWarn.
• Connectez séparément les composants tCatcher et tLogRow.
• Dans la vue Properties du composant tRowGenerator, paramétrez la création aléatoire
d’entrées à l’aide d’une fonction Perl basique:

Composants
• Dans la vue Properties du tWarn, saisissez votre message de notification et le niveau de

priorité. Pour ce scénario, le message dit simplement : “this is a warning”.
• Une fonction Perl concaténée au message ci-dessus permet de collecter la première valeur
de la table d’entrée.
• 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.
Exécutez lejob et remarquez que le fichier de log est complet.

Composants
Scénario 2: log & kill un job
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.

Composants
• Configurez le composant tFileOutputDelimited. La connexion Row partant du

tRowGenerator alimente automatiquement le schéma en sortie. Le séparateur est un simple
point-virgule.
• Connectez ce composant de sortie au tDie à l’aide d’un lien Trigger > If. Double-cliquez
sur la connexion nouvellement créée pour définir la condition:
$_globals{tRowGenerator_1}{NB_LINE} <= 0
• Puis double-cliquez sur le tDie pour configurer ses propriétés.
• 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.

Composants
• 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.

Composants
tDBOutput
tDBOutput
Propriétés de tDBOutput
Famille du composant Database

Fonction tDBOutput écrit, modifie ou supprime les entrées de base de données.
Objectif tDBOutput exécute l’action définie sur la table et/ou sur les données d’une
table.
Database driver SGBD disponibles incluent MySQL, MS SQL et
PostgreSQL.
Host Adresse IP du serveur de base de données
Port Numéro de port d’écoute du serveur BDD.
Database Nom de la base de données
Username et Données d’authentification d’utilisateur BDD.
Password
Table Nom de la table à écrire. Notez qu’une seule table
peut être écrite à la fois.
Action on table Vous pouvez effectuer les opérations suivantes sur la
table définie ;
None: Aucune opération sur la table
Drop and create the table: Supprime la table et la
crée à nouveau
Create a table: La table n’existe pas et doit être créée.
Clear a table: Le contenu de la table est supprimé
Action on data Vous pouvez effectuer les opérations suivantes sur les
données de la table sélectionnée :
Insert: Ajoute de nouvelles entrées de table. Si des
doublons sont détectés, le job s’arrête.
Update: Met à jour les entrées existantes
Insert or update: Ajoute des entrées ou met à jour les
entrées existantes.
Update or insert: Met à jour les entrées existantes ou
en crée si elles n’existent pas.
Delete: Supprime les entrées correspondantes au flux
d’entrée.

Composants
tDBOutput
43
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.
Scénario: Affichage d’une sortie DB
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.
• Cliquez et déposez les trois composants nécessaire pour ce job.

• Dans la vue Properties du composant tFileInputDelimited, définissez les paramètres du
flux d’entrée. Dans ce scénario, le fichier contient des identifiants de propriétaires de
véhicules, la marque, la couleur et les références d’immatriculation qui s’organisent comme
suit: un point-virgule comme séparateur de champ, un retour chariot comme séparateur de
ligne. Le fichier d’entrée contient une ligne d’en-tête à prendre en compte dans le schéma.
Si ce fichier est déjà décrit dans les métadonnées (Metadata) du Repository, vous pouvez
retrouver facilement ses propriétés en sélectionnant l’élément approprié dans la liste.

Composants
tDBOutput
• 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 :

Composants
tDBOutput
• 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.
• Etant donné que le traitement peut prendre un peu de temps, nous vous recommandons
d’activer la fonction Statistics dans la console Run Job.

Composants
tFileInputMail
tFileInputMail
Propriétés de tFileInputMail

Fonction Lit l’en-tête et le contenu d’un fichier email défini
Objectif Permet d’extraire les données clé standard des emails.
Propriétés File name Entrez le fichier email source
Schema type et Edit Un schéma est une description de ligne, i.e. il
job.
built-in, page 43
Mail parts Column: Ce champ est automatiquement
renseigné avec les colonnes définies dans le
schéma que vous avez propagé.
Mail part: Saisissez l’étiquette d’en-tête ou de
corps de message à afficher dans la sortie.
Utilisation Ce composant traite un flux de données et par conséquent requiert un
composant d’entrée et de sortie.
Limitation n/a
Scénario: Extraction des champs clé d’un email
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.

Composants
tFileInputMail
• Cliquez et déposez les composants tFileInputMail et tLogRow

• Dans la vue Properties, définissez les paramètres d’email :
• 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.

Composants
tFileInputMail
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.

Composants
tFileOutputLDIF
tFileOutputLDIF
Propriétés de tFileOutputLDIF

Fonction tFileOutputLDIF extrait des données vers un fichier LDIF qui peut ensuite
être chargé dans un annuaire LDAP.
Objectif tFileOutputLDIF écrit ou modifie un fichier LDIF avec des données
délimitées en entrées selon le schéma défini. Peut également supprimer le
contenu d’un fichier LDIF.
Propriétés File name Nom ou chemin d’accès au fichier de sortie. Voir
également: Variables and aliases, page 82
Wrap Place un retour à la ligne après le nombre de
caractères défini.
Change type Sélectionnez Add, Modify ou Delete pour
respectivement créer un nouveau fichier LDIF,
modifier ou supprimer un fichier LDIF. En cas de
modification, paramétrez le type de modification
apportée.
Change on attributes Sélectionnez Add, Modify ou Delete pour
respectivement ajouter un nouvel attribut au fichier,
remplacer les attributs existants ou supprimer les
attributs d’un fichier défini.
43
Sync columns Cliquez pour synchroniser le schéma du fichier de
sortie avec le schéma du fichier d’entrée. La fonction
Sync n’apparaît qu’une fois la connexion Row mise
en place entre les composants d’entrée et de sortie.
Utilisation Utilisez ce composant pour écrire un fichier XML à l’aide les données
provenant d’autres composants liés par connexion Row.

Composants
tFileOutputLDIF
Scénario: Ecriture de données dans un fichier LDIF
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.
• Cliquez et déposez les composants tDBInput et tFileOutputLDIF de la Palette vers

l’espace de modélisation. Connectez les deux composants à l’aide d’un lien Row > Main.
• Sélectionnez un composant tDBInput, et dans la vue Properties cliquez sur l’onglet
Properties.
• Si vous conservez les informations de connexion à votre base de données dans la zone
Metadata du référentiel, sélectionnez Repository dans le champ Property type. De même
sélectionnez le schéma de métadonnée correspondant si votre schéma est également stocké
dans le Repository. Tous les paramètres de connexion comme de schéma sont ainsi
récupérés.
• 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.

Composants
tFileOutputLDIF
• 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.
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.

Composants
tStatCatcher
tStatCatcher
Propriétés de tStatCatcher

Fonction Basé sur un schéma standard prédéfini, ce composant collecte les
métadonnées de traitement du job, au niveau de ce job mais également au
niveau de chacun des composants utilisés.
Objectif Fonctionne comme un outil de log déclenché par l’activation de l’option
StatsCatcher Statistics dans chacun des composants utilisés dans le job, puis
collecte et tranfère ces données de log standard vers la sortie spécifiée.
Schema type Un schéma est une description de ligne, i.e. il définit
le nombre de champs qui seront traités et passés au
composant suivant. Dans ce cas particulier, le
schéma est en lecture seule car l’information
collectée est standard et comprend :
Moment: Date et heure de traitement
Pid: Identifiant système du job
Job:Nom du job courant
Context: Nom du contexte actif
Origin:Nom du composant le cas échéant
Message: Begin (début) ou End (fin).
Utilisation Ce composant est le composant start d’un job secondaire qui se déclenche
automatiquement à la fin du job principal. Le temps de traitement est
également affiché à la fin du fichier de log.
Limitation n/a
Scénario: Affichage des informations de log d’un job
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.

Composants
tStatCatcher
• Cliquez et déposez les composants nécessaires : tRowGenerator, tFileOutputDelimited,

tStatCatcher et tLogRow
• Dans la vue Properties du composant tRowGenerator, configurez les données à générer de
façon aléatoire. Pour ce job, le schéma est composé de trois colonnes : ID_Owners,
Name_Customer et ID_Insurance, dont les données sont générées à l’aide d’un script Perl.
• Le nombre de lignes est restreinte à 100.

• Cliquez sur l’onglet Main de la vue Properties.
• Et cochez la case tStatCatcher Statistics pour activer l’opération de collecte d’informations

de log.

Composants
tStatCatcher
• 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.
• Définissez ensuite le composant tLogRow, notamment le séparateur à afficher dans la

console.
• Enfin, appuyez sur F6 pour exécuter le job et afficher les résultats de log.
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é.

Composants
tRunJob
tRunJob
Propriétés de RunJob
Famille du composant System

Fonction Exécute le job appelé dans les propriétés du composant, dans le contexte
spécifié.
Objectif tRunJob permet de contrôler les systèmes complexes notamment lors de
l’exécution de jobs successive.
Propriétés Process Sélectionnez le job à appeler et traiter.
Assurez-vous que le job appelé a déjà été exécuté
une fois afin de s’assurer que l’exécution via le
tRunJob s’effectue parfaitement.
Context Si vous avez défini des contextes et des variables
pour le job appelé, sélectionnez l’entrée
appropriée dans la liste.
Utilisation Ce composant peut être utilisé comme job autonome et permet de
simplifier la gestion de sous-job dans une implémentation complexe.
Limitation n/a
Scénario: Exécution d’un job distant
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.
Créez d’abord le job appelé.

• Cliquez et déposez les composants tFileInputDelimited et tLogRow dans l’espace de
modélisation.
• Paramétrez le composant d’entrée, dans la vue Properties.
• Le champ Property type est défini sur Built-In pour ce job.

Composants
tRunJob
• 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.

Composants
tRunJob
• 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.
• Dans le champ Context, sélectionnez le contexte approprié. Dans ce scénario, seul le

contexte Default est disponible, il contient la variable créée précédemment.
• Sauvegarder le master job puis appuyez sur F6 pour l’exécuter.

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

Composants
tRunJob

A
Activation .................................................................................................................................84
Appearance ..............................................................................................................................27
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
Copyright © 2007 Talend Open Studio i

F
File
tFileInputMail ..................................................................................................................171
tFileInputXML .................................................................................................................157
tFileOutputLDIF ..............................................................................................................174
File XML
Loop limit ..........................................................................................................................66
FilePositional ...........................................................................................................................55
Forme .......................................................................................................................................22
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
ii Talend Open Studio Copyright © 2007

Métadonnées ........................................................................................13, 46, 49, 56, 59, 61, 64
Schéma
FileDelimited 49
Schema FileLDIF ...............................................................................................................61
Schéma FilePositional ........................................................................................................55
Schema FileXML ...............................................................................................................63
Mode
Debug .................................................................................................................................92
Model
Affecter ..............................................................................................................................29
Commenter .........................................................................................................................25
Copier .................................................................................................................................30
Déplacer .............................................................................................................................30
Réarranger ..........................................................................................................................25
Sauvegarder .......................................................................................................................30
Supprimer ...........................................................................................................................30
Modeler ....................................................................................................................................21
Multiple Input/Output ..............................................................................................................39
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
Copyright © 2007 Talend Open Studio iii

Main ...................................................................................................................................30
Onglet .................................................................................................................................14
Vue .....................................................................................................................................14
Propriétés ...............................................................................................................14, 22, 26, 30
Comment ............................................................................................................................42
Properties ...........................................................................................................................42
Rulers & Grid .....................................................................................................................26
View ...................................................................................................................................40
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
iv Talend Open Studio Copyright © 2007

Run Before .........................................................................................................................39
Run if .................................................................................................................................39
Run if Error ........................................................................................................................39
Run if OK ...........................................................................................................................39
V
Variable ..................................................................................................................................180
StoreSQLQuery ...............................................................................................................129
Vue
Appearance ........................................................................................................................27
W
Workspace ...............................................................................................................................14
X
XMLFile ..................................................................................................................................63
Copyright © 2007 Talend Open Studio v

vi Talend Open Studio Copyright © 2007

Talend User Guid - FR

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Talend User Guid - FR

Uploaded by

Copyright:

Available Formats

Talend Open Studio

Convient pour l’utilisation de Talend Open Studio v1.1 et ultérieure.

ii Talend Open Studio Copyright © 2007

A propos de ce manuel... ....................................................................................1

Présentation de Talend Open Studio ................................................................3

Conception d’un Business Model ...................................................................19

Copyright © 2007 Talend Open Studio iii

Conception d’un Job Design ............................................................................31

iv Talend Open Studio Copyright © 2007

Copyright © 2007 Talend Open Studio v

vi Talend Open Studio Copyright © 2007

Copyright © 2007 Talend Open Studio vii

viii Talend Open Studio Copyright © 2007

Ce manuel s’adresse aux utilisateurs et administrateurs de Talend Open Studio.

Historique des versions

Le tableau ci-dessous liste les modifications apportées au Guide Utilisateur.

Version Date Historique

Copyright © 2007 Talend Open Studio 1

2 Talend Open Studio Copyright © 2007

Présentation de Talend Open Studio

Accès à Talend Open Studio

Copyright © 2007 Talend Open Studio 3

4 Talend Open Studio Copyright © 2007

Création d’un projet

Copyright © 2007 Talend Open Studio 5

Importation d’un projet

6 Talend Open Studio Copyright © 2007

Copyright © 2007 Talend Open Studio 7

Configuration de Talend Open Studio

8 Talend Open Studio Copyright © 2007

Copyright © 2007 Talend Open Studio 9

10 Talend Open Studio Copyright © 2007

Description de l’interface utilisateur

Talend Open Studio s’ouvre sur une fenêtre à zones multiples.

Talend Open Studio est composé des vues suivantes:

Copyright © 2007 Talend Open Studio 11

Le bouton de rafraîchissement vous permet de mettre à jour

Cliquez pour importer des projets créés avec des versions

Sauvegardez toutes vos données dans les divers dossiers

L’arborescence du Repository rassemble les éléments suivants :

12 Talend Open Studio Copyright © 2007

Copyright © 2007 Talend Open Studio 13

Vues Properties, Run Job et Logs

14 Talend Open Studio Copyright © 2007

Voir également: Vues Modules et Scheduler, page 15

Vues Modules et Scheduler

Copyright © 2007 Talend Open Studio 15

16 Talend Open Studio Copyright © 2007

Paramétrez l’heure et la date complète d’exécution de cette tâche.

Vues Outline et Code

Copyright © 2007 Talend Open Studio 17

La représentation graphique visible dans l’éditeur

18 Talend Open Studio Copyright © 2007

Conception d’un Business Model

Création ou ouverture d’un business model

Copyright © 2007 Talend Open Studio 19

Cliquez droit sur Business Models et sélectionnez l’option

Ouverture d’un business model

Double-cliquez sur le nom du business model que vous

Création d’un business model

Cliquez droit sur Business Models et sélectionnez Create

20 Talend Open Studio Copyright © 2007

Le Modeler est composé des vues suivantes :