tStandardizeRow - 6.1

Composants Talend Guide de référence

EnrichVersion
6.1
EnrichProdName
Talend Big Data
Talend Big Data Platform
Talend Data Fabric
Talend Data Integration
Talend Data Management Platform
Talend Data Services Platform
Talend ESB
Talend MDM Platform
Talend Open Studio for Big Data
Talend Open Studio for Data Integration
Talend Open Studio for Data Quality
Talend Open Studio for ESB
Talend Open Studio for MDM
Talend Real-Time Big Data Platform
task
Création et développement
Gouvernance de données
Qualité et préparation de données
EnrichPlatform
Studio Talend

Avertissement

Ce composant est disponible dans la Palette du Studio Talend si vous avez souscrit à l'un des produits Talend Platform.

Fonction

Le composant tStandardizeRow segmente le flux de données reçu du composant précédent et applique des règles personnalisées pour analyser les données. En se fondant sur cette analyse, ce composant normalise et écrit les données analysées dans un flux de données séparé. Les balises XML utilisées sont celles définis par les noms des règles.

L'option de standardisation ajoute une colonne supplémentaire au flux de sortie dans laquelle les données sont standardisées après normalisation.

ANTLR est utilisé pour analyser et segmenter les données d'entrée. Pour plus d'informations, consultez le site http://www.antlr.org/ (en anglais).

Note

Ce composant ne modifie pas vos données brutes.

Objectif

Le tStandardizeRow normalise les données d'entrée dans un flux de données XML ou JSON distinct. Cela vous permet de séparer (et de standardiser si besoin) les données conformes à la règle des données non conformes.

Si vous avez souscrit à l'une des solutions Big Data de Talend, ce composant est disponible dans les types de Job suivants :

Types de règles

Les types de règles fournies sont divisées en deux groupes : les types de règles simples et les types de règles avancées.

  • Les types de règles simples sont : Enumeration, Format et Combination. Les règles de ce type se composent de certains symboles ANTLR donnés.

  • Les types de règles avancées sont : Regex, Index et Shape. Les règles de ce type correspondent aux données segmentées et standardisent ces données si nécessaire.

Les règles de type avancé sont toujours exécutées après les règles spécifiques ANTLR. Aucun compte n'est tenu de leur ordre.

Pour plus d'informations concernant les règles simples et avancées, consultez Différents types de règles pour différents niveaux de parsing et Scénario 4 : Utiliser deux niveaux de parsing pour extraire des informations de données non structurées.

Pour créer les règles de tout type, Talend fourni les éléments suivants prédéfinis et sensibles à la casse (éléments ANTLR) pour définir la composition d'une chaîne de caractères à mettre en correspondance :

  • INT : integer (nombre entier),

  • WORD : word,

  • WORD+ : groupe de plusieurs mots,

  • CAPWORD : mot en majuscules,

  • DECIMAL : float décimal,

  • FRACTION : float fraction,

  • CURRENCY : devises,

  • ROMAN_NUMERAL : chiffres romains,

  • ALPHANUM : nombres alphanumériques (combinaison de caractères alphabétiques et numériques)

  • WHITESPACE : espace blanc,

  • UNDEFINED : chaînes de caractères non attendues, comme les codes ASCII qui ne sont reconnus par aucun autre élément.

Les trois tableaux suivants présentent successivement les informations détaillées concernant les types de règles simples, les types de règles avancées et les symboles ANTLR utilisés par les types de règles simples. Ces trois tableaux vous aident à compléter le tableau Conversion rules dans l'onglet Basic settings de ce composant.

Pour les types de règles simples :

Type de règle simple

Utilisation

Exemple

Avertissement

Enumeration

Une règle de ce type fournit une liste de critères facultatifs.

RuleName : Gender RuleValue : " 'Male' | 'Female'"

- Chaque option doit être écrite entre guillemets doubles.

- Les options définies doivent être séparées par le symbole |.

- Le nom de la règle doit commencer par une majuscule.

Format

(Le nom de la règle commence par une majuscule)

Une règle de ce type définit la composition d'une chaîne de caractères en spécifiant le type de chaque élément de cette chaîne.

RuleName : ProductNumber RuleValue : " DIGIT DIGIT LETTER '-' DIGIT DIGIT " Cette règle correspond aux chaînes de caractères telles que 13A-74.

- Seuls les types d'éléments pré-définis (les segments ANTLR) sont acceptés pour définir les éléments de chaîne de caractères. Ils sont sensibles à la casse  : DIGIT, LETTER, CAPWORD, WORD, INT, ALPHANUM, DECIMAL, FRACTION, CURRENCY, ROMAN_NUMERAL.

Format (Le nom de la règle commence par une minuscule)

Une règle de ce type définit la composition d'une chaîne de caractères en spécifiant le type de chaque élément de cette chaîne.

En plus des types d'élément prédéfinis, une règle Enumeration est applicable pour définir le type d'un élément d'une chaîne de caractères.

RuleName : length RuleValue : "DECIMAL LengthUnit " Cette règle correspond aux chaînes telles que 1.4 cm, où DecimalFloat est un des types d'éléments pré-définis et LengthUnit est une règle Enumeration défnissant " 'inch' | 'cm' ".

 

Combination

Une règle de ce type définit la composition d'une chaîne de caractères en spécifiant le type de chaque élément de cette chaîne.

Celle-ci utilise une règle Enumeration ou Format ou les deux.

RuleNam e: Size (or size)

RuleValue : "length BY length" Cette règle correspond aux chaînes de caractère telles que 1.4 cm by 1.4 cm, où length est une règle Format (commençant par une minuscule) et BY est une règle Enumeration définissant " 'By' | 'by' | 'x' | 'X' ".

- Pour la règle Combination, le texte ou les caractères littéraux ne sont pas acceptés comme faisant partie de la valeur de la règle.

Au besoin, vous devez créer une règle Enumeration pour définir ces textes ou ces caractères et utiliser ensuite cette règle à la place de la première.

Avertissement

Tout caractère ou chaîne de caractères constant(e) (string literals), s'ils sont acceptés par un type de règle, doivent être placés entre guillemets simples. Autrement, ils seront traités comme des symboles grammaticaux ou des variables ANTLR et généreront des erreurs ou des résultats non souhaités lors de l'exécution.

Pour les types de règles avancées :

Type de règle avancée

Utilisation

Exemple

Avertissement

Regex

Une règle de ce type utilise des expressions régulières pour mettre en correspondance les données entrantes segmentées par ANTLR.

RuleName : ZipCode RuleValue : "\\d{5}" Cette règle correspond aux chaînes de caractères telles que "92150".

Les expressions régulières doivent être compatibles avec Java.

Index

Une règle de ce type utilise un index de synonymes comme référence pour rechercher les données entrantes mises en correspondance.

Pour plus d'informations concernant les index de synonymes disponibles, consultez l'annexe relative aux dictionnaires de synonymes de données, dans le Guide utilisateur du Studio Talend.

Pour plus d'informations concernant les index de synonymes disponibles, consultez l'annexe concernant les dictionnaires des synonymes de données dans le Guide utilisateur du Studio Talend.

Un scénario est disponible dans Scénario 2 : Standardiser des adresses provenant de données non structurées.

- Sous Windows, les barres obliques inverses "\" doivent être remplacées par des barres obliques "/" si le chemin d'accès est copié à partir du fichier système.

- Lorsque vous traitez un enregistrement, une règle Index met en correspondance la première chaîne de caractères identifiée comme correspondante.

- Dans un Job Talend Map/Reduce, vous devez compresser chaque index de synonymes à utiliser en fichier Zip. Si vous utilisez Talend Oozie scheduler pour exécuter ce Job, vous devez placer le fichier .zip dans la distribution où le Job est exécuté.

Shape

Une règle de ce type utilise des segments pré-définis ainsi que des règles établies Regex ou Index ou les deux pour faire correspondre les données entrantes.

RuleName : Address RuleValue : "<INT><WORD><StreetType>"

Cette règle correspond aux adresses telles que 12 main street, où StreetType est une règle Index que vous devez définir avec cette règle d'exemple dans la vue Basic settings de ce composant.

Pour plus d'informations concernant le type de règle Shape, consultez Scénario 2 : Standardiser des adresses provenant de données non structurées.

- Les segments pré-définis sont :

-INT pour un entier ; -WORD pour un mot ; -WORD+ pour les caractères littéraux de plusieurs mots ;

-CAPWORD pour les mots en majuscule ;

-DECIMAL pour les types de données Float décimales ;

-FRACTION pour les types de données Float de fraction,

-CURRENCY pour les monnaies, -ROMAIN_NUMERAL pour les chiffres/nombres romains,

-ALPHANUM pour les nombres alphabétiques,

- UNDEFINED pour les chaînes de caractères contenant des codes ASCII inattendus, qu'aucun autre segment ne peut reconnaître.

- Seul le contenu placé entre < > est reconnu. Autrement, le contenu est considéré comme une erreur ou est omis.

Pour les symboles ANTLR donnés :

Symboles

Signification

|

alternative

's'

caractère littéral ou chaîne de caractères constante (string literal)

+

1 ou plus

*

0 ou plus

?

facultatif ou prédicat sémantique

~

ne correspond pas

Les scénarios suivants présentent des exemples d'utilisation de ces symboles, mais vous pouvez également trouver d'autres exemples en consultant ce site :

https://theantlrguy.atlassian.net/wiki/display/ANTLR3/ANTLR+Cheat+Sheet.

Modes de recherche pour les règles d'Index

Un type de règle avancée utilisé par le composant tStandardizeRow est Index. Les règles Index utilisent des index de synonymes en tant que référence dans lesquelles chercher des correspondances de données.

Utiliser une règle Index sans avoir la possibilité de spécifier quel type de correspondance (exacte, partielle, floue, etc.) utiliser sur le flux d'entrée ne permet pas de standardiser et d'écrire en sortie les données attendues. Le tStandardizeRow vous permet de sélectionner l'un des modes de recherche suivants pour chaque règle Index définie dans le composant :

Mode de recherche

Description

Match all

chaque mot de la chaîne de caractères d'entrée doit exister dans la chaîne de caractères de l'index, mais la chaîne de l'index peut également d'autres mots.

Match all fuzzy

chaque mot de la chaîne de caractères d'entrée doit correspondre à des mots similaires de la chaîne de caractères dans l'index.

Match any

la chaîne de caractères d'entrée doit avoir au moins un mot correspondant à un des mots de la chaîne de caractères de l'index.

Match any fuzzy

la chaîne de caractères d'entrée doit avoir au moins un mot similaire à un mot de la chaîne de caractères de l'index.

Match exact

la chaîne de caractères exacte doit correspondre à la chaîne de caractères exacte de l'index.

Match partial

chaque mot de la chaîne de caractères d'entrée doit exister dans la chaîne de caractères de l'index, mais la chaîne de caractères d'entrée peut contenir d'autres mots, dans une certaine limite, 1 par défaut. Cela signifie qu'un mot de la chaîne de caractères d'entrée peut ne pas correspondre à un mot de la chaîne de caractères de l'index.

Par exemple, si vous avez cet enregistrement dans le flux d'entrée :

DULUX PAINTPOD EXTRA REACH HANDLE

Si vous avez créé un index par couleur contenant la chaîne de caractères Extra Deep Base.

Si vous définissez une règle Index dans le tStandardizeRow et que vous configurez le mode de recherche à Match any, le composant retourne Extra Deep Base comme couleur pour l'enregistrement ci-dessus, car le mot Extra correspond à la chaîne de caractères de l'index. Si vous souhaitez que le composant retourne uniquement une correspondance lorsque la chaîne de caractères exacte est trouvée dans l'index, vous pouvez configurer le mode de recherche à Match exact. Le composant ne retournera pas de couleur pour cet enregistrement.

Pour un exemple de Job, consultez le Scénario 3 : Extraire des correspondances exactes à l'aide des règles d'Index.

Différents types de règles pour différents niveaux de parsing

Le composant tStandardizeRow utilise des règles simples basées sur la grammaire ANTLR et des règles avancées définies par Talend, non basées sur ANTLR.

Parfois, l'utilisation de règles ANTLR ne répond pas à toutes vos attentes lors de normalisation et de standardisation de données. Par exemple, si vous souhaitez extraire la quantité de liquide dans les enregistrements suivants :

3M PROJECT LAMP 7 LUMENS 32ML
A 5 LUMINES 5 LOW VANILLA 5L 5LIGHT 5 L DULUX L
54MLP FAC 32 ML

Vous devez d'abord définir une unité pour les liquides et une quantité de liquides dans des règles d'analyse simples, comme suit :

Si vous testez ces règles dans la perspective Profiling du Studio Talend, vous pouvez constater que ces règles extraient 7 L de 7 LUMENS et que ce n'est pas ce que vous attendiez. Vous ne souhaitez pas que le mot LUMENS soit divisé en deux jetons.

Les règles simples définies précédemment sont des règles ANTLR d'analyse lexicale et sont utilisées pour diviser en jetons la chaîne de caractères d'entrée. ANTLR ne fournit pas de symbole de limite, comme le \b dans les expressions régulières. Vous devez donc être prudent lors du choix de vos règles d'analyse lexicale, car elles définissent comment sont divisées en jetons les chaînes d'entrée.

Vous pouvez résoudre ce problème en utilisant deux approches différentes :

La première approche est la définition d'une autre règle simple mettant en correspondance un mot et une valeur numérique, la règle Amount dans cet exemple :

La règle simple est une règle d'analyse syntaxique, une règle Format commençant par une majuscule. Si vous testez cette règle dans la perspective Profiling du Studio Talend, vous pouvez constater que les quantités non liquides sont mises en correspondance par cette règle. La règle LiquidAmount met en correspondance uniquement les séquences attendues de caractères.

La seconde approche consiste en une règle avancée telle une expression régulière et en la définition d'une limite de mot avec \b. Vous pouvez utiliser un analyseur lexical afin de diviser en jetons les quantités pour lesquelles vous mettez en correspondance tout mot avec une valeur numérique. Utilisez une expression régulière mettant en correspondance des quantités de liquide, comme suit : un chiffre facultativement suivi d'un espace puis de L ou de ML et terminé par une limite.

Notez que l'expression régulière va être appliquée sur les jetons créés par la règle d'analyse lexicale.

Vous ne pouvez vérifier les résultats de la règle avancée en testant la règle dans la perspective Profiling du Studio Talend comme vous le faites pour les règles simples. Cela signifie que le seul moyen de voir les résultats des règles avancées est de les utiliser dans un Job. Les résultats se présentent comme suit :

3M PROJECT LAMP 7 LUMENS 32ML
<record>
	<Amount>3M</Amount> 
	<Amount>7 LUMENS</Amount>
	<LiquidAmount>32ML</LiquidAmount> 
	<UNMATCHED> 
		<CAPWORD>PROJECT</CAPWORD> 
		<CAPWORD>LAMP</CAPWORD> 
	</UNMATCHED> 
</record>

Pour un exemple de Job concernant l'utilisation des règles ci-dessus, consultez Scénario 4 : Utiliser deux niveaux de parsing pour extraire des informations de données non structurées.

La première approche utilise uniquement la grammaire ANTLR et peut être plus efficace que la seconde, qui nécessite une seconde passe de parsing, afin de vérifier chaque jeton par rapport à l'expression régulière. Les expressions régulières permettent aux gens ayant une certaine connaissance de ces expressions de créer des règles plus avancées, qui ne pourraient pas vraiment être créées à l'aide d'ANTLR uniquement.

Propriétés du tStandardizeRow

Famille du composant

Data Quality

 

Basic settings

Schema et Edit schema

Un schéma est une description de lignes, il définit le nombre de champs (colonnes) qui sont 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 est créé et conservé ponctuellement pour ce composant seulement. Voir également le Guide utilisateur du Studio Talend.

 

 

Repository : Le schéma existe déjà et il est stocké dans le Repository. Ainsi, il peut être réutilisé. Voir également le Guide utilisateur du Studio Talend.

 

Column to parse

Sélectionnez la colonne à analyser à partir du flux de données reçu

 

Standardize this field

Cochez cette case pour standardiser les données identifiées comme conformes à la règle, c'est-à-dire remplacer les doublons de données identifiés par les données standardisées correspondantes à partir d'un index donné.

Pour plus d'informations concernant l'index de ces données standardisées, consultez tSynonymOutput.

Chaque fois que vous cochez ou décochez cette case, le schéma de ce composant est modifié automatiquement. De ce fait, dans un Job donné, vous devez cliquer sur le bouton Sync columns afin de régler les problèmes d'incohérence du schéma.

 

Generate parser code in Routines

Cliquez sur ce bouton pour permettre à l'analyseur de données de votre Studio Talend de générer le code des règles définies dans le tableau Conversion rules.

Dans un Job donné, lorsqu'une règle est créée, cette opération est nécessaire pour son exécution. En revanche, si une simple modification est effectuée sur la règle existante, cette opération est nécessaire uniquement lorsque la règle modifiée est de type Enumeration, Format ou Combination. Pour plus d'informations concernant les types de règles, consultez Types de règles.

 

et

Cliquez sur le bouton d'import ou d'export pour sélectionner une règle donnée de standardisation depuis le DQ Repository.

- Lorsque vous cliquez sur le bouton d'export, votre studio passe en perspective Profiling et la vue Parser rule Settings s'ouvre dans l'espace de travail avec son contenu automatiquement renseigné. Si nécessaire, vous pouvez modifier la règle exportée et la sauvegarder dans le dossier Libraries > Rules > Parser de la vue DQ Repository.

- Lorsque vous cliquez sur le bouton d'import, un assistant d'import s'ouvre et vous permet d'importer la règle de standardisation souhaitée.

Pour plus d'informations, consultez le Guide utilisateur du Studio Talend.

 

Conversion rules

Complétez ce tableau pour définir les règles que vous souhaitez appliquer. Les colonnes de la table à remplir sont :

- Name : dans cette colonne, saisissez le nom que vous souhaitez utiliser. Ce nom est utilisé comme nom balise pour les données de sortie en XML ou attribut JSON et comme nom de segment pour étiqueter les données d'entrée identifiées par cette règle.

- Type : dans cette colonne, sélectionnez le type de la règle que vous souhaiter appliquer.

Pour plus d'informations concernant les types de règles disponibles, consultez Types de règles.

- Value : dans cette colonne, saisissez la règle que vous souhaitez définir.

Une vue de test est fournie pour vous permettre de créer les analyseurs syntaxiques qui vous intéressent. Pour plus d'informations, consultez le Guide utilisateur du Studio Talend.

Advanced settings

Advanced options for INDEX rules

- Search UNDEFINED fields : cochez cette case si vous souhaitez que le composant recherche des enregistrements indéfinis dans les résultats de l'exécution de l'index.

- Word distance for partial match (disponible pour le mode Match partial) : définissez le nombre maximal de mots autorisés dans une séquence de mots pouvant être trouvée dans l'index. La valeur par défaut est 1.

- Max edits for fuzzy match (basé sur l'algorithme de Levenshtein et disponibles pour les modes Fuzzy) : sélectionnez une distance de modification, 1 ou 2, dans la liste. Tout terme au sein de la distance de modification depuis les données d'entrée est mis en correspondance. Avec une distance maximale de modification de 2, par exemple, vous pouvez effectuer 2 insertions, suppressions ou substitutions. Le score de chaque mise en correspondance se base sur la distance de modification de ce terme.

Les performances de la mise en correspondance floue sont nettement améliorées avec l'option Max edits for fuzzy match.

Note

Les Jobs migrés dans le Studio depuis d'anciennes versions s'exécutent correctement, mais les résultats peuvent être légèrement différents, car l'option Max edits for fuzzy match est utilisée à la place de l'option Minimum similarity for fuzzy match.

Output format

-XML : cette option est sélectionnée par défaut. Elle permet d'écrire en sortie les données normalisées au format XML.

-JSON : sélectionnez cette option pour écrire les données normalisées au format JSON.

-Pretty print : cette option est sélectionnée par défaut. Elle permet d'avoir une sortie sur plusieurs lignes. Si vous décochez cette case, la sortie se fait sur une ligne.

 

tStatCatcherStatistics

Cochez cette case pour collecter les métadonnées de process du Job, aussi bien au niveau du Job qu'au niveau de chaque composant.

Global Variables

ERROR_MESSAGE : message d'erreur généré par le composant lorsqu'une erreur survient. Cette variable est une variable After et retourne une chaîne de caractères. Cette variable fonctionne uniquement si la case Die on error est décochée, si le composant a cette option.

Une variable Flow fonctionne durant l'exécution d'un composant. Une variable After fonctionne après l'exécution d'un composant.

Pour renseigner un champ ou une expression à l'aide d'une variable, appuyez sur les touches Ctrl+Espace pour accéder à la liste des variables. A partir de cette liste, vous pouvez choisir la variable que vous souhaitez utiliser.

Pour plus d'informations concernant les variables, consultez le Guide utilisateur du Studio Talend.

Utilisation

Ce composant est un composant intermédiaire. Il requiert des composants d'entrée et de sortie.

Ce composant génère du code Java dans le nœud Routines du Repository. Ce code implémente la grammaire définie dans les règles. Il est compilé automatiquement pour être utilisé par le composant.

Lorsque vous modifiez/ajoutez/supprimez une règle, le code doit être généré à nouveau, afin que le Job puisse prendre en compte les modifications et s'exécuter.

Pour le générer, cliquez sur le bouton Generate parser code in Routines.

Connections

Liens de sortie (de ce composant à un autre) :

Row : Main; Reject

Trigger : Run if; On Component Ok; On Component Error.

Liens d'entrée (d'un autre composant à celui-ci) :

Row : Main; Reject

Pour plus d'informations concernant les connexions, consultez le Guide utilisateur du Studio Talend.

Scénario 1 : Normaliser les données à l'aide de règles de type simple

Dans ce scénario, deux étapes successives sont effectuées afin de :

  1. normaliser les données entrantes (séparer les données conformes des données non conformes) ;

  2. extraire les données souhaitées et les afficher.

Avant de reproduire ces étapes, vous devez analyser les données source afin de déterminer les règles à rédiger. Pour ce scénario, les données source sont stockées dans un fichier .csv appelé partsmaster.

Le fichier contient un total de 59 lignes de données brutes, mais certaines d'entre elles n'apparaissent pas sur la capture ci-dessus.

En observant les données, vous pouvez anticiper que la troisième ligne ne sera pas reconnue car elle contient des caractères asiatiques. De plus, vous pouvez déterminer que :

  • les données SKU contiennent 34-9923, pb710125, etc. De ce fait, la règle utilisée pour analyser les données SKU peut être :

    Nom

    Type

    Valeur

    "SKU"

    "Format"

    "(DIGIT DIGIT|LETTER LETTER'-'? DIGIT DIGIT DIGIT DIGIT (DIGIT DIGIT?)?"

  • pour les données Size, le format correct est la multiplication de deux ou trois longueurs (length) ajoutée aux unités de longueur (length unit). De ce fait, les règles utilisées pour les données Size peuvent être :

    Name

    Type

    Value

    "LengthUnit"

    "Enumeration"

    " 'm' | '\'' | 'inch' | 'inches' | '\"'"

    "BY"

    "Enumeration"

    "'X' | 'x' | 'by' "

    "Length"

    "Format"

    "(INT | FRACTION | DECIMAL) WHITESPACE* LengthUnit "

    "Size"

    "Combination"

    "Length BY Length BY Length"

    "Size"

    "Combination"

    "Length BY Length"

Puisque deux règles Combination utilisent le même nom, elles seront exécutées par ordre descendant comme présenté dans ce tableau.

  • pour les données Weight, le format correct est le poids (weight) ajouté à l'unité de poids (weight unit). De ce fait, les règles utilisées pour analyser les données  Weight peuvent être :

    Name

    Type

    Value

    "WeightUnit"

    "Enumeration"

    " 'lb' | 'lbs' | 'pounds' | 'Kg' | 'pinds'"

    "Weight"

    "Format"

    "(INT | FRACTION | DECIMAL) WHITESPACE* WeightUnit "

Vous pouvez à présent commencer à reproduire les deux étapes de ce scénario.

Séparer les données conformes des données non conformes

Pour cette première étape, quatre composants sont utilisés :

  • un tFileInputDelimited (partsmaster) : ce composant charge et passe les données source au composant suivant.

  • un tStandardizeRow : ce composant normalise les données entrantes et rejette les exceptions non reconnues.

  • un tLogRow : ce composant est utilisé à deux reprises pour afficher respectivement les exceptions et les données XML de sortie.

Pour reproduire cette étape, procédez comme indiqué dans les sections suivantes.

Déposer et relier les composants

Pour reproduire cette étape, procédez comme suit :

  1. Configurez votre schéma File Delimited pour le fichier partsmaster.csv dans la vue Repository de votre Studio Talend. Pour plus d'informations concernant cette procédure, consultez le Guide utilisateur du Studio Talend.

  2. Sous le nœud Metadata de la vue Repository de votre Studio Talend, sélectionnez le schéma File Delimited de partsmaster.csv et déposez-le dans l'espace de modélisation graphique.

  3. A partir de la boîte de dialogue qui apparaît, sélectionnez tFileInputDelimited.

    Le composant tFileInputDelimited (partsmaster) s'affiche dans l'espace de modélisation graphique.

  4. A partir de la Palette, déposez le composant tStandardizeRow ainsi que deux tLogRow dans l'espace de modélisation graphique.

  5. Cliquez-droit sur le tFileInputDelimited (partsmaster) pour afficher son menu contextuel.

  6. A partir de ce menu, sélectionnez un lien Row > Main pour connecter ce composant au tStandardizeRow.

  7. Acceptez la propagation du schéma dans la boîte de dialogue qui apparaît en cliquant sur Yes.

  8. A partir du tStandardizeRow, procédez de même pour connecter ce composant au premier tLogRow à l'aide d'un lien Row > Main et au second à l'aide d'un lien Row > Reject puis acceptez la propagation du schéma.

    Vous avez la possibilité de modifier le libellé de chaque composant, comme cela a été fait pour le composant tLogRow, renommé Exception pour ce scénario. Pour plus d'informations, consultez le Guide utilisateur du Studio Talend.

Configurer la normalisation des lignes

Pour ce faire, procédez comme suit :

  1. Cliquez sur le tStandardizeRow pour ouvrir l'onglet Basic settings de sa vue Component.

  2. Dans le champ Column to parse, sélectionnez SKU_Description_Size_Weight. C'est l'unique colonne que contient le schéma d'entrée.

  3. Sous le tableau Conversion rules, cliquez sur le bouton [+] à huit reprises pour ajouter huit lignes à ce tableau.

  4. Pour remplir ces lignes, saisissez les règles déterminées lors de l'analyse des données brutes effectuée au début de ce scénario.

    Les deux règles Size sont exécutées par ordre descendant puisqu'elles font partie du même type de règle. Dans ce scénario, l'ordre des règles permet au composant de mettre d'abord en correspondance la règle Size composée de trois nombres puis celles de deux nombres. Si vous inversez cet ordre, le composant met en correspondance les deux premiers nombres avec la première règle Size (Length BY Length) et traite ensuite le dernier nombre de la chaîne est ignoré car il ne correspondant pas.

  5. Cliquez sur le bouton Generate parser code in routines afin de générer le code d'analyse syntaxique dans des routines.

  6. Dans la vue Advanced settings, laissez les options par défaut dans la zone Output format.

    Le paramètre Max edits for fuzzy match est configuré à 1 par défaut.

Exécuter la normalisation du Job

Appuyez sur F6 pour exécuter ce Job.

Dans la console de la vue Run, vous pouvez observer la structure des données de sortie. Chaque instance de données XML est écrite dans une ligne séparée car la case Pretty print est cochée dans la vue Advanced settings du composant tStandardizeRow.

Un segment XML correspondant aux données brutes telles que 34-9923, Monolithic Membrance, 4' x 8', 26 lbs est généré là où les données conformes sont séparées des données non conformes (qui ne correspondent pas). Les données brutes sont donc normalisées.

Toujours à partir de cette console, vous pouvez observer qu'une ligne est rejetée car elle contient des données non reconnaissables.

Extraire les données souhaitées à partir des données XML normalisées

Cette section présente la deuxième étape de ce scénario. Quatre composants sont ajoutés pour recevoir les données XML normalisées à la place du composant tLogRow défini pour cette action lors de la première étape :

  • le tExtractXMLField : ce composant lit un champ d'entrée en XML et extrait les données souhaitées ;

  • le tFilterRow : ce composant filtre les lignes d'entrée en définissant des conditions sur les colonnes sélectionnées ;

  • le tLogRow (deux fois) : ces deux composants reçoivent et affichent respectivement les données valides ou invalides conformément aux conditions établies dans le tFilterRow.

Pour reproduire la deuxième étape, procédez comme dans les sections suivantes :

Déposer et relier les composants supplémentaires
  1. Dans l'espace de modélisation graphique, supprimez le composant tLogRow connecté au tStandardizeRow à l'aide d'un lien Row > Main.

  2. A partir de la Palette, déposez un tExtractXMLField, un tFilterRow ainsi que deux tLogRow dans l'espace de modélisation graphique. Pour ce scénario, les deux composants tLogRow sont nommés respectivement ValidSize et InvalidSize.

    Pour plus d'informations concernant le renommage d'un composant, consultez le Guide utilisateur du Studio Talend.

  3. Connectez le tExtractXMLField au tFilterRow à l'aide d'un lien Row > Main comme vous l'avez fait lors de la première étape pour connecter partsmaster au tStandardizeRow.

  4. Procédez de la même façon pour connecter le tFilterRow au ValidSize à l'aide d'un lien Row > Filter.

  5. Connectez le tFilterRow au composant InvalidSize à l'aide d'un lien Row > Reject comme vous l'avez fait lors de la première étape pour connecter le tSandardizeRow au composant Exception.

Configurer l'extraction des champs XML

Pour ce faire, procédez comme suit :

  1. Double-cliquez sur le tExtractXMLField pour ouvrir l'onglet Basic settings de sa vue Component.

  2. A côté de Edit schema, cliquez sur [...] pour ouvrir l'éditeur de schéma.

  3. A gauche de cet éditeur, sélectionnez la ligne SKU_Description_Size_Weight.

  4. Cliquez sur le bouton pour passer cette ligne à la droite de l'éditeur.

  5. A droite de cet éditeur, cliquez sur le bouton [+] à trois reprises pour ajouter trois lignes.

  6. Renommez les trois lignes ainsi : SKU, Size, Weight, chacune d'entre elles étant des balises des données XML normalisées.

  7. Cliquez sur OK pour valider cette configuration et acceptez la propagation du schéma demandée dans la boîte de dialogue qui apparaît. Observez que quatre lignes sont automatiquement remplies dans le tableau Mapping de la vue Component.

  8. Dans le champ XML field de la vue Component, sélectionnez le champ XML souhaité des données d'entrée. Pour ce scénario, il s'agit de Normalized_field.

  9. Dans le champ Loop XPath Query, saisissez le nom de la balise racine de l'arborescence XML pour remplacer sa valeur par défaut. Pour ce scénario, saisissez "/record".

  10. Dans la colonne XPath query du tableau Mapping, saisissez entre guillemets doubles les balises de l'arborescence XML correspondant aux données normalisées souhaitées. Pour ce scénario, il s'agit de "SKU", "Size", et "Weight".

Configurer le filtrage des lignes

Pour ce faire, procédez comme suit :

  1. Double-cliquez sur le tFilterRow pour ouvrir l'onglet Basic settings de sa vue Component.

  2. Sous le tableau Conditions, cliquez sur le bouton [+] pour ajouter une ligne.

  3. Dans la colonne InputColumn de cette ligne, sélectionnez Size à partir de la liste déroulante.

  4. Dans la colonne Function, sélectionnez Empty.

  5. Dans la colonne Operator, sélectionnez Not equal to.

  6. Dans la colonne Value, saisissez des guillemets doubles "".

    La condition est définie. Les données normalisées qui ne contiennent pas de valeurs nulles dans la balise Size seront passées au composant de sortie tandis que celles qui contiennent des valeurs nulles dans la balise Size seront rejetées.

Exécuter le Job
  • Appuyez sur F6 pour exécuter ce Job.

    Dans la console de la vue Run, vous pouvez observez les données souhaitées sélectionnées à partir du flux de données XML normalisées.

    Ce Job liste les données normalisées souhaitées en parallèle avec les données brutes.

    Vous pouvez également observer les données rejetées par le composant tFilterRow.

    Note

    Pour des raisons d'espace, tous les résultats ne sont pas affichés.

Scénario 2 : Standardiser des adresses provenant de données non structurées

Dans ce scénario, six composants sont utilisés pour standardiser des adresses provenant de données d'entrée non structurées copiées d'un site Web en les rapprochant des données contenues dans un index, précédemment généré par un Job.

Pour plus d'informations concernant la création d'index, consultez tSynonymOutput.

Glissez-déposez de la Palette dans l'espace de modélisation graphique les composants suivants :

  • un tFixedFlowInput : ce composant contient les données non structurées desquelles extraire les adresses.

  • un tStandardizeRow : ce composant définit les règles de l'adresse et génère les adresses au format XML avec les balises définies.

  • un tFilterColumns : ce composant filtre l'adresse standardisée.

  • un tExtractXMLField : ce composant extrait les attributs du nœud Address de l'arborescence XML pour renvoyer en sortie chaque composante de l'adresse dans une colonne typée.

  • deux tLogRow : ces composants servent à afficher les données en sortie. Le premier tLogRow retourne les erreurs s'il y en a. Le second tLogRow affiche le résultat dans la console.

Avant de reproduire ce scénario, vous devez avoir récupéré le contenu d'un index afin de mettre en correspondance les données non structurées avec les données de l'index. Cet index se présente comme suit :

Les noms des rues de Paris s'affichent à gauche et leurs synonymes utilisés dans les données s'affichent à droite. Les données seront utilisées comme références pour standardiser les adresses collectées depuis le site Web, par exemple http://paris.conciergerie.com/travel_paris/address.php.

Pour reproduire ce scénario, procédez comme dans les sections suivantes.

Préparer les données non structurées

  1. Double-cliquez sur le composant tFixedFlowInput pour afficher sa vue Basic settings.

  2. Cliquez sur le bouton [...] pour ouvrir la boîte de dialogue [Schema]. Cliquez sur le bouton [+] pour ajouter une colonne et nommez-la input. Cliquez sur OK pour valider et fermer l'éditeur.

  3. Dans la zone Mode, sélectionnez Use Inline Content (delimited file).

  4. Dans le champ Content, collez les données copiées du site Web. Ces données ne sont pas structurées.

Vous pouvez continuer à configurer le processus de standardisation.

Configurer la standardisation des données non structurées

Pour ce faire, procédez comme suit :

  1. Reliez le tFixedFlowInput au tStandardizeRow à l'aide d'un lien Row > Main.

  2. Dans l'espace de modélisation graphique, double-cliquez sur le composant tStandardizeRow pour afficher sa vue Basic settings.

    Les règles de type avancé sont toujours exécutées après les règles spécifiques ANTLR. Aucun compte n'est tenu de leur ordre.

  3. Dans la liste Column to parse, sélectionnez input.

  4. Cochez la case Standardize this field.

  5. Dans le tableau Conversion rules, cliquez six fois sur le bouton [+] afin d'ajouter six colonnes.

    Pour la règle "StreetName", sélectionnez le type Index dans la colonne Type et saisissez le chemin d'accès à votre index dans la colonne Value.

    • Sélectionnez le type Index dans la liste Type.

    • Saisissez le chemin d'accès à votre index dans le champ Value.

    • Sélectionnez Match exact comme mode de recherche dans la liste Search mode.

      En utilisant le mode Match exact, vous extrayez du flux d'entrée uniquement les chaînes de caractères correspondant exactement aux index des noms de rues.

      Pour plus d'informations concernant les modes de recherche disponibles, consultez Modes de recherche pour les règles d'Index.

    Les autres règles sont :

    Nom

    Type

    Valeur

    "Zip"

    Format

    " DIGIT DIGIT DIGIT DIGIT DIGIT "

    "City" Enumeration

    " 'Paris' | 'Paris' | 'PARIS' | 'Bagnolet' "

    "SpecialStreetNumber" Format

    " (INT ('bis'|'ter')) | ( INT '-' INT) "

    "INT" Shape

    "<SpecialStreetNumber>"

    "Address" Shape

    " <INT> <StreetName> <Zip> <City> "

    Ces règles étant de type avancé, elles sont toujours exécutées après les règles spécifiques ANTLR. Les règles simples "Zip", "City" et "SpecialStreetNumber" sont exécutées en premier, suivies des règles avancées, "INT" et "Address".

  6. Cliquez sur le bouton Generate parser code in Routines afin de générer le code dans les Routines.

    Avertissement

    Si vous ne cliquez pas sur ce bouton, le Job ne pourra pas s'exécuter.

  7. Dans la vue Advanced settings, laissez les options par défaut dans la zone Output format.

    Le paramètre Max edits for fuzzy match est configuré à 1 par défaut.

  8. Dans l'espace de modélisation graphique, cliquez-droit sur le tStandardizeRow afin de le relier au tLogRow du dessous, à l'aide d'un lien Row > Reject.

  9. Double-cliquez sur le tLogRow lié au tStandardizeRow afin d'afficher sa vue Basic settings.

  10. Dans la zone Mode, sélectionnez l'option Table (print values in cells of a table).

Configurez le filtrage et l'extraction des données qui vous intéressent.

Configurer le filtrage et l'extraction des données

Pour ce faire, procédez comme suit :

  1. Dans l'espace de modélisation graphique, reliez le tStandardizeRow au tFilterColumns à l'aide d'un lien Row > Main.

  2. Dans la vue Basic settings du tFilterColumns, cliquez sur le bouton [...] à côté du champ Edit schema pour ouvrir l'éditeur du schéma.

  3. Dans cet éditeur, cliquez sur la colonne STANDARDIZED_FIELD, puis cliquez sur la première flèche, afin de filtrer cette colonne. Cliquez sur OK pour fermer l'éditeur et valider les modifications.

  4. Dans l'espace de modélisation graphique, reliez le tFilterColumns au tExtractXMLField à l'aide d'un lien Row > Main.

  5. Double-cliquez sur le tExtractXMLField afin d'afficher sa vue Basic settings.

  6. Cliquez sur le bouton [...] à côté du champ Edit schema afin d'ouvrir l'éditeur du schéma. Ajoutez quatre colonnes et nommez-les respectivement number, street, zip et city, puis cliquez sur OK pour valider et fermer l'éditeur.

  7. Dans le champ XML field, vérifiez que la colonne STANDARDIZED_FIELD est bien sélectionnée.

    Le contenu de la colonne STANDARDIZED_FIELD est un champ XML ayant pour racine la balise <record>. Sous cette balise, la structure définie par les normes des règles configurées dans le composant tStandardizeRow permet d'extraire chaque composante de l'adresse tel que vous pouvez le voir dans l'exemple ci-dessous.

  8. Dans le champ Loop XPath query, saisissez "/record/Address".

  9. Dans le tableau Mapping, dans le champ XPath query, saisissez "INT" pour la colonne number, "StreetName" pour la colonne street, "Zip" pour la colonne zip et "City" pour la colonne city.

Vous pouvez maintenant exécuter votre Job.

Exécuter le Job

Avant d'exécuter le Job, vous devez ajouter un composant tLogRow, afin d'afficher les résultats d'exécution.

Pour ce faire, effectuez les opérations suivantes :

  1. Dans l'espace de modélisation, reliez le tExtractXMLField au second tLogRow à l'aide d'un lien Row > Main.

  2. Double-cliquez sur ce tLogRow afin d'ouvrir sa vue Basic settings.

  3. Dans la liste Schema, sélectionnez Built-In.

  4. Cliquez sur le bouton [...] à côté du champ Edit schema et vérifiez que les schémas en entrée et en sortie dans le tLogRow sont synchronisés.

    S'ils ne le sont pas, cliquez sur le bouton Sync columns.

  5. Dans la zone Mode, sélectionnez l'option Table (print values in cells of a table).

Appuyez sur F6 pour exécuter ce Job.

Le second tLogRow affiche dans la console les adresses normalisées et standardisées par rapport à l'index.

Par exemple, vous pouvez constater que l'adresse des Champs Elysées a été corrigée et formatée et seuls les noms de rues correspondant exactement à une chaîne de caractères de l'index sont extraits.

Le premier tLogRow ne retourne rien dans ce scénario, car aucune erreur n'est générée.

Scénario 3 : Extraire des correspondances exactes à l'aide des règles d'Index

Dans ce scénario, vous allez standardiser des descriptions longues de produits clients en mettant en correspondance le flux d'entrée et les données contenues dans un index. Ce scénario vous explique comment utiliser les règles d'Index afin de mettre en jetons les données produit puis de vérifier chaque jeton par rapport à un index, afin d'extraire les correspondances exactes.

Pour ce scénario, vous devez d'abord créer un index en utilisant un Job contenant un composant tSynonymOutput. Vous devez créer des index pour la marque, la finition, la couleur et l'unité de mesure des produits clients. Utilisez le composant tSynonymOutput afin de générer les index et de les alimenter par des entrées et des synonymes. La capture d'écran suivante illustre le Job :

Ci-dessous se trouve un exemple d'index générés pour ce scénario :

Chaque index généré a des chaînes de caractères (séquences de mots) dans une colonne et leurs synonymes correspondants dans une autre colonne. Ces chaînes de caractères sont utilisées en tant que données de référence par rapport auxquelles les données produits, générées par le tFixedFlowInput, vont être mises en correspondance. Pour plus d'informations concernant la création d'index, consultez tSynonymOutput.

Dans ce scénario, les index générés sont définis comme variables de contexte. Pour plus d'informations concernant les variables de contexte, consultez le Guide utilisateur du Studio Talend.

Construire le Job

  1. Déposez les composants suivants de la Palette dans l'espace de modélisation graphique : un tFixedFlowInput, un tStandardizeRow, un tExtractXMLField et un tFileOutputExcel.

  2. Reliez les composants à l'aide de liens Row > Main.

  3. Déposez un tLogRow dans le Job et reliez le tStandardizeRow au tLogRow à l'aide d'un lien Reject.

Générer des données non structurées

  1. Double-cliquez sur le tFixedFlowInput pour afficher sa vue Basic settings.

    Ce composant va générer les données produits non structurées desquelles la marque, la finition, la couleur et l'unité de mesure sont extraites.

  2. Cliquez sur le bouton [...] pour ouvrir la boîte de dialogue [Schema].

  3. Cliquez deux fois sur le bouton [+] pour ajouter deux colonnes, nommez-les Long_Description et Supplier_Product_Code. Cliquez sur OK pour fermer la boîte de dialogue.

  4. Dans la zone Mode, sélectionnez Use Inline Content (delimited file).

  5. Dans le champ Content, saisissez les données produits non structurées que vous souhaitez standardiser, par exemple comme suit :

    HONEYWELL 7DAY SNGL CHNL TIMESWITCH C/W EX LARGE BACKLIT DISPLAY ST9100C1106|ST9100C1006||Data to be standardised||
    HONEYWELL AQUASTAT SINGLE IMMERSION T/STAT WITH CAPILLARY 70-140C|L6188B2018U||||
    HONEYWELL S PLAN ZONE VALVE CONTROL PACK TW6Z910C|TW6Z910C||||
    H/WELL ST6100S1001 24HR 1CH SERVIC TIMER|||||
    H/WELL Y603A1133 BOXED Y PLAN                                        |||||
    HWEL V8600N2056 LOW VOLT COMBI VALVE                                        |||||
    HWEL VR4700C4022 GAS VALVE                                        |||||
    DULUX PAINTPOD 2M EXTENSION TUBE                                        |6030950||||
    DULUX PAINTPOD REPLACEMENT ROLLER SLEEVE|6030948||||
    DULUX PAINTPOD EXTRA REACH HANDLE                                        |6030951||||
    DULUX PAINTPOD REPLACEMENT EDGING BRUSH                                       |6030952||||
    DT TRADE WEATHERSHIELD ULTIMATE OPAQUE BLACK 1L|5180583||||
    DT TRADE WEATHERSHIELD ULTIMATE OPAQUE BLACK 2.5L|5180652||||
    DT TRADE WEATHERSHIELD ULTIMATE OPAQUE BLACK 5L|5180744||||
    DT TRADE WEATHERSHIELD ULTIMATE OPAQUE EXTRA DEEP BASE 1L|5180584||||

Définir les règles de parsing pour standardiser les données

  1. Double-cliquez sur le tStandardizeRow pour afficher sa vue Basic settings.

    Ce composant vous permet de définir les règles nécessaires pour standardiser le flux de données d'entrée non structurée et de générer la marque, la finition, la couleur et l'unité de mesure, au format XML.

  2. Dans la liste Column to parse, sélectionnez Long_Description.

  3. Cochez la case Standardize this field.

  4. Définissez vos règles comme suit :

    • Dans la table Conversion rules, cliquez sur le bouton [+] pour ajouter les colonnes nécessaires à la définition des règles.

      Ce scénario traite des règles de type Index. Pour des exemples détaillés concernant les autres types de règles définis dans la capture d'écran ci-dessus, consultez les autres scénarios du tStandardizeRow.

    • Définissez trois règles : Brand (marque), Range (finition) et Color (couleur).

    • Dans la liste Type, sélectionnez Index et renseignez le champ Value avec les variables de contexte des index générés.

      Pour plus d'informations concernant comment créer et utiliser des variables de contexte, consultez le Guide utilisateur du Studio Talend.

    • Dans la liste Search mode, sélectionnez Match exact. Les modes de recherche sont uniquement applicables aux règles Index.

      Avec le mode Match exact, vous extrayez du flux d'entrée uniquement les chaînes de caractères correspondant exactement aux chaînes de caractères dans l'index de la marque, la finition et la couleur générées avec le composant tSynonymOutput.

      Pour plus d'informations concernant les modes de recherche disponibles, consultez Modes de recherche pour les règles d'Index

  5. Cliquez sur le bouton Generate parser code in Routines afin de générer le code sous le dossier Routines, dans la vue DQ Repository, dans la perspective Profiling.

    Cette étape est obligatoire, sinon le Job ne s'exécute pas.

  6. Dans la vue Advanced settings, laissez les options par défaut dans la zone Output format.

    Le paramètre Max edits for fuzzy match est configuré à 1 par défaut.

  7. Double-cliquez sur le tLogRow afin de configurer ses propriétés dans la vue Basic settings.

  8. Dans la zone Mode, sélectionnez l'option Table (print values in cells of a table).

    Ce composant affiche les jetons du flux d'entrée ne pouvant pas être analysés et mis en correspondance par rapport aux chaînes de caractères de l'index.

Extraire les correspondances exactes

  1. Double-cliquez sur le tExtractXMLField pour afficher la vue Basic settings du composant.

  2. Cliquez sur le bouton [...] à côté du champ Edit schema pour ouvrir l'éditeur du schéma. Ajoutez quatre colonnes dans le flux de sortie et nommez-les Brand, Range, Color et Amount. Cliquez sur OK pour valider et fermer l'éditeur.

  3. Dans le champ XML field, vérifiez que la colonne STANDARDIZED_FIELD est sélectionnée.

    Le contenu de la colonne STANDARDIZED_FIELD est un champ XML avec la balise <record> comme racine. Sous cette balise, la structure définie par les règles configurées dans le composant tStandardizeRow vous permet d'extraire des éléments du flux d'entrée.

  4. Dans le champ Loop XPath query, saisissez "/" pour définir la racine comme nœud de boucle.

  5. Dans le champ XPath query de la table Mapping, saisissez respectivement "record/Brand", "record/Range""record/Color" et "record/Measure".

  6. Double-cliquez sur tFileOutputExcel pour afficher sa vue Basic settings.