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... ....................................................................................1Historique des versions .......................................................................................................1Remarques et Support .......................................................................................................1

Présentation de Talend Open Studio ................................................................3Accès à Talend Open Studio ..............................................................................................3Création d’un projet ...........................................................................................................5Importation d’un projet .....................................................................................................6Configuration de Talend Open Studio ..............................................................................8Description de l’interface utilisateur ...............................................................................11

Repository .....................................................................................................................11Business Models ...........................................................................................................12Job Designs ...................................................................................................................12Code ..............................................................................................................................12

Routines .....................................................................................................................12Snippets ......................................................................................................................13

Documentation .............................................................................................................13Metadata .......................................................................................................................13Recycle bin ...................................................................................................................13

Espace de modélisation .................................................................................................14Vues Properties, Run Job et Logs ..................................................................................14

Properties ......................................................................................................................15Logs ..............................................................................................................................15Run Job .........................................................................................................................15

Vues Modules et Scheduler ..............................................................................................15Modules ........................................................................................................................15Open Scheduler ............................................................................................................17

Vues Outline et Code .....................................................................................................17Outline ..........................................................................................................................18Code viewer ..................................................................................................................18

Conception d’un Business Model ...................................................................19Objectifs .............................................................................................................................19Création ou ouverture d’un business model ...................................................................19

Ouverture d’un business model ........................................................................................20Création d’un business model ..........................................................................................20

Modélisation d’un business model ...................................................................................21Cliquer & déposer des objets ...........................................................................................22Connexions .......................................................................................................................23

Copyright © 2007 Talend Open Studio iii

Commentaires et réarrangement d’un Business Model ....................................................25Ajoût d’une note ou de texte libre ................................................................................25Réarrangement d’une vue métier ..................................................................................25

Propriétés ..........................................................................................................................26Vue Rulers & Grid ........................................................................................................26Vue Appearance ...........................................................................................................27Vue Assignment ...........................................................................................................28

Affectation d’éléments à un Business Model ..................................................................29Modification d’un Business model ...................................................................................30

Renommer un business model ..........................................................................................30Copier et coller un business model ..................................................................................30Déplacer un business model .............................................................................................30Supprimer un business model ..........................................................................................30

Conception d’un Job Design ............................................................................31Objectifs .............................................................................................................................31Création ou Ouverture d’un job .....................................................................................31

Ouverture d’un job ...........................................................................................................32Création d’un job ..............................................................................................................32

Conception d’un Job Design ............................................................................................33Cliquer & Déposer des composants .................................................................................33Afficher/Cacher la palette ................................................................................................34Réorganiser les onglets d’un job ......................................................................................34Avertissements et erreurs sur un composant ....................................................................35

Connexion des composants ...............................................................................................36Types de connexion ..........................................................................................................36

Connexions de type Row ..............................................................................................36Main row ....................................................................................................................36Lookup row ................................................................................................................37Output row .................................................................................................................38

Connexion de type Iterate .............................................................................................38Connexions de type Trigger .........................................................................................39

Job à entrées/sorties multiples ..........................................................................................39Définition des propriétés d’un Job ..................................................................................39

Onglet Main ......................................................................................................................40Onglet View .....................................................................................................................40Onglet Documentation .....................................................................................................41Onglet Properties ..............................................................................................................42

Paramétrage d’un schéma built-in ................................................................................43Paramétrage d’un schéma repository ............................................................................43

Définition du composant Start .........................................................................................44Définition des schémas de métadonnées ..........................................................................45

Configurer une connexion DB .........................................................................................46Etape 1: propriétés générales ........................................................................................46Etape 2: Connexion ......................................................................................................47

iv Talend Open Studio Copyright © 2007

Etape 3: Chargement de la table ...................................................................................49Etape 4: Définition du schéma .....................................................................................49

Configurer un schéma File Delimited ..............................................................................49Etape 1: Propriétés générales ........................................................................................50Etape 2: Chargement du fichier ....................................................................................50Etape 3: Définition du schéma .....................................................................................51Etape 4: Schéma final ...................................................................................................54

Configurer un schéma File Positional ..............................................................................55Etape 1 : Propriétés générales .......................................................................................56Etape 2 : Connexion et chargement du fichier .............................................................56Etape 3 : Affinage du schéma .......................................................................................58Etape 4 : Schéma final ..................................................................................................58

Configurer un schéma File Regex ....................................................................................58Etape 1: Propriétés générales ........................................................................................59Etape 2 : Chargement du fichier ...................................................................................59Etape 3 : Définition du schéma ....................................................................................60Etape 4: Schéma final ...................................................................................................61

Configurer un schéma LDIF ............................................................................................61Etape 1 : Propriétés générales .......................................................................................62Etape 2 : Chargement du fichier ...................................................................................62Etape 3: Définition de schéma ......................................................................................62Etape 4: Schéma final ...................................................................................................63

Configurer un schéma File XML .....................................................................................63Etape 1 : Propriétés générales .......................................................................................64Etape 2 : Chargement du fichier ...................................................................................64Etape 3: Définition du schéma .....................................................................................64Etape 4 : Schéma final ..................................................................................................67

Création de requêtes à l’aide de SQLBuilder .................................................................67Comparaison des structures de base de données ..............................................................69Construction d’une requête ..............................................................................................69

Mapping de données .........................................................................................................70Présentation du fonctionnement tMap ..............................................................................71Mapper .............................................................................................................................72

Paramètres Input ..........................................................................................................74Renseigner les tables ..................................................................................................74Lier des tables input ...................................................................................................75Joins Inner ..................................................................................................................76Retirer des entrées de la table Input ...........................................................................77

Mapping de variables .................................................................................................77Accéder aux variables globales et contextuelles .......................................................79Supprimer des variables .............................................................................................79

Paramètres Output .......................................................................................................79Filtres .........................................................................................................................80Rejets .........................................................................................................................81Rejets Inner Join ........................................................................................................81

Copyright © 2007 Talend Open Studio v

Retirer des entrées de la table Output ........................................................................82Expression editor ..........................................................................................................82Schema Editor ..............................................................................................................82

Activation/Désactivation d’un job ou sous-job ...............................................................84Désactiver un composant Start .........................................................................................84Désactiver un composant non-Start ..................................................................................84

Définition d’un contexte et de variables de job ..............................................................85Ajouter ou renommer un contexte ....................................................................................85Définir les paramètres de contexte ...................................................................................86Variables et alias ............................................................................................................87

Création rapide de variables de contexte ......................................................................87Requêtes StoreSQL ......................................................................................................89

Exécuter un job dans un contexte défini ..........................................................................89Exécution d’un job ............................................................................................................90

Exécuter en mode normal .................................................................................................90Afficher les statistiques ................................................................................................90Afficher les traces .........................................................................................................91

Exécuter en mode debug .................................................................................................92Enregistrement ou Exportation de jobs ..........................................................................92

Enregistrement d’un Job ...................................................................................................92Exportation de job scripts .................................................................................................93

Raccourcis clavier .............................................................................................................93

Composants .......................................................................................................95 tMsgBox ............................................................................................................................96

Propriétés de tMsgBox .....................................................................................................96Scénario test de type ‘Hello World’ .................................................................................96

tFileInputDelimited ..........................................................................................................98Propriétés de tFileInputDelimited ....................................................................................98Scénario: Affichage du contenu d’un fichier délimité .....................................................99

tFileInputPositional .........................................................................................................101Propriétés de tFileInputPositional ..................................................................................101Scénario: Transformation d’un fichier positionnel en XML ..........................................102

tFileOutputXML .............................................................................................................106Propriétés de tFileOutputXML .......................................................................................106Scénario: Utilisation d’un format de sortie XML .........................................................107

tLogRow ...........................................................................................................................108Propriétés de tLogRow ...................................................................................................108Scénario: Affichage dans la console ..............................................................................108

tFileList ............................................................................................................................109Propriétés de tFileList ....................................................................................................109Scénario: Itération sur un répertoire ...............................................................................109

tFTP ..................................................................................................................................112Propriétés de tFTP ..........................................................................................................112tFTP put ..........................................................................................................................112

vi Talend Open Studio Copyright © 2007

tFTP get ..........................................................................................................................113tFTP rename ...................................................................................................................113tFTP delete .....................................................................................................................113Scénario: Charger des fichiers sur un serveur distant ....................................................113

tSendMail .........................................................................................................................115Propriétés de tSendMail .................................................................................................115Scénario: Envoi de notification d’erreur par email ........................................................115

tPerl ..................................................................................................................................118Propriétés de tPerl ..........................................................................................................118Scénario: Affichage du nombre de lignes traitées ..........................................................118

tSystem .............................................................................................................................121Propriétés de tSystem .....................................................................................................121Scénario: Affichage message dans sortie système .........................................................121

tFileInputRegex ...............................................................................................................123Propriétés de tFileInputRegex ........................................................................................123Scénario: Transformation de fichier Regex en XML .....................................................124

tDBInput ..........................................................................................................................127Propriétés de tDBInput ...................................................................................................127Scénario 1: Transformation de données de Bdd en XML ..............................................128Scénario 2: Utilisation de StoreSQLQuery ....................................................................129

tMap .................................................................................................................................131Propriétés de tMap .........................................................................................................131Jeux de Scénarios ...........................................................................................................131

Scénario 1 : Mapping simple ......................................................................................131Scénario 2 : Mapping avancé .....................................................................................137Scénario 3 : Mapping de join en cascade ...................................................................143

tRowGenerator ................................................................................................................144Propriétés de tRowGenerator .........................................................................................144Scénario: Génération aléatoire de fichiers de test ..........................................................145

tAggregateRow ................................................................................................................147Propriétés de tAggregateRow .........................................................................................147Scénario: Aggrégation de valeurs et tri des données .....................................................148

tSortRow ..........................................................................................................................152Propriétés de tSortRow ...................................................................................................152Scénario: Tri de données ................................................................................................153

tUniqRow .........................................................................................................................155Propriétés de tUniqRow .................................................................................................155Scénario: Dédoublonnage d’entrées ...............................................................................155

tFileInputXML ................................................................................................................157Propriétés de tFileInputXML .........................................................................................157Scénario: Extraction d’adresses XML ............................................................................158

tCatcher, tWarn & tDie ..................................................................................................160Propriétés de tCatcher ....................................................................................................161Propriétés de tWarn ........................................................................................................161Propriétés de tDie ...........................................................................................................162

Copyright © 2007 Talend Open Studio vii

Scénario1: warning & log sur un flux entrant ................................................................162Scénario 2: log & kill un job ..........................................................................................164

tDBOutput .......................................................................................................................167Propriétés de tDBOutput ................................................................................................167Scénario: Affichage d’une sortie DB ............................................................................168

tFileInputMail .................................................................................................................171Propriétés de tFileInputMail ...........................................................................................171Scénario: Extraction des champs clé d’un email ............................................................171

tFileOutputLDIF .............................................................................................................174Propriétés de tFileOutputLDIF .......................................................................................174Scénario: Ecriture de données dans un fichier LDIF .....................................................175

tStatCatcher .....................................................................................................................177Propriétés de tStatCatcher ..............................................................................................177Scénario: Affichage des informations de log d’un job ..................................................177

tRunJob ............................................................................................................................180Propriétés de RunJob ......................................................................................................180Scénario: Exécution d’un job distant .............................................................................180

viii Talend Open Studio Copyright © 2007

A propos de ce manuel...Historique des versions

A propos de ce manuel...

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.

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

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.

Copyright © 2007 Talend Open Studio 1

http://talendforge.org/forum

A propos de ce manuel...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.


Présentation de Talend Open StudioAccè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.


Présentation de Talend Open StudioCré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.


Présentation de Talend Open StudioImportation 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.

Importation d’un projet

Sur la fenêtre de connexion, cliquez sur Import projects pour lancer l’assistant d’importation.


Présentation de Talend Open StudioImportation d’un projet

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.


Présentation de Talend Open StudioConfiguration de Talend Open Studio

Sélectionnez le projet que vous souhaitez ouvrir, et cliquez OK pour lancer Talend Open Studio.

Configuration de 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.


Présentation de Talend Open StudioDescription de l’interface utilisateur

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.

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.

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



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/


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.


Conception d’un Business ModelCré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.


Conception d’un Business ModelModé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.

Modélisation d’un business model

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 :

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 :

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.



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:

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.

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 attachment

Permet d’ajouter des commentaires, des notes afin de conserver toute information utile concernant tout ou partie du processus.



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


Conception d’un Business ModelAffectation 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:

Pour plus d’informations concernant les éléments du Repository, voir également: Conception d’un Job Design, page 31

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.


Conception d’un Business ModelModification 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.


Conception d’un Job DesignCré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.


Conception d’un Job DesignConception d’un Job Design

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.

Conception d’un Job Design

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.

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.



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.


Conception d’un Job DesignConnexion des composants

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.


Conception d’un Job DesignDé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..

Définition des propriétés d’un Job

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.

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.

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


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.

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.


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.


Conception d’un Job DesignDé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.


Conception d’un Job DesignDé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

Définition des schémas de métadonnées

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.


Conception d’un Job DesignCré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é.

Création de requêtes à l’aide de SQLBuilder

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.


Conception d’un Job DesignMapping 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.



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



que la fonction d’aperçu de l’éditeur de mapping soit disponible dans le panneau Properties de l’espace de modélisation.

Double-cliquez sur l’icone tMap dans l’éditeur graphique ou cliquez sur le bouton en regard du champ Map editor dans l’onglet Properties. L’éditeur de mapping s’ouvre dans une nouvelle fenêtre.

Mapper

tMap est un composant dit avancé qui requiert plus d’informations de propriétés que les autres composant. Par conséquent le Mapper est l’outil le mieux adapté pour définir tous les paramètres nécessaires au mapping, à la transformation et l’aiguillage des données dans votre processus, par l’intermédiaire de son interface graphique conviviale.



Vous pouvez réduire et restaurer la fenêtre de toutes les tables contenues dans l’éditeur de mapping, à l’aide des boutons dans coin supérieur gauche de chacune des fenêtres.



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.



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.



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



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.



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:



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.

Comment faire pour... Actions associées

Insérer toutes les entrées sélectionnées comme variables séparées.

Faites simplement un glisser-déposer vers la table Var. 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 sélectionnées avec une entrée Var existante.

Glissez-déposez vers l’entrée Var à concaténer, elle se met alors en surbrillance. Toutes les entrées sont 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 Input sélectionnées, et les concaténer.

Glissez-déposez vers l’entrée Var appropriée qui se 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 sélectionnées, avec plusieurs entrées Var mises en surbrillance. Créer de nouvelles lignes en cas de besoin.

Glissez-déposez vers des Var existantes puis appuyez sur Maj. Les premières entrées sont concaténées avec les entrées Var en surbrillance, et si nécessaire, de nouvelles lignes sont créées pour contenir les entrées restantes.



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.

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.

Action Résultat

Glisser-déposer vers des expressions existantes

Concatène l’expression sélectionnée, vers des expressions existantes.

Glisser-déposer vers une ligne d’insertion

Insère une ou plusieurs nouvelle entrée en début ou en 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.



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.



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.



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.

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.

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.


Conception d’un Job DesignActivation/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.


Conception d’un Job DesignDé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.

Définition d’un contexte et de variables de job

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.



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.

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.



• 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


Conception d’un Job DesignExé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.

Exécution d’un job

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.


Conception d’un Job DesignExécution d’un job

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.


Conception d’un Job DesignEnregistrement 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.


Conception d’un Job DesignRaccourcis 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 :


Conception d’un Job DesignRaccourcis clavier

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.

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 Job si aucun job n’est ouvert.

Application globale F6

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 composants et les classes java associées

Application globale Ctrl + Maj + F3

Passez en mode Debug Dans la vue Run Job F7

Créer une variable de contexte à partir d’un champ Properties

Dans la vue Properties d’un job F5

Tuer le job courant Dans la vue Run Job F8

Rafraichir le statut d’installation des Modules Dans la vue Modules F5


—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


ComposantstMsgBox

tMsgBox

Propriétés de tMsgBox

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

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.


ComposantstMsgBox

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


ComposantstFileInputDelimited

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 Schema

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. 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 number of lines

Cochez cette case pour définir un nombre de lignes à extraire 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é.



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.



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


ComposantstFileInputPositional

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 Schema



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


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.


Utilisation Utilisez ce composant pour lire un fichier et séparer les champs à l’aide du séparateur spécifié.



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 l’espace de modélisation.

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



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



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


ComposantstFileOutputXML

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 name

Cochez cette case pour récupérer les libellés de 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.


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. Le schéma est soit local (built-in) soit distant dans le Repository (référentiel).



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.


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


ComposantstFileOutputXML

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.


ComposantstLogRow

tLogRow

Propriétés de tLogRow

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.

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


ComposantstFileList

tFileList

Propriétés de tFileList

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 :


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.


ComposantstFileList

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


ComposantstFileList

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


ComposantstFTP

tFTP

Propriétés de tFTP

tFTP put

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.

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 Password

Données d’authentification FTP de l’utilisateur

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.

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.


ComposantstFTP

tFTP get


tFTP rename


tFTP delete


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.

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.

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.

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.


ComposantstFTP

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


ComposantstSendMail

tSendMail

Propriétés de tSendMail

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

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.


ComposantstSendMail

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


ComposantstSendMail

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.


ComposantstPerl

tPerl

Propriétés de tPerl

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.

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.


ComposantstPerl

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


ComposantstPerl

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


ComposantstSystem

tSystem

Propriétés de tSystem

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:

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


ComposantstSystem

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


ComposantstFileInputRegex

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.




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.


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. Le schéma est soit local (built-in) soit distant (Repository).






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 l’espace de modélisation.

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


Utilisation Ce composant sert à lire un fichier et à en séparer les champs selon les Regex définies.

Limitation n/a



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


ComposantstDBInput

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.




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 Password

Données d’authentification BDD utilisateur


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. Le schéma est soit local (built-in) soit distant (Repository).




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.


ComposantstDBInput

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 l’espace de modélisation.

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


ComposantstDBInput

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


ComposantstDBInput

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


ComposantstMap

tMap

Propriétés de tMap

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.


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.


ComposantstMap

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


ComposantstMap

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


ComposantstMap

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


ComposantstMap

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


ComposantstMap

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


ComposantstMap

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


ComposantstMap

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


ComposantstMap

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


ComposantstMap

• 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


ComposantstMap

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


ComposantstMap

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


ComposantstMap

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.


ComposantstRowGenerator

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




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.


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



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.



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


ComposantstAggregateRow

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 Schema




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.



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.

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



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



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



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


ComposantstSortRow

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.


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. Le schéma est soit local (built-in) 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.



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


ComposantstSortRow

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.


ComposantstSortRow

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


ComposantstUniqRow

tUniqRow

Propriétés de tUniqRow

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.


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.





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


ComposantstUniqRow

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


ComposantstFileInputXML

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.








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/XPath Query

Column: Colonnes à mapper. Elles reflètent le 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.



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:


Limitation n/a



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


ComposantstCatcher, tWarn & tDie

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.



Propriétés de tCatcher

Propriétés de tWarn

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.




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.

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


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



Propriétés de tDie

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:


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



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



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.


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


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


ComposantstDBOutput

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 Password

Données d’authentification d’utilisateur BDD.

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.


ComposantstDBOutput

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.




Repository: Le schéma existe déjà et est stocké dans le Repository. Il peut être réutilisé dans divers projets et job designs. Voir également : Paramétrage d’un schéma repository, page 43.

Encoding Champ texte libre. L’encodage n’est pour l’instant pas vérifié, mais cette fonction devrait être ajoutée à l’avenir.

Utilisation Ce composant offre la flexibilité .des requêtes de base de données et couvre toutes les possibilités de requête SQL.


ComposantstDBOutput

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


ComposantstDBOutput

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


ComposantstFileInputMail

tFileInputMail

Propriétés de tFileInputMail

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.


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





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



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



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.


ComposantstFileOutputLDIF

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.





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.



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.



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


ComposantstStatCatcher

tStatCatcher

Propriétés de tStatCatcher

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.


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



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



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


ComposantstRunJob

tRunJob

Propriétés de RunJob

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.

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


ComposantstRunJob

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


ComposantstRunJob

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


ComposantstRunJob

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.


ComposantstRunJob


AActivation .................................................................................................................................84Appearance ..............................................................................................................................27

BBreakpoint ................................................................................................................................92Business Model ............................................................................................................12, 19, 20

Arranger .............................................................................................................................26Ouvrir .................................................................................................................................20

Business Modeler .....................................................................................................................21Business Models

Créer ...................................................................................................................................20

CCode .........................................................................................................................................12Code Viewer ............................................................................................................................17

Vue .....................................................................................................................................18Code viewer .............................................................................................................................18Component ...............................................................................................................................33Composant .........................................................................................................................33, 95

Activer ...............................................................................................................................40Start ....................................................................................................................................44

Connexion ................................................................................................................................36Iterate .................................................................................................................................38Lookup ...............................................................................................................................36Main ...................................................................................................................................36Output ................................................................................................................................36Row ....................................................................................................................................36

Contexte .....................................................................................................................86, 90, 180Configuration .....................................................................................................................86

Corbeille .............................................................................................................................14, 30

DDatabase

tDBOutput ........................................................................................................................167Debug mode .............................................................................................................................92Déclencheur .............................................................................................................................39Delimited .................................................................................................................................49Désactivation ...........................................................................................................................84Documentation .........................................................................................................................13

EEdit Schema .............................................................................................................................43Exécution d’un Job ..................................................................................................................14Expression régulière ................................................................................................................60

Copyright © 2007 Talend Open Studio i

FFile

tFileInputMail ..................................................................................................................171tFileInputXML .................................................................................................................157tFileOutputLDIF ..............................................................................................................174

File XMLLoop limit ..........................................................................................................................66

FilePositional ...........................................................................................................................55Forme .......................................................................................................................................22

GGeneration language ..................................................................................................................6Grid ..........................................................................................................................................26

IIterate .......................................................................................................................................38

JJob

Designer .............................................................................................................................33Exécuter .......................................................................................................................89, 90

Job Design ..........................................................................................................................31, 32Job design ................................................................................................................................12Job script

Exportation .........................................................................................................................92

LLDIFfile ...................................................................................................................................61Lien ..........................................................................................................................................23Log/error

tCatcher ............................................................................................................................160tDie ...................................................................................................................................160tStatCatcher ......................................................................................................................177tWarn ...............................................................................................................................160

LogsVue .....................................................................................................................................14

Lookup .....................................................................................................................................37

MMain .........................................................................................................................................30Metadata .............................................................................................................................13, 45

Db Connection ...................................................................................................................46File delimited .....................................................................................................................49File positional ....................................................................................................................56File regex ...............................................................................................................59, 61, 64

ii Talend Open Studio Copyright © 2007

Métadonnées ........................................................................................13, 46, 49, 56, 59, 61, 64Schéma

FileDelimited 49Schema FileLDIF ...............................................................................................................61Schéma FilePositional ........................................................................................................55Schema FileXML ...............................................................................................................63

ModeDebug .................................................................................................................................92

ModelAffecter ..............................................................................................................................29Commenter .........................................................................................................................25Copier .................................................................................................................................30Déplacer .............................................................................................................................30Réarranger ..........................................................................................................................25Sauvegarder .......................................................................................................................30Supprimer ...........................................................................................................................30

Modeler ....................................................................................................................................21Multiple Input/Output ..............................................................................................................39

OObjet .........................................................................................................................................22Onglet

Appearance ........................................................................................................................27Code Viewer ................................................................................................................17, 18Logs ...................................................................................................................................14Outline .........................................................................................................................17, 18Properties ...........................................................................................................................14Scheduler ...........................................................................................................................17

Outline ...............................................................................................................................17, 18View ...................................................................................................................................17Vue .....................................................................................................................................18

Output ......................................................................................................................................38

PPalette .....................................................................................................................14, 22, 25, 34

Note ....................................................................................................................................25Note attachment .................................................................................................................25Select ..................................................................................................................................25Zoom ..................................................................................................................................25

ProcessingtSortRow ..........................................................................................................................152tUniqRow .........................................................................................................................155

ProjetNom technique .....................................................................................................................6

Properties ...........................................................................................................................22, 26

Copyright © 2007 Talend Open Studio iii

Main ...................................................................................................................................30Onglet .................................................................................................................................14Vue .....................................................................................................................................14

Propriétés ...............................................................................................................14, 22, 26, 30Comment ............................................................................................................................42Properties ...........................................................................................................................42Rulers & Grid .....................................................................................................................26View ...................................................................................................................................40

RRecycle bin ........................................................................................................................14, 30Référentiel ........................................................................................................4, 5, 8, 11, 19, 31Refresh .......................................................................................................................................5Regular Expressions ................................................................................................................60Relationship .............................................................................................................................23Repository ........................................................................................................4, 5, 8, 11, 19, 31Requête

SQLBuilder ........................................................................................................................67Routine .....................................................................................................................................12Row ..........................................................................................................................................36

Main ...................................................................................................................................36Rulers .......................................................................................................................................26Run Job ........................................................................................................................14, 89, 90

SScheduler .................................................................................................................................17Schéma

Built-in ...............................................................................................................................44Schéma de métadonnées ..........................................................................................................45Shape ........................................................................................................................................22SQLBuilder ..............................................................................................................................67Start ..........................................................................................................................................44Statistics ...................................................................................................................................90StoreSQLQuery .....................................................................................................................129Sync columns ...........................................................................................................................43System

tRunJob ............................................................................................................................180

TTable d’Affectation ..................................................................................................................29Technical name ..........................................................................................................................6tMapper ....................................................................................................................................39Traces .......................................................................................................................................92Trigger

Run After ...........................................................................................................................39

iv Talend Open Studio Copyright © 2007

Run Before .........................................................................................................................39Run if .................................................................................................................................39Run if Error ........................................................................................................................39Run if OK ...........................................................................................................................39

VVariable ..................................................................................................................................180

StoreSQLQuery ...............................................................................................................129Vue

Appearance ........................................................................................................................27

WWorkspace ...............................................................................................................................14

XXMLFile ..................................................................................................................................63

Copyright © 2007 Talend Open Studio v

Talend user guid - Fr

Documents

Transcript of Talend user guid - Fr