Création d'un script de Job utilisant le tMap pour consolider une liste de noms à partir de fichiers CSV - 6.4

Talend Real-time Big Data Platform Studio Guide utilisateur

EnrichVersion
6.4
EnrichProdName
Talend Real-Time Big Data Platform
task
Création et développement
Qualité et préparation de données
EnrichPlatform
Studio Talend

Cet exemple vous explique comment écrire un script de Job pour définir un Job simple qui consolidera deux fichiers CSV en un seul à partir d'une colonne donnée. Ce Job contiendra les composants suivants :

  • deux composants tFileInputDelimited pour lire les fichiers CSV source, un composant contenant une liste de personnes et un autre composant noms de famille.

  • un composant tMap afin de consolider les données d'entrée pour obtenir une liste de noms à partir de la colonne id.

  • un composant tFileOutputDelimited pour écrire une liste consolidée dans un autre fichier CSV.

Le contenu des fichiers d'entrée sont utilisés dans les exemples présentés ci-dessous.

Contenu du fichier d'entrée principal list_people.csv :

id;name;age;city
1;James;75;Richmond
2;Bill;18;Austin
3;George;76;Topeka
4;Herbert;48;Raleigh
5;Woodrow;54;Annapolis
6;Ulysses;56;Frankfort
7;Ulysses;47;Bismarck
8;Woodrow;37;Montgomery
9;Theodore;44;Salem
10;Dwight;38;Little Rock
11;Herbert;26;Salt Lake City
12;Zachary;41;Harrisburg
13;Harry;31;Atlanta
14;Millard;34;Annapolis
15;Ronald;28;Jackson
16;Rutherford;18;Carson City
17;Richard;49;Salt Lake City
18;Woodrow;52;Providence
19;Millard;79;Raleigh
20;James;75;Sacramento

Contenu du fichier de référence list_families.csv :

id;family
1;Cleveland
2;Roosevelt
3;Carter
4;Jefferson
5;Hayes
6;van Buren
7;Kennedy
8;Adams
9;McKinley
10;Buchanan
11;Jefferson
12;Adams
13;Grant
14;Pierce
15;McKinley
16;Clinton
17;Roosevelt
18;Adams
19;Fillmore
20;Fillmore

Pour créer ce script de Job, vous devez suivre la procédure ci-dessous.

Créer un script de Job dans le Studio

Suivez les étapes suivantes pour créer un nouveau script de Job dans votre Studio Talend et définissez les propriétés nécessaires du Job.

  1. Dans l'arborescence Repository, développez le nœud Code, cliquez-droit sur script de Jobs et sélectionnez Create JobScript dans le menu contextuel pour ouvrir la boîte de dialogue [Create JobScript].

  2. Saisissez un nom pour votre script de Job dans le champ Name, consolidateList dans cet exemple. Vous pouvez laisser les autres champs configurés par défaut.

  3. Cliquez sur Finish pour fermer la boîte de dialogue et ouvrez une page de script de Job vide dans l'espace de modélisation graphique.

  4. Si nécessaire, renseignez les propriétés du Job, y compris :

    • le type de Job

    • le framework

    • le contexte par défaut

    • le type de contexte

    • le paramètres de contexte

    Étant donné que l'objectif de cet exemple est de créer un script de Job pour des Jobs standards sans aucune variable de contexte, ignorez cette étape et laissez le Studio compléter les propriétés avec les paramètres par défaut lors de la création de votre Job à partir de ce script de Job.

Configurer les composants d'entrée

Dans la majorité des cas, vous pouvez commencer à écrire un script de Job en ajoutant les composants nécessaires. Suivez les étapes ci-dessous afin d'ajouter et de configurer les composants.

  1. Dans la page du script de Job, saisissez une fonction addComponent {} pour commencer à ajouter un composant.

  2. Dans la fonction addComponent {}, saisissez la fonction setComponentDefinition {} et ses paramètres pour configurer le composant.

    Vous pouvez trouver ci-dessous les paramètres de base requis pour définir le type, le nom unique et la position du premier composant tFileInputDelimited dans cet exemple.

    addComponent {
    	setComponentDefinition {
    		TYPE: "tFileInputDelimited",
    		NAME: "tFileInputDelimited_1",
    		POSITION: 192, 256
    	}
    }
    
  3. À côté de la fonction setComponentDefinition {}, saisissez la fonction setSettings {} pour spécifier le chemin d'accès au fichier source, le nombre de lignes d'en-tête à ignorer et le libellé du composant affiché dans l'espace de modélisation graphique. Dans cet exemple :

    	setSettings {
    		FILENAME : "\"E:/Talend/Data/Input/list_people.csv\"",
    		HEADER : "1",
    		LABEL : "people"
    	}

    Avertissement

    Assurez-vous d'utiliser la barre oblique inversée (\) lorsque vous spécifiez un métacaractère.

  4. À côté de la fonction setSettings {}, saisissez une fonction addSchema {} et des paramètres de définition des colonnes pour définir le schéma du composant. Pour chaque colonne, vous avez uniquement besoin de spécifier le nom, le type et de laisser les propriétés des autres colonnes par défaut.

    Dans cet exemple, la principale source du fichier possède quatre colonnes, toutes de type String : id, name, age et city.

    	addSchema {
    		NAME: "tFileInputDelimited_1",
    		CONNECTOR: "FLOW"
    		addColumn {
    			NAME: "id",
    			TYPE: "id_String"
    		}
    		addColumn {
    			NAME: "name",
    			TYPE: "id_String"
    		}
    		addColumn {
    			NAME: "age",
    			TYPE: "id_String"
    		}
    		addColumn {
    			NAME: "city",
    			TYPE: "id_String"
    		}
    	}
  5. Suivez les étapes présentées ci-dessus pour ajouter un second composant tFileInputDelimited. Ce composant lira un fichier d'entrée de référence contenant uniquement deux colonnes, toutes les deux de type String : id et family.

    addComponent {
    	setComponentDefinition {
    		TYPE: "tFileInputDelimited",
    		NAME: "tFileInputDelimited_2",
    		POSITION: 192, 128
    	}
    	setSettings {
    		FILENAME : "\"E:/Talend/Data/Input/list_families.csv\"",
    		HEADER : "1",
    		LABEL : "families"
    	}
    	addSchema {
    		NAME: "tFileInputDelimited_2",
    		CONNECTOR: "FLOW"
    		addColumn {
    			NAME: "id",
    			TYPE: "id_String"
    		}
    		addColumn {
    			NAME: "family",
    			TYPE: "id_String"
    		}
    	}
    }

Définir le composant de traitement

Suivez les étapes ci-dessous pour définir un composant tMap afin qu'il :

  • effectue des conversions automatiques de types entre l'entrée et la sortie pour éviter les erreurs de compilation lors de l'exécution du Job

  • combine le prénom et le nom de chaque personne

  1. Saisissez les fonctions et les paramètres suivants pour ajouter le composant.

    addComponent {
    	setComponentDefinition {
    		TYPE: "tMap",
    		NAME: "tMap_1",
    		POSITION: 480, 256
    	}
    }
  2. À côté de la fonction setComponentDefinition {}, saisissez la fonction setSettings {} pour définir les paramètres de mapping. Dans cet exemple, activez la fonctionnalité de conversions automatiques de types du composant et laissez les autres paramètres par défaut.

    Dans cet exemple, le type de données des colonnes id et age est String dans les schémas d'entrée et le type de données est Integer dans le schéma de sortie.

    	setSettings {
    		ENABLE_AUTO_CONVERT_TYPE : "true"
    	}
  3. À côté de la fonction setSettings {}, saisissez une fonction addSchema {} pour définir la structure de données attendue par le composant suivant.

    Dans cet exemple, le flux de sortie est appelé out et contient quatre colonnes :

    • id, de type Integer, d'une longueur de deux caractères

    • full_name, de type String

    • age, de type Integer, d'une longueur de deux caractères

    • city, de type String

    		addSchema {
    		NAME: "out",
    		CONNECTOR: "FLOW",
    		LABEL: "out"
    		addColumn {
    			NAME: "id",
    			TYPE: "id_Integer",
    			LENGTH: 2
    		}
    		addColumn {
    			NAME: "full_name",
    			TYPE: "id_String"
    		}
    		addColumn {
    			NAME: "age",
    			TYPE: "id_Integer",
    			LENGTH: 2
    		}
    		addColumn {
    			NAME: "city",
    			TYPE: "id_String"
    		}
    	}
  4. À côté de la fonction addSchema {}, saisissez la fonction addMapperData {} pour définir le mapping des données, dont l'entrée, la sortie, les tables var, les jointures et les mappings.

  5. Dans la fonction addMapperData {}, saisissez une fonction addInputTable {} pour définir la table d'entrée du flux principal d'entrée. Notez que la définition des colonnes doit être la même que celle du premier composant tFileInputDelimited.

    	addMapperData {
    		addInputTable {
    			NAME: "row1"
    			addColumn {
    				NAME: "id",
    				TYPE: "id_String"
    			}
    			addColumn {
    				NAME: "name",
    				TYPE: "id_String"
    			}
    			addColumn {
    				NAME: "age",
    				TYPE: "id_String"
    			}
    			addColumn {
    				NAME: "city",
    				TYPE: "id_String"
    			}
    		}
    	}
  6. Dans la fonction addMapperData {}, saisissez une autre fonction addInputTable {} pour définir la table d'entrée pour le flux de référence. Notez que la définition des colonnes doit être la même que celle du second composant tFileInputDelimited.

  7. Dans la définition pour la colonne id, saisissez le paramètre EXPRESSION: "row1.id" pour définir une jointure sur les tables d'entrée dans la colonne id.

    Notez que cet exemple définit un Left Outer Join. Pour définir une jointure Inner Join, ajoutez le paramètre ISINNERJOIN: true dans la fonction addInputTable {}.

    		addInputTable {
    			NAME: "row2"
    			addColumn {
    				NAME: "id",
    				TYPE: "id_String"
    				EXPRESSION: "row1.id"
    			}
    			addColumn {
    				NAME: "family",
    				TYPE: "id_String"
    			}
    		}
  8. Dans la fonction addMapperData {}, saisissez une fonction addOutputTable {} et définissez uniquement la table de sortie dans cet exemple. Notez que cette définition de colonnes doit être la même que celle des paramètres du schéma.

    Notez que le paramètre ID est requis. Toutefois ce paramètre requiert une valeur uniquement lorsque la table de sortie utilise un schéma stocké dans le Repository.

  9. Créez des mappings entre les colonnes d'entrée et de sortie en ajoutant le paramètre EXPRESSION à chaque colonne de sortie.

    Notez que la colonne full_name est une combinaison de la colonne name du principal flux d'entrée et de la colonne family du flux de référence, séparées par un espace.

    		addOutputTable {
    			ID: "",
    			NAME: "out"
    			addColumn {
    				NAME: "id",
    				TYPE: "id_Integer",
    				EXPRESSION: "row1.id"
    			}
    			addColumn {
    				NAME: "full_name",
    				TYPE: "id_String",
    				EXPRESSION: "row1.name  + \" \" + row2.family"
    			}
    			addColumn {
    				NAME: "age",
    				TYPE: "id_Integer",
    				EXPRESSION: "row1.age"
    			}
    			addColumn {
    				NAME: "city",
    				TYPE: "id_String",
    				EXPRESSION: "row1.city "
    			}
    		}

    Avertissement

    Assurez-vous d'utiliser la barre oblique inversée (\) lorsque vous spécifiez un métacaractère.

Définir le composant de sortie

Suivez les étapes ci-dessous pour ajouter et définir le composant de sortie, dans cet exemple un tFileOutputDelimited.

  1. À côté de la définition du composant tMap, saisissez une autre fonction addComponent {} et à l'intérieur de cette fonction, saisissez la fonction setComponentDefinition {} et ses paramètres de base requis pour ajouter le composant de sortie.

    addComponent {
    	setComponentDefinition {
    		TYPE: "tFileOutputDelimited",
    		NAME: "tFileOutputDelimited_1",
    		POSITION: 736, 256
    	}
    }
  2. À côté de la fonction setComponentDefinition {}, saisissez la fonction setSettings {} et les paramètres requis pour définir les propriétés du composant :

    • le chemin d'accès au fichier de sortie

    • si l'en-tête doit être compris dans le fichier de sortie

    • le type de chiffrement du fichier de sortie

    • si un message d'erreur doit s'afficher et l'exécution du Job s'arrêter si le fichier de sortie spécifié existe déjà

    • le libellé du composant affiché dans le Job généré dans l'espace de modélisation graphique

    	setSettings {
    		FILENAME : "\"E:/Talend/data/output/consolidated_list.csv\"",
    		INCLUDEHEADER : "true",
    		ENCODING : "\"UTF-8\"",
    		ENCODING:ENCODING_TYPE : "UTF-8",
    		FILE_EXIST_EXCEPTION : "false",
    		LABEL : "consolidated_list"
    	}

    Avertissement

    Assurez-vous d'utiliser la barre oblique inversée (\) lorsque vous spécifiez un métacaractère.

  3. À côté de la fonction setSettings {}, saisissez une fonction addSchema {} pour définir le schéma du composant de sortie. Notez que la définition des colonne du schéma doit être la même que celle du schéma de sortie défini dans le composant précédant, le tMap.

    addSchema {
    		NAME: "tFileOutputDelimited_1",
    		CONNECTOR: "FLOW",
    		LABEL: "out"
    		addColumn {
    			NAME: "id",
    			TYPE: "id_Integer",
    			LENGTH: 2
    		}
    		addColumn {
    			NAME: "full_name",
    			TYPE: "id_String"
    		}
    		addColumn {
    			NAME: "age",
    			TYPE: "id_Integer",
    			LENGTH: 2
    		}
    		addColumn {
    			NAME: "city",
    			TYPE: "id_String"
    		}
    	}

Définir les connexions reliant les composants

Suivez les étapes ci-dessous pour ajouter et définir les connexions qui relient les composants dans le Job.

  1. À côté de la définition du composant de sortie, saisissez la fonction addConnection {} pour ajouter une connexion.

  2. Dans la fonction addConnection {}, saisissez les paramètres requis pour définir les propriétés de la connexion :

    • le type de connexion

    • le nom de la connexion

    • le style de la connexion

    • le composant source

    • le composant cible

    L'exemple ci-dessous définit une connexion Row > Main entre le premier composant tFileInputDelimited et le composant tMap.

    Avertissement

    Le nom de cette connexion doit correspondre au nom de la table d'entrée principale défini dans les paramètres du tMap.

    addConnection {
    	TYPE: "FLOW",
    	NAME: "row1",
    	LINESTYLE: 0,
    	SOURCE: "tFileInputDelimited_1",
    	TARGET: "tMap_1"
    }
  3. Saisissez une autre fonction addConnection {} et définissez une connexion Row > Look up entre la section du composant tFileInputDelimited et la section du composant tMap.

    Avertissement

    Le nom de cette connexion doit correspondre au nom de la table d'entrée de référence défini dans les paramètres du tMap.

    addConnection {
    	TYPE: "FLOW",
    	NAME: "row2",
    	LINESTYLE: 8,
    	SOURCE: "tFileInputDelimited_2",
    	TARGET: "tMap_1"
    }
  4. Saisissez une autre fonction addConnection {} et définissez la connexion Row > Main entre le composant tMap et le composant tFileoutputDelimited.

    Avertissement

    Le nom de cette connexion doit correspondre aux noms du schéma de sortie et de la table de sortie correspondants définis dans le composant tMap.

    addConnection {
    	TYPE: "FLOW",
    	NAME: "out",
    	LINESTYLE: 0,
    	SOURCE: "tMap_1",
    	TARGET: "tFileOutputDelimited_1"
    }

Générer et exécuter le Job

Vous avez maintenant défini tous les composants et toutes les connexions requis pour cet exemple, vous pouvez générer votre Job à partir du script de Job et l'exécuter dans votre Studio.

  1. Sauvegardez votre script de Job, puis cliquez-droit sur le script de Job dans l'arborescence Repository avant de sélectionner Generate Job dans le menu contextuel.

  2. Si nécessaire, double-cliquez sur le Job généré dans l'arborescence Repository et vérifiez la conception du Job dans l'onglet Designer.

  3. Appuyez sur F6 ou cliquez sur le bouton Run dans la console Run pour exécuter le Job.

    Si vous obtenez le résultat attendu, le fichier de sortie consolidated_list.csv devrait se présenter comme suit :

    id;full_name;age;city
    1;James Cleveland;75;Richmond
    2;Bill Roosevelt;18;Austin
    3;George Carter;76;Topeka
    4;Herbert Jefferson;48;Raleigh
    5;Woodrow Hayes;54;Annapolis
    6;Ulysses van Buren;56;Frankfort
    7;Ulysses Kennedy;47;Bismarck
    8;Woodrow Adams;37;Montgomery
    9;Theodore McKinley;44;Salem
    10;Dwight Buchanan;38;Little Rock
    11;Herbert Jefferson;26;Salt Lake City
    12;Zachary Adams;41;Harrisburg
    13;Harry Grant;31;Atlanta
    14;Millard Pierce;34;Annapolis
    15;Ronald McKinley;28;Jackson
    16;Rutherford Clinton;18;Carson City
    17;Richard Roosevelt;49;Salt Lake City
    18;Woodrow Adams;52;Providence
    19;Millard Fillmore;79;Raleigh
    20;James Fillmore;75;Sacramento