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

Propriétés du tRecordMatching

Famille du composant

Data Quality

 

Fonction

Le tRecordMatching fait une jointure sur deux tables en effectuant une correspondance floue sur plusieurs colonnes, à l'aide d'une grande variété d'algorithmes de comparaison. Il compare des colonnes du flux principal à des colonnes du flux de référence (lookup) et écrit les données qui correspondent, les correspondances possibles et les données en rejet. Au moment de définir votre stratégie de correspondance, les scores de correspondance définis par l'utilisateur sont cruciaux pour déterminer le niveau de correspondance des données qui vous intéressent.

Objectif

Ce composant permet d'assurer la qualité des données de n'importe quelle source de données en la comparant avec une source de données de référence.&²

Basic settings

Schema et Edit schema

Un schéma est une description de lignes, il définit le nombre de champs 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 est stocké dans le Repository. Ainsi, il peut être réutilisé. Voir également le Guide utilisateur du Studio Talend.

 

Replace output column with lookup column if matches or possible matches

Cochez cette case pour remplacer la colonne de sortie par la colonne de référence en cas de correspondance ou de valeurs de correspondances possibles. Une fois la case cochée, le tableau Columns Mapping apparaît.

 

Columns Mapping

Complétez ce tableau afin de définir le colonnes de sortie à remplacer et les colonnes de référence de substitution.

- Output Column : sélectionnez la colonne à remplacer dans la liste déroulante. Dans cette liste, les deux colonnes MATCHING_WEIGHT et MATCHING_DISTANCES sont définies par défaut. Les autres colonnes sont disponibles lorsque vous les avez définies dans le schéma du composant. Pour plus d'informations concernant ces deux colonnes par défaut, consultez Scénario 1 : Correspondance d'entrées utilisant les algorithmes Q-grams et Levenshtein.

- Lookup Column ; sélectionnez la colonne de substitution dans la liste déroulante. Cette liste est disponible lorsqu'un lien Lookup a été ajouté afin de fournir au composant les colonnes de référence correspondantes.

 

Cliquez sur l'icône d'import pour sélectionner une règle de rapprochement dans le référentiel du Studio.

Lorsque vous cliquez sur l'icône d'import, un assistant [Match Rule Selector] s'ouvre pour vous permettre d'importer les règles de rapprochement du référentiel du Studio et les utiliser dans votre Job.

Vous pouvez uniquement importer des règles créées avec l'algorithme VSR. Pour plus d'informations, consultez Importer des règles de mise en correspondance depuis le référentiel du studio.

Key definition

Input Key Attribute

Sélectionnez la ou les colonne(s) du flux principal devant être vérifiées par rapport à la colonne clé de référence (lookup).

Note

Lorsque vous sélectionnez une colonne de dates sur laquelle appliquer un algorithme ou un algorithme de mise en correspondance, vous pouvez choisir ce que vous souhaitez comparer dans le format de date.

Par exemple, si vous souhaitez comparer uniquement l'année, attribuez le type Date à la colonne concernée dans le schéma du composant puis saisissez "yyyy" dans le champ Date Pattern. Le composant convertit le format de date en une chaîne de caractères, selon le modèle défini dans le schéma, avant de comparer les chaînes de caractères.

 

Lookup Key Attribute

Sélectionnez les colonnes clé du flux lookup que vous utiliserez comme référence, c'est-à-dire auxquelles vous souhaitez comparer les colonnes du flux d'entrée.

 

Matching Function

Sélectionnez l'algorithme de correspondance dans la liste :

Exact Match : associe chaque entrée traitée à toutes les entrées possibles de référence qui ont exactement la même valeur.

Levenshtein : cette option se base sur la théorie de la distance d'édition. Elle calcule le nombre d'insertions, suppressions ou substitutions nécessaires pour qu'une entrée corresponde à l'entrée de référence.

Metaphone : Cette option se base sur un algorithme phonétique afin d'indexer les entrées selon leur prononciation. Elle charge d'abord la phonétique de toutes les entrées du flux lookup de référence, puis vérifie toutes les entrées du flux principal par rapport aux entrées du flux de référence.

Double Metaphone : une nouvelle version de l'algorithme phonétique Métaphone, qui produit des résultats plus précis que l'algorithme originel. Il peut retourner un code primaire et un code secondaire pour une chaîne de caractères. Cela est utile dans des cas ambigus, mais également pour de multiples variantes de noms de famille aux origines communes.

Exact - ignore case : fait correspondre chaque entrée traitée à toutes les entrées de référence possibles ayant les mêmes valeurs, en ignorant la valeur de la casse.

Soundex : algorithme phonétique utile pour la comparaison de prénoms, selon la prononciation britannique.

Soundex FR : algorithme phonétique utile pour la comparaison de prénoms, selon la prononciation française.

Jaro ; fait correspondre les entrées traitées selon des erreurs d'orthographe.

q-grams : fait correspondre les entrées traitées en divisant les chaînes de caractères en blocs de lettres de longueur q, afin de créer un nombre de longueurs q-grammes. Le résultat de correspondance est donné comme le nombre de correspondances entre les q-grammes d'entrée et de référence, divisé par le nombre de q-grammes possibles.

custom... : permet de charger un algorithme externe de mise en correspondance à partir d'une bibliothèque Java. La colonne Custom Matcher Class est activée lorsque vous sélectionnez cette option.

Pour plus d'informations concernant le chargement d'une bibliothèque externe Java, consultez tLibraryLoad.

 

Custom Matcher

Saisissez le chemin pointant vers la classe personnalisée (algorithme externe de mise en correspondance) que vous souhaitez utiliser. Vous définissez ce chemin dans le fichier de la bibliothèque (fichier .jar).

Par exemple, pour utiliser une classe MyDistance.class stockée dans le répertoire org/talend/mydistance dans une bibliothèque personnalisée  mydistance.jar, le chemin d'accès à saisir est org.talend.mydistance.MyDistance.

 

Weight

Définissez un poids numérique pour chaque attribut (colonne) de la définition de clé. Les valeurs doivent être supérieures à 0.

 Handle Null

Handle Null

Pour gérer des valeurs Null, sélectionnez dans la liste l'opérateur à utiliser sur la colonne :

Null Match Null : un attribut Null correspond à un autre attribut Null uniquement.

Null Match None : un attribut Null ne correspond jamais à un autre attribut.

Null Match All : un attribut Null correspond à n'importe quelle autre valeur d'un attribut.

Par exemple, dans deux colonnes name et firstname pour lesquelles le nom n'est jamais null, le prénom peut être null.

Si vous avez deux enregistrements :

"Doe", "John"

"Doe", ""

Selon l'opérateur sélectionné, ces deux enregistrements peuvent correspondre ou ne pas correspondre :

Null Match Null : ne correspondent pas.

Null Match None : ne correspondent pas.

Null Match All : correspondent.

Pour les enregistrements

"Doe", ""

"Doe", ""

Null Match Null : correspondent.

Null Match None : ne correspondent pas.

Null Match All : correspondent.

Blocking Selection

Input Column

Au besoin, sélectionnez la (les) colonne(s) de flux d'entrée selon laquelle (lesquelles) vous souhaitez partitionner les données traitées en blocs, ce qui est habituellement appelé "blocking".

La création de blocs (ou de groupes) réduit le nombre de paires d'enregistrements nécessitant examen. Lors de la création de blocs, les données d'entrée sont partitionnées en blocs exhaustifs créés pour augmenter la proportion de correspondances observées lors de la réduction du nombre de paires à comparer. Les comparaisons sont limitées aux paires d'enregistrements dans chaque bloc.

Utiliser des colonnes de bloc est très utile lorsque vous traitez des données très volumineuses.

 Matching strategy

Sélectionnez le type de correspondance en sortie qui répond le mieux à vos besoins. Choisissez :

  • All matches : écrit en sortie les enregistrements qui correspondent ou peuvent correspondre.

  • Best match : écrit en sortie uniquement l'enregistrement possédant le plus haut score de correspondance.

  • First match : écrit en sortie le premier enregistrement correspondant. Si aucun ne correspond, la première correspondance possible sera écrite en sortie.

  • Last match : écrit en sortie le dernier enregistrement correspondant. Si aucun ne correspond, la dernière correspondance possible sera écrite en sortie.

    Au moment de sélectionner votre stratégie de correspondance, les scores de correspondance sont cruciaux. Définissez-les dans le champ Possible match interval dans la vue Advanced settings.

Advanced settings

Matching Algorithm

Sélectionnez un algorithme dans la liste - seul un est disponible pour le moment.

Simple VSR Matcher : cet algorithme est basé sur la méthode de modèle vectoriel, qui spécifie comment deux enregistrements peuvent correspondre.

 

Possible match interval

Saisissez une valeur minimale et une valeur maximale.

minimum : définissez le nombre minimum de changements autorisés afin de correspondre à la référence (les valeurs doivent être supérieures à 0)

maximum : définissez le nombre maximal de changements autorisés afin de correspondre à la référence (Les valeurs doivent être inférieures à 1).

Par exemple, si vous définissez 0,5 comme valeur minimum et 0,9 comme valeur maximum, les scores égaux ou supérieurs à 0,9 indiquent une correspondance. Ceux compris entre 0,5 exclu et 0,9 exclu indiquent une correspondance possible et les autres résultats indiquent qu'il n'y a pas de correspondance.

 

Store on disk

Cochez cette case si vous souhaitez stocker les blocs de données traitées sur le disque, afin d'optimiser les performances de votre système.

 

tStatCatcher Statistics

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

NB_MATCH_LINE : nombre de lignes correspondant à l'algorithme de comparaison. Cette variable est une variable After et retourne un nombre entier.

NB_POSSIBLE_MATCH_LINE : nombre de lignes pouvant correspondre à l'algorithme de rapprochement. Cette variable est une variable After et retourne un nombre entier.

NB_NONE_MATCH_LINE : nombre de lignes ne correspondant pas à l'algorithme de rapprochement. Cette variable est une variable After et retourne un nombre entier.

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 nécessite un composant d'entrée et un composant de sortie.

Créer un algorithme de correspondance personnalisé

Le composant tRecordMatching vous permet d'utiliser un algorithme de mise en correspondance personnalisé afin d'obtenir les résultats dont vous avez besoin.

Un algorithme de mise en correspondance personnalisé est écrit manuellement et stocké dans un fichier .jar (archive Java). Talend fournit un exemple de fichier .jar sur la base duquel vous pouvez créer votre propre fichier. Pour ce faire, procédez comme suit :

  1. Dans Eclipse, effectuez un check out sur le projet SVN test.mydistance :

    http://talendforge.org/svn/top/trunk/test.mydistance/

  2. Dans ce projet, naviguez jusqu'à la classe Java nommée MyDistance.Java. http://talendforge.org/svn/top/trunk/test.mydistance/src/main/java/org/talend/mydistance//

  3. Ouvrez ce fichier contenant le code suivant :

    package org.talend.mydistance;
    
    import org.talend.dataquality.record.linkage.attribute.AbstractAttributeMatcher;
    import org.talend.dataquality.record.linkage.constant.AttributeMatcherType;
    
    /**
     * @author scorreia
     * 
     * Example of Matching distance.
     */
    public class MyDistance extends AbstractAttributeMatcher {
    
        /*
         * (non-Javadoc)
         * 
         * @see org.talend.dataquality.record.linkage.attribute.IAttributeMatcher#getMatchType()
         */
        @Override
        public AttributeMatcherType getMatchType() {
            // a custom implementation should return this type AttributeMatcherType.custom
            return AttributeMatcherType.CUSTOM;
        }
    
        /*
         * (non-Javadoc)
         * 
         * @see org.talend.dataquality.record.linkage.attribute.IAttributeMatcher#getMatching
         Weight(java.lang.String,
         * java.lang.String)
         */
        @Override
        public double getWeight(String arg0, String arg1) {
            // Here goes the custom implementation of the matching distance between the two given strings.
            // the algorithm should return a value between 0 and 1.
    
            // in this example, we consider that 2 strings match if their first 4 characters are identical
            // the arguments are not null (the check for nullity is done by the caller)
            final int max = 4;
            int nbIdenticalChar = Math.min(max, Math.min(arg0.length(), arg1.length()));
            for (int c = 0; c < max; c++) {
                if (arg0.charAt(c) != arg1.charAt(c)) {
                    nbIdenticalChar = c;
                    break;
                }
            }
            return (max - nbIdenticalChar) / ((double) max);
        }
    
    }
  4. Dans ce fichier, saisissez le nom de la classe de l'algorithme personnalisé que vous créez afin de remplacer le nom par défaut. Le nom par défaut est MyDistance et vous pouvez le trouver dans la ligne : public class MyDistance implements IAttributeMatcher.

  5. A la place de l'algorithme par défaut dans le fichier, saisissez l'algorithme que vous souhaitez créer. L'algorithme par défaut se présente comme suit :

    final int max = 4;
            int nbIdenticalChar = Math.min(max, Math.min(arg0.length(), arg1.length()));
            for (int c = 0; c < max; c++) {
                if (arg0.charAt(c) != arg1.charAt(c)) {
                    nbIdenticalChar = c;
                    break;
                }
            }
            return (max - nbIdenticalChar) / ((double) max);
  6. Sauvegardez vos modifications.

  7. Via Eclipse, exportez ce nouveau fichier .jar.

Cet algorithme personnalisé est prêt à être utilisé par le composant tRecordMatching.

Scénario 1 : Correspondance d'entrées utilisant les algorithmes Q-grams et Levenshtein

Ce scénario décrit un Job à six composants ayant pour but de :

  • faire correspondre les entrées de la colonne name à celles du fichier d'entrée de référence en divisant les chaînes de caractères en blocs de longueur q, où q est de trois, afin de créer un certain nombre de q-grammes. Le résultat de correspondance est donné comme le nombre de correspondances entre les q-grammes d'entrée et de référence, divisé par le nombre de q-grammes possibles,

  • faire correspondre la distance d'édition entre les entrées de la colonne email du fichier d'entrée et celles du fichier d'entrée de référence.

Les sorties de ces deux types de correspondances sont écrites dans trois fichiers de sortie : le premier pour les valeurs de correspondance, le deuxième pour les valeurs de correspondance possible, et le troisième pour les valeurs n'ayant aucune correspondance dans le fichier de référence.

Dans ce scénario, vous avez déjà stocké les schémas principaux et de référence dans le Repository. Pour plus d'informations concernant le stockage des métadonnées de schémas dans le Repository, consultez le Guide utilisateur du Studio Talend.

La table d'entrée principale contient sept colonnes : code, name, address, zipcode, city, email et col7. Vous allez effectuer une correspondance floue sur deux colonnes : name et email.

Construire le Job

  1. Dans la vue Repository, développez les nœuds Metadata - DB Connections où vous avez stocké les schémas principaux d'entrée, et glissez le fichier correspondant dans l'espace de modélisation graphique.

    La boîte de dialogue [Components] s'ouvre.

  2. Sélectionnez le tMysqlInput et cliquez sur OK afin de déposer un composant tMysqlInput dans l'espace de modélisation graphique.

    La table d'entrée utilisée dans ce scénario est appelée person. Elle contient plusieurs colonnes, y compris les deux colonnes name et email sur lesquelles effectuer la correspondance floue. La capture d'écran suivante montre les propriétés simples du composant principal d'entrée, récupérées du Repository.

  3. Répétez l'opération pour la seconde table d'entrée que vous souhaitez utiliser comme référence, customer dans ce scénario.

    La capture d'écran suivante montre les propriétés simples du composant de référence.

  4. Déposez un composant tRecordMatching de la Palette dans l'espace de modélisation graphique, ainsi que trois tLogRow.

  5. Connectez les composants d'entrée principal et de référence au tRecordMatching à l'aide de liens Main. Le lien entre la table d'entrée de référence et le tRecordMatching s'affiche comme Lookup dans l'espace de modélisation graphique.

  6. Connectez le tRecordMatching aux trois composants tLogRow à l'aide des liens Matches, Possible Matches et Non Matches.

Configurer les composants

  1. Double-cliquez sur le tRecordMatching afin d'afficher sa vue Component et définir ses propriétés.

  2. Cliquez sur le bouton Edit schema afin d'ouvrir une boîte de dialogue. Vous pouvez définir les données que vous souhaitez passer aux composants de sortie.

    Dans cet exemple, l'objectif est de passer au composant tRecordMatching les colonnes name et email du premier composant tMysqlInput, ainsi que les colonnes ref_name et ref_email du second composant tMysqlInput.

    Les colonnes MATCHING_DISTANCE et MATCHING_WEIGHT du schéma de sortie sont définies par défaut.

    La valeur de la colonne MATCHING_WEIGHT est toujours comprise entre 0 et 1. C'est une distance globale entre les ensembles de colonnes (définis pour correspondre par les colonnes).

    La colonne MATCHING_DISTANCE affichera une distance pour chaque colonne sur laquelle a été utilisé un algorithme. Les résultats seront séparés pas une barre verticale.

    Cliquez sur OK afin de fermer la boîte de dialogue et procéder à l'étape suivante.

  3. Dans le tableau Key Definition de la vue Basic settings du composant tRecordMatching, cliquez sur le bouton [+] afin d'ajouter deux colonnes à la liste.

  4. Sélectionnez les colonnes d'entrée et de sortie sur lesquelles vous voulez effectuer la correspondance floue, à partir des colonnes Input key attribute et Lookup key attribute respectivement.

    Dans cet exemple, sélectionnez les colonnes name et email comme attributs d'entrée, et les colonnes ref-name et ref_email comme attributs de référence.

    Note

    Lorsque vous sélectionnez une colonne de dates sur laquelle appliquer un algorithme ou un algorithme de mise en correspondance, vous pouvez choisir ce que vous souhaitez comparer dans le format de date.

    Par exemple, si vous souhaitez comparer uniquement l'année, attribuez le type Date à la colonne concernée dans le schéma du composant puis saisissez "yyyy" dans le champ Date Pattern. Le composant convertit le format de date en une chaîne de caractères, selon le modèle défini dans le schéma, avant de comparer les chaînes de caractères.

  5. Cliquez sur la colonne Matching type et sélectionnez q-gram dans la liste, la méthode devant être utilisée sur la première colonne, afin de vérifier les données d'entrée, par rapport aux données de référence.

  6. Définissez le type de correspondance de la seconde colonne, Levenshtein dans cet exemple.

    Les valeurs minimale et maximale de correspondance possible sont définies dans la vue Advanced settings. Vous pouvez modifier les valeurs par défaut.

  7. Dans la colonne Confidence Weight, définissez un poids pour chacune des colonnes utilisées comme attributs de clé.

  8. Cliquez dans la cellule de la colonne Handle Null et sélectionnez l'opérateur à utiliser pour gérer les attributs nulls dans les colonnes.

  9. Si nécessaire, cliquez sur le bouton [+] sous la table Blocking Selection pour ajouter une ou plusieurs lignes. Cliquez dans la ligne et sélectionnez dans la liste la colonne à utiliser comme valeur de bloc.

    L'utilisation d'une valeur de bloc réduit le nombre de paires d'enregistrements à examiner. Les données d'entrée sont partitionnées en blocs exhaustifs, selon la valeur de bloc. Le nombre de paires à comparer est réduit, car la comparaison est restreinte aux paires d'enregistrements dans chaque bloc. Consultez Scénario 2 : Comparer les colonnes et regrouper dans le flux de sortie les enregistrements en doublon ayant la même clé fonctionnelle pour un scénario concernant les valeurs de bloc.

  10. Double-cliquez sur le premier tLogRow afin d'afficher sa vue Component et définir ses propriétés. Dans la zone Mode, sélectionnez Table, afin d'afficher le fichier source et les résultats du tRecordMatching ensemble, pour pouvoir les comparer.

  11. Répétez l'opération pour les deux autres composants tLogRow.

Exécuter le Job

  • Sauvegardez votre Job et appuyez sur F6 afin de l'exécuter.

    Trois tables de sortie sont affichées dans la console. La première montre les entrées qui correspondent, la deuxième retourne les entrées pouvant correspondre, et la dernière affiche les entrées qui ne correspondent pas, selon la méthode de correspondance utilisée dans les colonnes définies.

    La capture d'écran ci-dessous illustre les extractions des trois tables de sortie.

La première table liste tous les noms et adresses e-mails pouvant correspondre à des entrées de la table de référence. La distance de correspondance et le poids de correspondance sont équivalents à "1.0".

La seconde table liste tous les noms et adresses e-mail pouvant avoir une correspondance dans la table de référence. La colonne de distance de correspondance affiche les distances pour les colonnes name et email.

La troisième table liste tous les noms et les adresses e-mail n'ayant aucune correspondance dans la table de référence.

Scénario 2 : Utiliser un algorithme de mise en correspondance personnalisé pour faire correspondre des entrées

Dans ce scénario, réutilisez le Job précédent afin de charger et d'appliquer un algorithme de correspondance personnalisé.

Comme prérequis, suivez les étapes décrites dans Créer un algorithme de correspondance personnalisé afin d'écrire une algorithme personnalisé et le stocker dans un fichier .jar (archive Java). Le fichier mydistance.jar est utilisé ici pour fournir l'algorithme personnalisé de mise en correspondance, MyDistance.class.

Vous devez également utiliser le composant tLibraryLoad pour importer la bibliothèque Java dans le Job.

Construire le Job

  1. Dans le Job précédent, déposez un composant tLibraryLoad de la Palette dans l'espace de modélisation graphique.

  2. Supprimez les composants tLogRow nommés possible et none.

  3. Cliquez-droit sur le tLibraryLoad afin d'ouvrir son menu contextuel. Dans ce menu, sélectionnez Trigger > On Subjob Ok afin de le relier au composant tMysqlInput (person).

Configurer les composants

  1. Double-cliquez sur le tLibraryLoad pour ouvrir sa vue Component.

  2. A côté du champ Library, cliquez sur le bouton [...] et parcourez votre système jusqu'au fichier mydistance.jar.

  3. Cliquez sur Windows > Show view... pour ouvrir la vue Modules.

  4. Dans la vue Modules, cliquez sur le bouton . Dans la boîte de dialogue qui s'ouvre, parcourez votre système jusqu'au fichier personnalisé mydistance.jar, créé pour ce Job.

  5. Cliquez sur Open.

    Le fichier .jar personnalisé est importé et listé dans la vue Modules.

    Un message d'erreur s'affiche si vous essayez d'exécuter le Job sans avoir installé le fichier .jar externe personnalisé.

  6. Double-cliquez sur le tRecordMatching pour ouvrir sa vue Component.

  7. Dans le tableau Key Definition, cliquez sur la ligne name de la colonne Matching Type et sélectionnez custom... dans la liste déroulante.

  8. Dans la colonne Custom matcher class de la ligne name, saisissez le chemin d'accès pointant vers MyDistance.class dans le fichier mydistance.jar. Dans cet exemple, ce chemin d'accès est org.talend.mydistance.MyDistance.

    Note

    Lorsque vous sélectionnez une colonne de dates sur laquelle appliquer un algorithme ou un algorithme de mise en correspondance, vous pouvez choisir ce que vous souhaitez comparer dans le format de date.

    Par exemple, si vous souhaitez comparer uniquement l'année, attribuez le type Date à la colonne concernée dans le schéma du composant puis saisissez "yyyy" dans le champ Date Pattern. Le composant convertit le format de date en une chaîne de caractères, selon le modèle défini dans le schéma, avant de comparer les chaînes de caractères.

Exécuter le Job

  • Appuyez sur F6 pour exécuter le Job.

    Dans la vue Run, les entrées en correspondance sont identifiées et affichées comme suit :