3.3.3 Discussion
Le principal avantage des approches fondées sur les instances, telles qu’XSLT et XQuery, est qu’elles facilitent le développement de transformations simples, comme la transformation d’un document XML en un document HTML. Cependant, ces approches ne peuvent pas assurer la conformité des données manipulées par rapport à leur schéma. Pour contourner ce problème, certaines approches permettent de valider les données cibles générées en utilisant un schéma [W3C, 2007b]. Le fait de travailler au niveau des instances tout en voulant valider les données utilisées est sujet à erreur puisque cela mélange les instances et leur schéma. Les approches fondées sur les schémas ont pour but d’éviter ces problèmes.
3.4 Approches fondées sur les schémas
Les approches fondées sur les schémas considèrent le schéma des données comme l’élément central d’une manipulation de données. Elles permettent ainsi de manipuler les données sources et cibles conformément à leur schéma respectif.
1 s t a r t = element b l o g { a t t r i b u t e nom { t e x t } , 2 element b i l l e t s {element b i l l e t { B i l l e t }∗}} 3 B i l l e t = a t t r i b u t e num { xsd : i n t e g e r } , 4 element t i t r e { t e x t } , 5 element c o n t e n u { t e x t } , 6 element d a t e { t e x t } , 7 element a u t e u r { t e x t }
Fig. 3.7: Le schéma du blog de la figure 3.4a
La figure 3.7 présente le schéma du blog représenté en Relax NG Compact [OASIS, 2002]. La ligne 1 définit l’élément blog comme la racine du schéma, sachant qu’un blog est composé d’un nom (ligne 1) et d’un ensemble de billets (de la ligne 3 à 7). Le schéma SVG est disponible sur le site du W3C2.
Les approches fondées sur les schémas utilisent soit directement des types correspondant à la structure des données dans les transformations, soit une correspondance de schémas à partir de laquelle une transformation peut être générée.
3.4.1 Les langages de transformation typés
Certains langages de transformation considèrent le schéma comme un ensemble de types directement utilisables dans une transformation ; la conformité des données manipulées est ainsi naturellement garantie. On peut noter que les langages recensés sont des langages fonctionnels. Ce paradigme de programmation place les fonctions en tant qu’objets de première classe dont les calculs transforment les paramètres d’entrée en données de sortie [Hudak, 1989]. De plus, le
pattern matching permet la sélection des données d’entrées en fonction de critères. Ces
avan-tages ont motivé le développement de nombreux langages fonctionnels manipulant des données structurées ou semi-structurées.
2
1 module blogVersSVG {
2 const b l o g : [ XMLTree ] => [ XMLTree]= 3 pam x : [ XMLTree ] , y : [ XMLTree ]
4 var s : S t r i n g . ( ∗ ( x # [ ? b l o g ]++ ? x => [ | 5 b l o g # < l a b e l =%’b l o g ’ , a t t r =[{nom=?nomBlog } ] , sub=?s u b s> 6 => y+= [< l a b e l =’ s : svg ’ , 7 a t t r =[{ xmlns : s =’ h t t p : / /www. w3 . o r g / 2 0 0 0 / svg ’ } ] , 8 sub =[< l a b e l =’ s : g ’ , 9 a t t r =[{ f o n t −s i z e = ’ 2 4 ’ } , { f i l l = ’ # 0 0 0 0 0 0 ’ } ] , 10 sub =[< l a b e l =’ s : t e x t ’ , 11 a t t r =[{ x = ’ −280 ’} , { y = ’ 2 0 ’ } , { t e x t −a n c h o r =’ middle ’ } , 12 { t r a n s f o r m =’ r o t a t e ( − 9 0 ) ’ } ] , 13 sub =[ nomBlog ] > , 14 b i l l e t s ( s u b s ) ] > ] > ] | ] ) )
15 const b i l l e t s : [ XMLTree ] => [ XMLTree]= 16 pam x : [ XMLTree ] , y : [ XMLTree ]
17 var s : S t r i n g . ( ∗ ( x # [ ? b i l l e t ]++ ? x => [ | 18 b i l l e t # < l a b e l =%’ b i l l e t ’ , a t t r =[{num=?numBil } ] , 19 sub =[< l a b e l =%’ t i t r e ’ , sub=? t i t r e B i l >, 20 < l a b e l =%’c o n t e n u ’ , sub=? c o n t B i l >, 21 < l a b e l =%’a u t e u r ’ , sub=? a u t B i l >, 22 < l a b e l =%’d a t e ’ , sub=? d a t e B i l >]> 23 => y+= [< l a b e l =’ s : g ’ , a t t r s =[{ i d=numBil } ] , 24 sub =[< l a b e l =’ s : r e c t ’ , 25 a t t r =[{ y=(pos −1)∗260+30} ,{ x = ’ 4 0 ’ } , { f i l l =’#e 6 e 6 e 6 ’ } , 26 { w i d t h = ’ 6 3 0 ’ } , { h e i g h t = ’ 1 8 0 ’ } , { s t r o k e = ’#000000 ’}] > , 27 < l a b e l =’ s : t e x t ’ , sub =[ t i t r e B i l ] , 28 a t t r =[{ f o n t −w e i g h t =’ b o l d ’ } , { y=(pos −1)∗260+60} , { x = ’60 ’}] > 29 < l a b e l =’ s : t e x t ’ , sub =[ c o n t B i l ] , 30 a t t r =[{ y=(pos −1)∗260+125} ,{ x = ’ 5 5 ’ } ] > , 31 < l a b e l =’ s : t e x t ’ , sub =[ a u t B i l +’ − ’+ d a t e B i l , 32 a t t r =[{ f o n t −s t y l e =’ i t a l i c ’ } , { y = ’{( pos − 1 ) ∗ 2 6 0 + 1 9 5 } ’ } , 33 { x = ’ 6 2 0 ’ } , { t e x t −a n c h o r =’ end ’ } ] ] > ] > ] | ] ) ) }
Fig. 3.8: Transformation du blog en Circus
XDuce[Hosoya et Pierce, 2003] est un langage fonctionnel au typage statique manipulant des données XML. Ce langage possède un pattern matching puissant utilisant les opérations sur les arbres et les expressions régulières. Développé en parallèle à XDuce, CDuce3 est également un langage fonctionnel à typage statique pour XML [Benzaken et al., 2003; Frisch, 2004], partageant de nombreux principes avec XDuce comme son typage fort et son pattern matching. CDuce peut être vu comme une extension de XDuce permettant en plus l’utilisation d’itérateurs, la surcharge de fonctions et se voulant plus général (moins orienté XML). Dans le même registre, le langage OCaml+XDuce, fusion des langages XDuce et OCaml, combine les meilleures propriétés des deux langages [Frisch, 2006].
Circus est un langage typé spécialisé dans la transformation de structures s’adaptant à la manipulation de documents XML [Vion-Dury, 1999; Vion-Dury et al., 2002]. Il s’agit d’une extension du lambda-calcul typé non récursif rendant possible la définition de modules. La figure 3.8 présente un programme Circus de notre exemple dans lequel la définition des types a été volontairement omise. Ce programme Circus se compose d’une première méthode (ligne 2) créant le corps du document SVG. Cette méthode en appelle une seconde (ligne 15) qui construit la représentation SVG des billets du blog.
3
3.4 Approches fondées sur les schémas
Du fait de leur puissant pattern matching et de leur utilisation d’expressions régulières pour le traitement de données, ces langages ont tous la même capacité à réaliser des translations et des transformations de schémas.
3.4.2 Les approches fondées sur la correspondance de schémas
Les approches fondées sur la correspondance de schémas permettent d’établir des liens, appe-lés correspondances, entre des schémas sources et cibles. Ces approches diffèrent de celles fondées sur les instances : elles définissent des relations entre deux schémas et non un programme qui implémente ces relations. La spécification de correspondances est un paradigme utilisé originel-lement dans le domaine des bases de données et dont l’enjeu est double [Raffio et al., 2008; Roth et al., 2006] :
1. pouvoir générer, à partir d’une correspondance de schémas, des transformations dans dif-férents langages manipulant des données instances de ces schémas ;
2. capturer la relation entre des schémas pour faciliter la gestion des changements affectant des schémas.
Cette section se focalise sur la capacité des approches présentées à gérer le premier point puisque notre problématique concerne la manipulation de données et non l’évolution de schémas.
Clio est un outil IBM permettant la définition graphique de correspondances entre un schéma source et un schéma cible [Miller et al., 2000; Miller et al., 2001; Yan et al., 2001; Popa et al., 2002; Haas et al., 2005]. Ces correspondances sont enrichissables via un éditeur d’expressions (expressions arithmétiques par exemple). Clio génère des transformations XQuery, SQL ou XSLT à partir de correspondances de schémas.
La figure 3.9 présente l’interface de Clio lors de la définition de la correspondance entre le schéma de la figure 3.7, représenté dans la partie gauche, et celui de SVG dans la partie droite. Les correspondances sont établies entre les attributs des schémas. Dans notre exemple, la première correspondance concerne l’attribut nom de l’élément blog et un élément SVG text ; les autres concernent les éléments titre, contenu, date, auteur et num des billets, et des éléments SVG text. Chaque élément cible est défini soit par une correspondance, soit par une valeur fixe définie par le biais de l’éditeur d’expression (voir la fenêtre à gauche de la figure 3.9). La transformation d’un blog en un document SVG n’est pas réalisable avec Clio puisque certaines opérations impératives, comme l’itération, ne sont pas permises. Il est cependant possible de contourner ce problème en appelant directement les fonctions d’un langage de transformation
via l’éditeur d’expressions, comme l’illustre la figure 3.9 avec l’appel de la fonction XSLT count.
L’inconvénient de ce processus est la dépendance à un langage de transformation, ce qui contredit l’un des principes fondamentaux de la correspondance de schémas.
Influencé par Clio, Clip est un langage graphique réalisant le tracé de correspondances entre des éléments d’un schéma source et d’un autre cible [Raffio et al., 2008]. La différence entre ces deux approches est que Clip définit graphiquement la sémantique des correspondances. Le prin-cipal inconvénient de Clip est le même que la plupart des langages graphiques, à savoir le manque de lisibilité et donc de compréhension lorsque le nombre et la complexité des correspondances augmentent.
Fig. 3.9: Interface de Clio pour l’exemple du blog
3.4.3 Discussion
Les approches fondées sur les schémas répondent certainement le mieux au problème de la MDSI. En effet, ces approches garantissent la validité des données et demeurent indépendantes des processus de transformation ; les transformations peuvent ainsi être générées dans diffé-rents langages à partir d’une même correspondance de schémas. De plus, une correspondance de schémas peut être utilisée pour définir un lien durable entre des données sources et une pré-sentation, comme le détaille la section 3.6. L’utilisation du principe des correspondances permet également l’application d’opérations importantes sur des sources de données et leur schéma, comme le schema matching4 et le schema merging, visant notamment à simplifier la définition de correspondances.