Ministère de l’Enseignement Supérieur
∗∗∗ ∗ ∗∗∗
Université du 7 novembre à Carthage
∗∗∗ ∗ ∗∗∗
[nom]
Appliquées et de Technologie
Projet de Fin d’Etudes
Pour l’obtention du Diplôme [nom] d’Ingénieur en [nom] Appliquées et en Technologie
Filière : Réseaux Informatiques et Télécommunications
Sujet :
Conception et Réalisation d'un outil de génération
automatique de Mappage pour la transformation de
documents XML
Réalisé par : · Sana SELLAMI
Laboratoire d’accueil :
LIRIS (Laboratoire d'Informatique en Images et Systèmes d'Information)
Soutenu le 22/05/2006
Responsable · LIRIS · Nabila BENHARKAT
Co-Responsable SDSC · Rami RIFAIEH
Responsable · INSAT · Mona LAROUSSI
Année Universitaire : 2005/2006
A mon père à qui je dois tout
A ma mère pour son soutien et sa présence aux moments difficiles
A mes grands parents
Remerciements
Le plus dur n’est pas de rédiger le rapport mais de remercier toutes les personnes qui m’ont soutenu pour réaliser ce projet. Je tiens tout d’abord à remercier ma directrice de stage Mme
Nabila BENHARKAT, maître de conférences au LIRIS, de m’avoir acceptée pour effectuer ce stage de projet de fin d’études, pour son temps précieux et ses précieux conseils tout au long du déroulement de ce stage. Je remercie également M.Rami RIFAIEH, doctorant à l’université de Californie San Diego, avec qui j’ai travaillé étroitement durant mon stage, pour ses conseils et discussions fructueuses.
Je remercie sincèrement madame Mona LAROUSSI d’avoir accepté de m’encadrer et de me soutenir tout au long de stage. Je tiens à lui exprimer toute mon admiration et ma reconnaissance.
Finalement, j’adresse mes profondes gratitudes à ma famille qui a été toujours à mes côtés, pour son soutien et son encouragement. Je remercie également tous mes amis : Reim, Claudia, Fred, Salma, Rachid, Girma, Samir, Skander, Claire, Ferid,Riadh, KhalilFaten, Imene, Emna, Jihene,Mehdi.
Table [nom] matières
Chapitre 1 Introduction .....................................................................................................................9
- Introduction................................................................................................................................9
- Problématique ..........................................................................................................................10
- Plan du rapport ........................................................................................................................10
- Environnement du stage..........................................................................................................11 Chapitre 2 Etat de l'art sur le Matching .........................................................................................12
- L'interopérabilité .....................................................................................................................12
- Les schémas XML ....................................................................................................................12
- Les algorithmes de Matching [nom] schémas ............................................................................13 3.1. Les approches basées sur les schémas de données.............................................................13 3.2. Les approches basées sur les instances ou ontologies........................................................13
- EX-SMAL [7] (EDI/XML semi-automatic Schema Matching Algorithm).........................14
- Conclusion.................................................................................................................................15 Chapitre 3 Etat de l'art sur les modèles de mappage......................................................................16
- Mapping [nom] schémas ..............................................................................................................16
- Modèles de découverte [nom] expressions de mappage ..........................................................17 2.1 Value Correspondences .......................................................................................................17 2.2 Le Modèle d'expression de Mappage [1].............................................................................18 2.3 Le Modèle de données LIMXS ............................................................................................19 2.4 Le modèle XHS (Intégration via l'HYPERSCHEMA XML) ................................................21 2.5 Model Management System ................................................................................................23 2.6 TUPELO..............................................................................................................................24
- Synthèse [nom] expressions de mappage....................................................................................25 Chapitre 4 Etat de l'art sur les outils de Mapping ..........................................................................26
- Introduction..............................................................................................................................26
- Les plateformes et Outils de Mapping ...................................................................................26 2.1 Altova MapForce ................................................................................................................26 2.2 Schema Mapper....................................................................................................................28 2.3 Stylus Studio.........................................................................................................................30 2.4 Visual XSLT..........................................................................................................................31 2.5 TIBCO XMLTransform .......................................................................................................32 2.6 Adeptia XML Mapper...........................................................................................................33 2.7 Redix AnyToAny XML GUI Mapper ...................................................................................35 2.8 Clio......................................................................................................................................35 2.9 HyperMapper ......................................................................................................................36 2.10 BEA WebLogic Workshop.................................................................................................38 2.11 Cape Clear .........................................................................................................................38
4
- Tableau comparatif.................................................................................................................40
- Conclusion.................................................................................................................................41 Chapitre 5 Architecture ASMADE..................................................................................................42
- Introduction..............................................................................................................................42
- Présentation de l’architecture ASMADE ..............................................................................42 2.1 La Première Couche: Matching Layer ...............................................................................44 2.2 La Deuxième Couche: Filtering Layer ...............................................................................44 2.3 La Troisième Couche : Mapping Layer ...............................................................................44 2.3.1 Représentation XSD de XME ............................................................................................46 2.3.2 Instance du modèle XME ..................................................................................................46 2.3.3 Opérateurs de transformations .........................................................................................47 2.4 Quatrième Couche : Transformation Layer........................................................................48
- Conclusion.................................................................................................................................49 Chapitre 6 Conception ....................................................................................................................50
- Introduction..............................................................................................................................50
- Conception de l’architecture...................................................................................................50 2.1 Identification [nom] diagrammes .............................................................................................50 2.2 Conception [nom] couches .......................................................................................................51 2.2.1. Diagramme de cas d'utilisation .......................................................................................51 2.2.2 Diagramme d'activités ......................................................................................................52 2.2.3 Diagramme de classes ......................................................................................................54
- Conclusion.................................................................................................................................55 Chapitre 7 Réalisation.....................................................................................................................56
- Introduction..............................................................................................................................56
- Environnement de travail........................................................................................................56 2.1 Environnement matériel.......................................................................................................56 2.2 Environnement logiciel ........................................................................................................56
- Implémentation ........................................................................................................................57 3.1 Choix de langage de programmation : Java........................................................................57 3.2 Développement de l’application ..........................................................................................57 3.2.1 Prototype...........................................................................................................................57 3.2.2 Choix [nom] schémas ............................................................................................................58 3.2.3 Matching [nom] schémas ......................................................................................................59 3.2.4 Filtrage..............................................................................................................................60 3.2.5 Sauvegarde du résultat......................................................................................................61 3.2.6 Choix [nom] fonctions de Mapping.......................................................................................61
- Difficultés techniques...............................................................................................................63
- Conclusion.................................................................................................................................63 Conclusions et Perspectives ..............................................................................................................64 Bibliographie .....................................................................................................................................66 Annexe A: Schéma1 et Schéma2......................................................................................................69
5
Annexe B: Requête de transformation de schémas .........................................................................70
6
Table [nom] figures
Figure 1 Description brève de l'algorithme.......................................................................................15
Figure 2 EXS représentant le concept personne..............................................................................22
Figure 3 Mapping dans MapForce....................................................................................................27
Figure 4 Mapping [nom] noeuds............................................................................................................29
Figure 5 Mapping dans Stylus Studio ................................................................................................30
Figure 6 Mapping dans Visual XSLT.................................................................................................31
Figure 7 Mapping dans Tibco XML Transform.................................................................................33
Figure 8 Mapping dans Adeptia XML Mapper..................................................................................34
Figure 9 Mapping dans Redix AnyToAny XML GUI Mapper ..........................................................35
Figure 10 Mapping dans Clio...........................................................................................................36
Figure 11 Interface de Mapping dans HyperMapper.......................................................................37
Figure 12 Mapping dans BEA WebLogic Workshop ........................................................................38
Figure 13 Mapping dans Cape Clear ...............................................................................................39
Figure 14 Architecture de ASMADE ................................................................................................43
Figure 15 Représentation de XME.....................................................................................................46
Figure 16 Diagramme de Cas d'utilisation.......................................................................................51
Figure 17 Diagramme d'activités représentant l'intéraction entre les différents modules................52
Figure 18 Diagramme de classes......................................................................................................55
Figure 19 Interface de ASMADE .....................................................................................................58
Figure 20 Choix [nom] schémas à comparer........................................................................................58
Figure 21 Sélection [nom] schémas ......................................................................................................59
Figure 22 Choix [nom] Coefficients pour le Matching ........................................................................59
Figure 23 Matching entre les schémas .............................................................................................60
Figure 24 Choix du coefficient de filtrage ........................................................................................60
Figure 25 Sauvegarde du résultat du Matching ...............................................................................61
Figure 26 Choix [nom] fonctions de Mapping ......................................................................................62
Figure 27 Mapping entre les schémas ..............................................................................................62
7
Liste [nom] Tableaux
Tableau 1 Exemple de représentation de LIMXS en XML.................................................................20
Tableau 2 Tableau de comparaison [nom] outils de Mapping ..............................................................40
Liste [nom] Equations
Équation 1 Modèle d'expression de Mappage dans Miller et al........................................................17
Équation 2 Modèle d'expression de Mappage ...................................................................................18
Équation 3 Formalisation du modèle................................................................................................24
Équation 4 Modèle mathématique ....................................................................................................25
Équation 5 Modèle d'expression de mappage étendu.......................................................................44
8
Chapitre 1 Introduction
Avec l'arrivée de l'Internet et du Web, le nombre de sources d'informations interconnectées
ainsi que le nombre d'utilisateurs potentiels de ces sources a connu une augmentation exponentielle
durant les dix dernières années. L’environnement informationnel actuel se caractérise par [nom]
données fortement distribuées. Ces données surabondantes sont généralement éparpillées, puisqu’il
existe souvent de multiples systèmes conçus chacun pour être efficace pour les fonctions pour
lesquelles il est spécialisé. Ces données se trouvent dans plusieurs domaines d'application tels que
les entrepôts de données, l'intégration de données, le commerce électronique, le traitement de
requêtes sémantiques, etc.
Le monde informatique regorge, ainsi, [nom] données aux formats très hétérogènes, autrement dit
utilisent [nom] modèles différents pour la représentation de l'information, qu'il est nécessaire d'intégrer
pour construire [nom] applications. En effet, les données peuvent être de plusieurs types : structurées
(données relationnelles, données objet), semi-structurées (HTML, XML, graphes) ou même non
structurées (texte, images, son). Dans un tel contexte, le besoin d’intégration se fait de plus en plus
sentir. Cependant, pour répondre à ce besoin, le développement [nom] applications d’intégration
(telles que pour un traitement élaboré de données, pour la construction [nom] entrepôts de données ou
[nom] systèmes d’aide à la décision) se voit contraint de composer avec la répartition [nom] sources et
l’hétérogénéité de leurs structures et de gérer l'interopérabilité entre les données en différents
formats qu'ils manipulent.
De nombreuses technologies ont permis de faire communiquer [nom] applications relevant de
systèmes d'informations différents permettant ainsi d'atteindre un niveau d'interopérabilité qu'il
s'agit toutefois d'étendre et d'améliorer. En dépit de nombreux outils disponibles sur le marché, le
problème de l'interopérabilité [nom] applications demeure entier car il faut pérenniser l'existant pour
l'intégration de standards mais aussi pour l'échange et la réutilisation.
Nous nous positionnons ici dans le cas d'intégration [nom] données et nous cherchons à améliorer la
transformation [nom] schémas XML. Ces schémas XML sont une représentation logique enrichie par
[nom] méta connaissances sémantiques utilisées lors de la phase de Matching. Nous nous sommes
donc intéressés au domaine du Matching et du Mapping [nom] schémas XML pour lesquels il serait
possible de réutiliser telles quelles les technologies déjà existantes. Ces deux processus qui se
9
suivent sont [nom] pré requis à l'intégration et la transformation de documents XML.
L'intégration [nom] données se reporte à un problème combinatoire de données résidentes dans
[nom] sources autonomes et hétérogènes. C e problème est rendu crucial avec la prolifération [nom]
sources de données sur Internet ou au sein [nom] entreprises, le caractère hétérogène de ces données et
le besoin de plus en plus pressant d’exploiter ces gisements de données pour [nom] besoins
décisionnels.
Notamment, l'appariement de schémas est l'un [nom] problèmes majeurs rencontrés lors du processus
d'intégration soit de données (par exemple, la médiation de données, les entrepôts de données, etc.),
soit applications (par exemple, le e-commerce, le Web sémantique, etc.).
Tout ceci pose de sérieux problèmes aux utilisateurs qui cherchent à combiner, ou "intégrer" [nom]
informations provenant [nom] sources différentes. Parmi eux on peut citer les problèmes liés à la
gestion [nom] schémas, l'évolution [nom] schémas, le Mapping et le Matching [nom] schémas.
Dans ce contexte, plusieurs approches ont été développées cernant ainsi les aspects de
transformation de données qui résultent de l’hétérogénéité technique, syntaxique et sémantique [nom]
sources de données, de génération de Matching et de Mappings.
Pour simplifier et accélérer ces tâches d'intégration de données et garantir une interconnexion
efficace entre tous les systèmes, il est nécessaire de bâtir [nom] passerelles entre tous ces types de
données. Ceci se fera en permettant de concevoir les schémas de Mapping de façon visuelle et en
automatisant les transformations nous permettant de nous concentrer sur l'implémentation de la
logique métier dans les applications.
Le présent rapport est organisé en trois grandes parties. La première est consacrée à l’état de
l’art où est passée en revue la littérature relative aux technologies traitées. En effet, un état de l'art
recensant les algorithmes de Matching de schémas est présenté dans le chapitre 2. Dans le chapitre
3, nous décrivons les modèles de découverte [nom] expressions de mappage. Dans le chapitre 4, nous
allons étudier les outils existants qui réalisent le Mapping et faire une comparaison entre eux.
Dans la deuxième partie, on va proposer une architecture répondant à toutes les problématiques
posées. Dans le chapitre 5, nous allons détailler cette architecture et présenter ses spécificités.
Le chapitre 6 sera consacré à la conception de l'architecture proposée et le chapitre 7 à la réalisation
et l'implémentation de cette architecture.
10
Enfin, la dernière partie (conclusion et perspectives) synthétise le travail accompli et les différents
points que nous devons développer dans le futur.
Mon stage s'est déroulé au laboratoire LIRIS (Laboratoire d'Informatique en Images et
Systèmes d'Information) à l' INSA ([nom] Appliquées) de Lyon. Le LIRIS
est né début 2003 à la suite du regroupement de plusieurs laboratoires de recherche lyonnais
(LIGIM, LISI, RFV) et d'individualités du domaine [nom] et Techniques de l'Information et
de la Communication.
Il a deux thèmes principaux de recherche : l'image numérique et les systèmes d'information, qui
sont déclinés suivant :
Quatre axes scientifiques :
- Axe 1 - Données, Documents et Connaissances.
- Axe 2 - Images et vidéos : segmentation et extraction d'information.
- Axe 3 - Modélisation et réalité augmentée.
- Axe 4 - Systèmes d'information communicants.
Deux actions transverses :
- Action A - Plate-forme d'Intégration d'outils logiciels pour le document numérique, en liaison avec l'[nom] du Document Numérique (ISDN).
- Action B - Plate-forme d'Intégration logicielle : dossier médical multimédia réparti, en liaison avec le thème fédérateur "Ingénierie de la Santé".
11
Première Partie – État de l’art · INSAT
Chapitre 2 Etat de l'art sur le Matching
L'interopérabilité de plusieurs sources de données hétérogènes et autonomes est un problème
important dans plusieurs applications comme les systèmes de médiation, datawarehouse et les
systèmes basés sur le web. Son but est de fournir une vue uniforme sur les données sources.
Les applications utilisant le système interopérable utilisent un schéma source qui représente ses
données au monde extérieur et définissent le schéma cible qui représente leurs besoins. Il y a deux
sortes de liens établis entre chaque schéma source et chaque schéma cible : le Matching (les
correspondances sémantiques) et le Mapping.
Le schéma XML est une norme définie par le World Wide Web Consortium (W3C) [31] conçue
comme une infrastructure de base pour la description du type et de la structure [nom] documents
XML.
Les schémas fournissent donc un modèle pour un document de données XML qui définit la mise en
place [nom] balises et du texte à l’intérieur de tous les documents faisant référence au schéma.
En termes d’utilisation, les schémas XML sont destinés à décrire la structure de données dans un
format commun que les divers navigateurs Web, les applications et tous les clients utilisant XML
peuvent reconnaître. Plus spécifiquement, les schémas définissent les règles qu’ un document de
données XML (notamment les noms d’éléments et les types de données) doit respecter. Ils
définissent comment les éléments peuvent se combiner et quels attributs sont disponibles pour
chaque élément.
L'utilisation d'un schéma est un atout pour l'interopérabilité. Il peut être fourni à d'autres
applications, de façon qu'elles sachent structurer les données et donc les schémas, qu'elles
transforment en retour.
Pour cette raison, les méthodes de Matching basées sur les schémas et donc, sur le nom [nom]
éléments, leur type, les méta données et [nom] algorithmes sont développés. Ils permettent alors
l'obtention d'un ensemble de règles d'association entre les éléments [nom] schémas XML.
12
Première Partie – État de l’art · INSAT
- Les algorithmes de Matching [nom] schémas
Le Matching [nom] schémas est une technique qui effectue la découverte de correspondances
sémantiques entre les éléments et les attributs [nom] schémas. Le Matching est donc, une opération
qui prend par exemple deux schémas de données en entrée et retourne à la fin les valeurs de
similarités sémantiques entre les éléments [nom] schémas.
Plusieurs travaux ont été réalisés afin de fournir [nom] algorithmes de Matching gérant les
correspondances ou incompatibilités [nom] schémas.
Dans la littérature on distingue [nom] catégories d'algorithmes de Matching:
3.1. Les approches basées sur les schémas de données
Dans cette catégorie, on trouvera les algorithmes travaillant sur les méta données (DTD,
schémas XML, schémas de bases de données, …) spécifiques pour trouver l'indice de similarité le
plus précis entre les éléments, Cupid [15] en est un exemple. Cet algorithme tente de trouver les
correspondances sémantiques [nom] éléments de différents schémas qui sont génériques. Les auteurs
ont testé leur application sur les schémas XML et les schémas relationnels. Le processus de
Matching se déroule en trois étapes: le calcul de la similarité, la similarité structurelle (les éléments
atomiques, les éléments composés, les feuilles, les noeuds internes, les sous arbres), et le calcul du
poids de similarité.
Similarity Flooding [16] [17] est un algorithme de Matching structurel pour schémas XML,
SQL DDL, schemas RDF, UML et OEM. Il utilise l'idée d'influence de nœud sur ses adjacents.
Dans [18] XClust est une stratégie d'intégration basée sur le clustering [nom] DTD ou bien sur les
schémas. La similarité linguistique dans ce cas, est basée sur un thésaurus et la similarité
structurelle est basée sur (les éléments atomiques, les éléments composés, sur les sous arbres et
nombre de feuilles).
3.2. Les approches basées sur les instances ou ontologies
Cette autre catégorie d'algorithmes travaille plutôt sur les instances[19][20] ou bien encore
sur les ontologies [21][22]. Par ailleurs, il existe également [nom] frameworks comme COMA[6] ou
COMA++ [23] qui utilisent plusieurs algorithmes avec [nom] techniques différentes. Les schémas sont
13
Première Partie – État de l’art · INSAT
traduits dans [nom] graphes acycliques traités simultanément par ces algorithmes. Les résultats
intermédiaires peuvent être utilisés avec [nom] possibilités de sélection et agrégation. L'utilisateur d'un
tel outil reste néanmoins un exercice difficile pour un utilisateur non averti.
- EX-SMAL [7] (EDI/XML semi-automatic Schema Matching Algorithm)
Le Matching dans EXSMAL est un processus qui permet la découverte [nom] relations
sémantiques entre deux schémas XML, il prend deux schémas de données en entrée et retourne à la
fin [nom] valeurs de similarités sémantiques entre les éléments [nom] schémas en entrée.
L ‘algorithme de Matching EX-SMAL (EDI/XML semi-automatic Schema Matching Algorithm)
permet de découvrir, donc, semi-automatiquement les correspondances entre les messages EDI
(Echange de données informatisées) basées sur les schémas XML. La compatibilité entre deux
messages de deux standards différents repose sur la sémantique de ces deux messages.
L'algorithme génère [nom] relations de Matching entre les noeuds [nom] schémas XML dont la
cardinalité varie entre 1-1, 1-n, n-m.
Il traite la structure de chaque élément à faire correspondre afin de raffiner l’efficacité de résultat. Il
se base sur la similarité de base entre les éléments individuels, en s’appuyant sur les descriptions
textuelles et les types de données [nom] éléments [nom] guides d’utilisations, spécifié à l’aide de
schémas XML, et la similarité de structure [nom] éléments en comparant les voisinages structurels [nom]
éléments de messages en entrée. Les deux similarités sont utilisées pour calculer la similarité finale
entre chaque paire d’éléments et cette dernière est enfin filtrée afin d’obtenir le résultat final de
Matching.
Etant donné un schéma XML considéré comme structure de données interne, l’algorithme
travaillera avec une structure arborescente. L’algorithme se déroule en trois étapes qui sont décrites
dans la figure 1. Il consiste à calculer la similarité entre tous les éléments de deux schémas, pour
chaque paire d’éléments, on calculera d’abord la similarité de base qui tient compte [nom] données
qu'un élément de schéma possède individuellement soit la description textuelle et le type de
données. Ensuite, la similarité de structure, qui se base sur le calcul de leurs contextes et le calcul de
similarité de base de chaque élément dans les deux schémas. Puis, utiliser les valeurs de ces deux
similarités pour calculer la valeur de similarité finale entre ces paires.
14
Première Partie – État de l’art · INSAT
Figure 1 Description brève de l'algorithme
Dans ce chapitre, nous avons défini différentes catégories d'algorithmes de Matching.
Le but de ces algorithmes est la mesure de similarité linguistique et structurelle entre les éléments,
cette similarité est exprimée par un coefficient entre 0 et 1. Quant à la transformation [nom]
documents XML, nous avons besoin [nom] opérations de transformations qui ne se basent pas sur les
valeurs numériques mais sur les relations sémantiques entre les entités de schémas. Nous décrivons,
dans le chapitre qui suit, les différents modèles d'expressions de mappage.
15
Première Partie – État de l’art · INSAT
Chapitre 3 Etat de l'art sur les modèles de mappage
Si le Matching consiste à trouver les relations entre [nom] entités avec un certain coefficient
qui indique qu'elles sont plus ou moins similaires, le Mapping consiste à trouver la vraie relation
sémantique qui permettra le passage de l'un à l'autre.
Les Mappings sont [nom] expressions décrivant le moyen dont les instances du schéma cible sont
dérivées à partir [nom] instances [nom] sources. Les Mappings sont définis en utilisant les
correspondances existantes entre les schémas. Quand les Mappings sont définis entre le schéma
cible et le schéma source, cela consiste essentiellement dans la restructuration [nom] données d'une
présentation à une autre. La définition de ces Mappings est aussi connue comme l'échange [nom]
données, la transformation [nom] données et la migration [nom] données. Le Mapping peut être plus
complexe: le Mapping ne transforme pas seulement la donnée source d'une structure à une autre
mais peut également combiner différentes sources. Plusieurs problèmes sont à soulever:
- Trouver tous les éléments sources correspondants à l'élément cible,
- Combiner les instances [nom] éléments source pour former les instances du schéma cible,
- Satisfaire la structure du schéma et les contraintes de cardinalité du schéma cible.
Résoudre ces problèmes requiert une compréhension profonde non seulement de la sémantique [nom]
schémas sources mais aussi [nom] liens sémantiques entre les schémas sources et cibles. La
complexité de ce processus augmente quand le nombre de données sources est élevé. Si les schémas
sources et cibles sont en format XML, la définition du Mapping devient plus complexe à cause de la
nature hiérarchique [nom] données [9].
Ceci revient à [nom] problèmes de cardinalité de Mapping qui peuvent être classés en deux catégories.
La première catégorie est le Mapping direct qui correspond à une cardinalité de Mapping (1:1). Ce
type de cardinalité est le plus étudié dans les approches existantes à cause de la difficulté pour
déterminer automatiquement les expressions de mappage. La seconde catégorie est le Mapping
indirect qui couvre les cardinalités de type (1:n), (n:1) et (n:m) qui signifie qu'il peut y avoir n
16
Première Partie – État de l’art · INSAT
éléments d'un schéma et m éléments d'un autre schéma qui correspondent [10].
De là vient le besoin de définir un processus de découverte d'expressions de mappage après le
Matching consistant à trouver une expression (logique, mathématique, opération sur les chaînes de
caractères, etc) permettant d'associer un ensemble d'éléments du schéma source pour obtenir un
élément du schéma cible (ex: name=FirstName CONCAT lastName), pour la découverte
d'expressions de mappage [2]. Les expressions de mappage sont requises pour exprimer comment
les éléments matchés (mis en correspondance) peuvent être mappés (transformés).
Plusieurs modèles ont été proposés pour exprimer les expressions de mappage offrant [nom]
opérations de transformations qui sont données par les relations sémantiques telles que (équivalent,
plus général, incompatible, compose, est composé de,…).
- Modèles de découverte [nom] expressions de mappage
2.1 Value Correspondences
L'approche présentée dans [11] crée un Mapping interactif basé sur les valeurs de correspondances
qui montrent comment la valeur d'un attribut cible peut être créée à partir d'un ensemble de valeurs
d'attributs sources. Les expressions de mappage sont étudiées comme [nom] valeurs de
correspondances.
La valeur de correspondances est une paire qui consiste en:
- Une fonction définissant comment une valeur (ou une combinaison de valeurs) de la base de données source peut être utilisée pour former une valeur dans la cible.
- Un filtre indiquant quelles valeurs sources doivent être utilisées.
Les valeurs de correspondances peuvent être entrées par un utilisateur ou peuvent être suggérées
utilisant [nom] techniques linguistiques appliquées aux données et méta-données comme les noms [nom]
composants de schémas.
Le modèle d'expression de mappage dans [11] est défini comme suit:
Équation 1 Modèle d'expression de Mappage dans Miller et al
- Fi: la fonction de correspondance dénotant la valeur de substitution
- Pi : un filtre
17
Première Partie – État de l’art · INSAT
L’implémentation de cette approche est un outil semi-automatique Clio pour la création de schémas
de Mappings. Il emploie un Mapping qui dépend de l’utilisation [nom] valeurs de correspondances
décrivant quelle valeur de l’attribut cible peut être créée par un ensemble de valeurs d’attributs
source. Clio utilise un raisonnement autour [nom] requêtes à créer, manager et classer les Mappings
possibles. Cependant, le choix final [nom] Mappings revient à l’utilisateur qui doit comprendre la
sémantique de l’application cible [12].
L'inconvénient de ce prototype est qu'il ne résout pas le Mapping conditionnel, le Mapping avec
rupture de clés et le Mapping simple.
2.2 Le Modèle d'expression de Mappage [1]
Un modèle d'expressions de mappage a été proposé dans [1]. Ce modèle est une extension de
l'approche présentée dans le paragraphe précédent du fait qu'il rajoute [nom] conditions et effectue un
filtrage par rapport à la cible. Cette approche sert à définir les expressions de mappage entre les
éléments similaires. L'idée [nom] valeurs de correspondances de Clio est similaire aux expressions
mappage. Il définit dans les méta-données les mappages entre les éléments de schéma source et
schéma cible.
Équation 2 Modèle d'expression de Mappage
Il couvre, par ailleurs, différents types d'expression de mappage :
- Décomposition/concaténation: la valeur du champ est établie par décomposition de la valeur de la source et par sa concaténation avec d'autres valeurs.
- Opérations arithmétiques avec [nom] données multiples: Dans ce cas, une fonction arithmétique est définie. Cette fonction calcule la valeur du résultat du champ cible.
- Mapping conditionnel: Parfois la valeur du champ cible dépend de la valeur d'un autre champ.
- Mapping avec décomposition de la clé: La représentation sur rang dépend de la valeur
18
Première Partie – État de l’art · INSAT
du champ.
- Mapping utilisant une table de correspondances avec [nom] colonnes multiples: La valeur du champ cible est une fonction utilisant plusieurs valeurs dans la table de conversion.
Il permet aussi d'exprimer sans difficulté les quatre catégories de traduction : La traduction simple
(1:1), la traduction avec découpage (1:n), la traduction avec groupement (n:1) et la traduction avec
découpage et groupement (n:m). Ces traductions ont été utilisées dans le cas de messages de type
EDI.
Ce modèle couvre, donc, · différents · types d'expressions de mappages, les différents cas de
traduction, Il est applicable sur un Mapping entre les entités et non pas entre les schémas et permet
de couvrir [nom] cas utiles de génération d'éléments cibles à partir de fonctions de Mapping.
2.3 Le Modèle de données LIMXS
Le modèle LIMXS [8] (Layered Interoperability Model for XML Schemas) offre une vue
sémantique et une vue logique [nom] schémas XML basée sur la modélisation conceptuelle.
La vue sémantique, décrite en terme de concepts et relations sémantiques, donne une définition explicite et formelle [nom] éléments [nom] schémas sémantiques et significations qui
nous permettent de mapper selon le sens [nom] éléments [nom] schémas et non pas seulement
leurs labels.
Deux phases sont adaptées:
- L'analyse linguistique qui correspond au niveau concept : Elle définit [nom] relations sémantiques entre les concepts. Cinq types de relations sémantiques sont considérés: équivalent, général, spécifique, compatible et incompatible.
- L'analyse structurelle qui correspond au niveau structure: Le but est d'étendre les relations sémantiques découvertes par les analyses linguistiques par l'examen de l'organisation [nom] données fournies par les vues sémantiques. L'organisation [nom] données est décrite à travers les relations d'agrégation (composition de relations entre deux concepts), association
(relation sémantique entre deux concepts qui sont conceptuellement au même niveau),
généralisation (relation entre un concept général C1 et un concept plus spécifique C2) et
contraintes (ensemble de contraintes sur les concepts et les relations).
La vue logique décrit les schémas construits indépendamment [nom] détails syntaxiques et nous permet de représenter le Matching à un niveau logique.
19
Première Partie – État de l’art · INSAT
Ce modèle se base donc sur un ensemble d'opérations de transformations sur les entités [nom]
schémas qui peuvent être composés ensemble pour représenter plus de transformations (les
opérations conceptuelles primitives, opérations logiques).
- Les opérations conceptuelles primitives:
- Add: ajoute une entité au schéma cible, l'entité peut être une relation, un concept, une propriété.
- Merge: fusion de deux entités en une seule entité: concaténation.
- Split: c'est l'opération inverse de Merge.
- Rename: change le nom d'un concept ou d'une propriété
- Connect: il s'agit d'un Mapping 1-1 qui relie deux entités équivalentes sans aucune transformation
- . Les opérations logiques:
Les opérations logiques traitent les différences dans les contraintes [nom] schémas comme la
cardinalité, les valeurs nulles ou par défaut mais peuvent être une information supplémentaire que
seul l'utilisateur peut fournir.
< Mapping ID = “map1 “>
<SourceSchema source = “S1.xsd”/> · <ManyToOneMapping ID = “map111” >
<TargetSchema target = “S3.xsd”/> · <AttributeMapping>
<HasMappings OneToOneMapping ID = “map11”/> · <SourceAttribute Attribute = “FirstName”/>
</Mapping> · <SourceAttribute Attribute = “LastName”/>
<TargetAttribute Attribute = “Name”/>
< OneToOneMapping ID = “map11” > · <Transformation>
<ConceptMapping> · <Operation name =”merge”/>
<SourceConcept concept = “Staff”/> · </Transformation>
<TargetConcept concept = “Employee”/> · </AttributeMapping>
<Transformation> · </ ManyToOneMapping >
<HasMappings OneTomany Mapping ID = “map111”/>
<Operation name =”rename”/>
</Transformation>
</ConceptMapping>
</OneToOneMapping>
Tableau 1 Exemple de représentation de LIMXS en XML
20
Première Partie – État de l’art · INSAT
Avantages: Ce modèle est capable de: Modéliser tous les facteurs de schémas XML tels que la
spécialisation/généralisation [nom] relations, espaces de noms,etc...
- Offrir les deux vues sémantique et logique [nom] schémas XML
- Réaliser le Mapping entre les entités [nom] schémas.
Inconvénients:
Ce modèle traite deux types de cardinalités correspondants au
- Matching simple: correspond aux relations de Matching 1-1 entre un noeud source et un noeud cible. On peut utiliser [nom] opérations simples comme Connect dans ces cas.
- Matching complexe: correspond aux relations de Matching 1-n et n-1 entre un noeud source et un noeud cible. Pour ce type de Matching, on utilise les opérations de transformation comme Merge et Split.
Mais il ne traite pas le cas de la cardinalité n-m.
2.4 Le modèle XHS (Intégration via l'HYPERSCHEMA XML)
L'hyperschéma XML (noté XHS) est constitué de l'ensemble [nom] schémas [nom] BDs sous
forme XSD étendu et de l'ensemble [nom] opérateurs de transformation d'un schéma à un autre sous
forme XSL. L'approche proposée dans [24] permet de fournir un modèle d'intégration capable de
fédérer les différentes sources de données hétérogènes représentant [nom] dimensions structurelle et
sémantique [nom] schémas sources. L'approche s'appuie sur un modèle semi structuré (XML) qui
permet une intégration aisée de modèles variés ainsi que sur deux parties distinctes à savoir :
- Le module d'extraction de schémas sources qui homogénéise la représentation [nom] différents schémas sources à intégrer en l'exprimant sous forme d'une définition de schémas XML.
- Le module d'intégration permettant de construire l'hyperschéma qui constitue l'ensemble [nom] schémas XML étendus (EXSi) et l'ensemble [nom] schémas XSL stipulant [nom] règles de transformation entre les entités [nom] EXS. Le schéma XML étendu est composé de trois types d'entités:
Concept(c): engendre [nom] propriétés et/ou d'autres concepts imbriqué, et porte [nom] relations.
Relation(r): correspond aux associations structurelles et/ou sémantiques existantes entre
21
Première Partie – État de l’art · INSAT
deux ou plusieurs concepts.
Propriété (p): peut être incluse dans [nom] concepts ou relations.
Le schéma EXS est donc défini par le triplet <concepts, relations, propriétés> illustré dans la
figure2 :
- c i est le concept nommé C de type <Cconcept>
- r(c i ....c j ) est la relation existante entre deux ou plusieurs concepts c i ....c j · nommé « c i ....c j RelationShip » qui possède une catégorie prédéfinie et inclut les concepts en question.
- P ki est la k ème propriété nommée p du concept c i , elle possède un domaine de définition et
[nom] contraintes (valeur par défaut, obligatoire,etc).
Figure 2 EXS représentant le concept personne
A l'issue de cette étape, six opérateurs de base seront appliqués d'un schéma EXS à un autre lors [nom]
appels aux primitives de transformations qui correspondent aux morphismes entre deux entités du
même domaine afin de réaliser le Mapping entre les différents éléments:
- Addition (add): permet d'ajouter une entité (concept, propriété d'un concept ou relation existante entre concepts) au schéma source.
22
Première Partie – État de l’art · INSAT
- Suppression (delete): permet de supprimer une ou plusieurs entités lors du processus de mises en correspondance (Matching) entre le schéma source et cible ( ( EXSsource → EXScible). La suppression est l'opérateur inverse de l'ajout.
- Fusion (merge): permet de fusionner deux entités distinctes en une entité atomique afin de regrouper [nom] propriétés appartenant au schéma source en un concept dans le schéma cible.
- Eclatement (split): permet la décomposition d'une entité du schéma source en un ensemble d'entités équivalentes dans le schéma cible. C'est l'opérateur inverse de merge.
2.5 Model Management System
Dans cette approche, les opérateurs sont génériques et sont appliqués aux schémas (nommés
modèles) et non aux éléments [nom] schémas.
Selon [13], l’implémentation [nom] applications revient à traduire les modèles de données en [nom]
représentations orientées objets et manipuler les modèles et les Mappings dans ces représentations.
La manipulation inclut la conception du Mapping entre les modèles, la génération d'un modèle à
partir d'un autre à l'aide d'un Mapping entre eux, la modification du modèle ou Mapping,
l'interprétation du Mapping et la génération du code du Mapping.
L'implémentation [nom] ces abstractions et opérateurs s'appelle MMS:Model Management System
dans lequel les modèles et Mappings sont [nom] structures syntaxiques mais n' ayant pas de
sémantique basée sur les contraintes de langages ou langages de requêtes.
Les principaux opérateurs du système de gestion de modèles MMS:
- Match: prend deux modèles comme entrée et retourne un Mapping entre eux.
- Compose: saisit un Mapping entre les modèles A et B et un Mapping entre les modèles B et C et retourne un Mapping entre A et C.
- Diff: saisit un modèle A et un Mapping entre A et un certain modèle B et retourne un sous-modèle de A qui ne participe pas au Mapping.
- ModelGen: saisit le modèle A et retourne un nouveau modèle B basé sur A et
Mapping entre A et B.
- Merge: saisit deux modèles A et B et un Mapping entre eux et retourne une union C de A et B avec Mapping entre C et A et C et B.
23
Première Partie – État de l’art · INSAT
L'expression suivante est un exemple de formalisation de ce modèle:
Équation 3 Formalisation du modèle
Inconvénients:
Cette approche est basée sur un Mapping entre les modèles (ou schémas) et non sur les éléments.
2.6 TUPELO
TUPELO [26] est un système de Mapping de données, qui permet la découverte [nom]
expressions de mappage complexes. Ce système utilise un langage de transformation nommé L qui
inclut [nom] opérateurs pour surmonter l'hétérogénéité structurelle entre les données sources
relationnelles. Le système prend en entrée les schémas source/cible et les instances source/cible
référencées comme étant [nom] instances critiques. Ces instances critiques illustrent la même
information sur les deux schémas et sont utilisées pour guider la découverte [nom] Mappings de
données. La découverte [nom] expressions de mappage est traitée comme une séquence
d'acheminement d'exploration de l'espace de transformation [nom] opérateurs dans le langage L sur
l'instance source. Dans l'implémentation du système, ils utilisent [nom] variations d'heuristiques pour
découvrir la séquence de transformations qui mappent la source à la cible. L'expression de mappage
découverte est retournée par le système.
Le problème de Mapping [nom] données est défini comme suit:
Etant donnée une source S et un schéma cible T et un langage de transformation approprié L ,
trouver un Mapping iЄL tel que pour chaque instance [nom] une instance correspondante t de T,
i(s)=t.
La nouveauté de ce système est la génération de Mapping pour [nom] Matchings de schémas simples,
il ne génère cependant pas les Mappings de données qui incluent les transformations sémantiques
complexes.
24
Première Partie – État de l’art · INSAT
Le modèle est exprimé dans un modèle mathématique:
Équation 4 Modèle mathématique
- λ: un opérateur
- A= <A 1 ....A n > : un attribut
- B: un attribut
- R: relation
- f: fonction de Mapping
- Synthèse [nom] expressions de mappage
Dans ce chapitre, nous nous sommes particulièrement intéressés au Mapping [nom] schémas.
Nous avons vu que Clio par exemple est présenté comme un outil semi automatique de Mapping où
les correspondances sont supposées déjà identifiées et exprimées dans un langage de logique de
premier ordre. Ce que l'on note c'est que les plateformes de Matching ne sont pas forcément
complétées pour le Mapping et avec [nom] études de cas pour [nom] processus d'interopérabilité. Nous
allons donc étudier, dans le chapitre suivant, quelques outils et plateformes de Mappings, discuter
leurs avantages, leurs lacunes et effectuer un comparatif de ces outils.
25
Première Partie – État de l’art · INSAT
Chapitre 4 Etat de l'art sur les outils de Mapping
Il existe sur le marché [nom] plateformes de Mapping, [nom] plateformes pour le Matching issues de
travaux de recherche et peu de plateformes incluant les deux processus. Nous allons dans ce qui
suit, donner un aperçu de la première catégorie de plateformes.
- Les plateformes et Outils de Mapping
2.1 Altova MapForce
MapForce est un produit de Altova mais aussi un outil de Mapping visuel puissant, travaillant
avec [nom] fichiers XML, [nom] bases de données, [nom] fichiers plats, [nom] données EDI, permettant de
développer [nom] outils personnalisés d'intégration de données. Il permet, ainsi, de bâtir [nom]
passerelles entre différents types de données afin d’assurer leur échange sous [nom] formats
hétérogènes pour fournir une interconnexion efficace entre tous les systèmes
MapForce se distingue par le fait qu’il offre la première implémentation de XSLT 2.0 et XPath
2.0. Il est aussi le premier outil du marché (et le seul) qui permet de générer le code de Mapping
sous divers formats XSLT 1.0, XSLT 2.0, XQuery, Java, C#, et C++ à partir d'une interface unique.
MapForce permet, en plus, de simplifier et d’accélérer les tâches d'intégration de données grâce à
une conception [nom] schémas de Mapping de façon visuelle et en automatisant les transformations.
En utilisant MapForce, on définit les Mappings entre [nom] modèles de contenu de façon visuelle juste
par drag and drop entre les éléments correspondants entre la source et la cible sur une interface
conviviale [27] (figure 3).
Il permet, aussi, de "mixer" plusieurs sources et plusieurs cibles pour permettre le Mapping à partir
de toutes les combinaisons de format possibles.
26
Première Partie – État de l’art · INSAT
De plus, MapForce étend la notion du Mapping au-delà de la gestion de 2 fichiers XML en offrant
la possibilité de gérer plusieurs fichiers qui ainsi connectés jouent parfois le rôle d’input et d’output
à la fois.
On peut aussi ajouter [nom] règles de traitement [nom] données. MapForce génère automatiquement le
code logiciel nécessaire pour mettre en place la transformation [nom] données sources vers les
données cibles. Le moteur MapForce intégré permet de pré visualiser le résultat de tout Mapping en
un seul clic, ce qui simplifie la conception et les tests de façon conséquente.
Figure 3 Mapping dans MapForce
Mapforce supporte les fonctionnalités suivantes:
- Construire [nom] services web à travers une surface graphique
- Faire du Mapping XML, base de données, fichiers et les sources EDI aux opérations [nom] services Web.
- Faire du Mapping pour toute combinaison de XML, base de données, fichiers et [nom] données
EDI à travers l’interface graphique.
- Générer automatiquement XSLT 1.0, XSLT 2.0, XQuery, Java, C++ ou C# pour implémenter les données de Mapping (XSLT et XQuery pour le Mapping XML-to-XML).
27
Première Partie – État de l’art · INSAT
- Exécuter, observer et sauvegarder les outputs [nom] transformations [nom] données de Mapping.
- Traitement et filtrage [nom] données à l’aide une riche bibliothèque de fonctions.
Limites :
- MapForce · ne permet pas d’éditer [nom] schémas directement. On est obligé d’utiliser différents éditeurs de schémas afin de rapporter [nom] modifications aux schémas puis rouvrir le schéma dans MapForce pour continuer le Mapping.
- Duplication du nœud cible lors d’un Mapping de plusieurs nœuds vers un seul.
2.2 Schema Mapper
SchemaMapper est un nouvel outil, un prototype intelligent de Mapping de schémas. Sa première
motivation provient de ETANA-DL qui est une librairie digitale pour promouvoir l’intégration de
l’information et [nom] services de divers sites archéologiques. C’est le premier outil qui offre une
représentation visuelle de schémas de Mapping en arbres hyperboliques pour donner une meilleure
vue afin de percevoir plus de détails sur l’écran. Ce qui est utile surtout pour les schémas à grande
échelle en permettant une navigation plus facile et moins de confusions [5].
Son architecture est divisée en quatre composants:
- Composant de Visualisation : Responsable de toutes les fonctions reliées à la visualisation du processus entier de Mapping.
- Composant de Recommandation : Responsable de donner [nom] recommandations données à l’utilisateur pour indiquer le Matching possible pour un nœud local spécial.
- Composant de Mapping : Responsable de faire [nom] Mappings. [nom] l’établissement du Mapping entre deux nœuds, ce composant sauvegarde les informations dans les structures de données.
- Composant de génération XML : [nom] que le Mapping est réalisé, ce composant crée une feuille de style XSLT sur le Mapping courant déjà stocké dans le composant de Mapping.
Pour réaliser le Mapping de nœuds (figure 4), il faut sélectionner le schéma local du nœud à mapper
et faire un simple clic droit sur le schéma global du nœud vers lequel on veut réaliser le Mapping.
Une fois mappé, la couleur [nom] nœuds mappés change en pourpre et le Mapping sera enregistré
28
Première Partie – État de l’art · INSAT
dans la table de Mapping (qui se situe dans le coin gauche de l’interface graphique). Le processus
de Mapping dans SchemaMapper est soumis à un ensemble de règles telles que seules les feuilles
de nœuds peuvent être mappées directement vers d’autres mais aussi la feuille du nœud non locale
ne peut pas être mappée à la feuille du nœud global.
Figure 4 Mapping [nom] noeuds
Cet outil a pour avantage d’éviter l’approche de line-drawing pour indiquer le Mapping. Il offre de
ce fait une architecture flexible qui permet une extensibilité pour [nom] fonctions supplémentaires. Il
utilise aussi la notion de coloration pour distinguer entres les différents types [nom] nœuds [nom]
schémas (root, leaf, non-leaf, selected, recommended, et mapped) et permet de renommer,
supprimer un nœud et ajouter un schéma local sub-tree dans le schéma global. Il permet d’éditer les
schémas dans le même outil.
Limites:
- Cet outil se limite à un Mapping de schémas XML à XML. En effet, il ne supporte pas
[nom] Mappings de schémas de base de données de même que le Mapping [nom] schémas de
méta données.
29
Première Partie – État de l’art · INSAT
- Il manque d’options de génération de code.
- Il ne permet pas les Mappings complexes qui nécessitent [nom] opérateurs mathématiques.
- La vue [nom] arbres hyperboliques rend difficile la vue de toutes les recommandations en même temps.
2.3 Stylus Studio
C’est un produit commercial qui inclut un outil de Mapping visuel XML Schema Mapping qui
permet le Mapping visuel entre schéma source et schéma cible par un drag et drop et offre une
implémentation facile [nom] données XML impliquant de multiples sources de données et
personnalise les processus de données utilisant XSLT ou le code XQuery.
Il réalise le Mapping entre schémas XML mais aussi d’autres formats de données comme les DTD
(Document Type Definition), les instances de documents XML, les bases de données relationnelles
avec XML, les services web dans une interface graphique conviviale composée de deux parties :
une pour visualiser le Mapping et une autre pour visualiser le code source généré en XSLT ou
XQuery conforme au Mapping et qui peut être édité (Figure 5).
Il offre une vitesse de traitement [nom] données rapide en Input et en Output et · intègre un
environnement de développement XML. Il comprend entre autre un éditeur et un débogueur XSLT,
un outil de conception graphique de schémas XML, un composeur d'appel pour services web (Web
Services Call Composer) et un éditeur, débogueur et mapper XQuery [28].
Figure 5 Mapping dans Stylus Studio
30
Première Partie – État de l’art · INSAT
Limites:
- Il ne permet pas de mapper plusieurs schémas.
- Il génère uniquement le code XSLT et XQuery.
2.4 Visual XSLT
C’est un outil couplé avec Visual Studio .Net [32], ce qui lui procure une vaste palette de fonctions
lui permettant notamment de réaliser [nom] Mappings avec la technologie [nom] templates XSLT.
Il permet un Mapping visuel [nom] schémas et transforme [nom] documents XML par une interface drag
et drop. Le Mapping est réalisé à partir d’un schéma source vers un schéma cible en cliquant sur
l’élément ou l’attribut de la source et en tirant (dragging) vers l’élément ou l’attribut de la cible
(figure 6). Ce lien est indiqué par l’icône « mapper » dans fenêtre du schéma cible dans l’interface
graphique. Un nœud dans le schéma source peut être mappé vers plusieurs nœuds du schéma cible
et vice vers ça. Il fournit un traitement [nom] informations rapide, offre une facilité d’accès et est très
maniable.
Il offre en plus un debugging JIT (Just In Time) en testant le code XSLT placé dans d’autres
applications .Net ou d’autres librairies sans nécessiter d’une technologie spéciale ou d’un accès au
code source.
On peut aussi utiliser [nom] sources de données comme inputs ou outputs telles que [nom] documents
instance XML, [nom] schémas XML ou DTD, [nom] services Web afin de faire du Mapping de données
dynamiques générées de services web et [nom] Bases de données relationnelles.
Figure 6 Mapping dans Visual XSLT
31
Première Partie – État de l’art · INSAT
Limites:
- On ne peut mapper que vers un seul schéma cible.
- Ne permet pas la génération du code XQuery, java et autre
2.5 TIBCO XMLTransform
TIBCO XML Transform [33] est une solution de conception complète qui rassemble les
fonctionnalités de conception XML et permet de traiter [nom] documents de manière visuelle grâce à
la création et au déboguage [nom] feuilles de style XSLT (Extensible Stylesheet Language
Transformation). Il offre une interface utilisateur graphique pour l'édition de feuilles de style
XSLT qui utilise [nom] mappers simples à base de " glisser-déplacer " pour faciliter le codage [nom]
feuilles de style XSLT complexes. Ces feuilles de style peuvent être ensuite intégrées à un
environnement d'exécution (" runtime ") pour transformer en toute transparence [nom] documents et
[nom] messages XML. L'interface utilisateur de XML Transform fournit également plusieurs fenêtres
pour consulter et éditer le code source XSLT, les erreurs de transformation et les résumés [nom]
modèles XSLT, ce qui simplifie et facilite le processus de développement.
Le Mapping dans Tibco XML Transform est réalisé d’une manière visuelle par un drag et drop
entre schéma ou instance source et cible. Pour de meilleurs résultats, les Mapping drag et drop
doivent êtr
