La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

XML modèle logique de données contraintes dintégrité (opérateurs) Master 2 ème année recherche en informatique Université François-Rabelais Béatrice Bouchou.

Présentations similaires


Présentation au sujet: "XML modèle logique de données contraintes dintégrité (opérateurs) Master 2 ème année recherche en informatique Université François-Rabelais Béatrice Bouchou."— Transcription de la présentation:

1 XML modèle logique de données contraintes dintégrité (opérateurs) Master 2 ème année recherche en informatique Université François-Rabelais Béatrice Bouchou Outils pour la représentation, l'échange et la fouille de données volumineuses

2 Introduction Données XML ? => modèle logique de données, pour : Définir la structure des données => schémas (validation) Définir la sémantique des données => contraintes dintégrité Définir les opérations sur les données => requêtes et transformations

3 Plan Modèle logique de données XPath –syntaxe –modèles opérationnels (exécution des requêtes) Contraintes dintégrité –syntaxe(s) –vérification

4 Principales références (1) N. Klarlund, T. Schwentick, D. Suciu : "Model, Schemas, Types, Logics and Queries", in Logics for Emerging Applications of Databases, Springer, 2003Model, Schemas, Types, Logics and Queries C. Koch : "Efficient Processing of Expressive Node- Selecting Queries on XML Data in Secondary Storage: a Tree Automata-based Approach", Proc. of the 29 th VLDB Conference, Berlin, Germany, 2003Efficient Processing of Expressive Node- Selecting Queries on XML Data in Secondary Storage: a Tree Automata-based Approach Béatrice Bouchou, Mírian Halfeld Ferrari Alves and Martin Musicante Tree Automata to verify XML Constraints International Workshop on Web and Databases, San Diego, California, 2003ree Automata to verify XML Constraints

5 Principales références (2) F. Neven : "Automata, Logic and XML", sur la page de l'auteur J. Carme, J. Niehren, M. Tommasi : "Querying Unranked Trees with Stepwise Tree Automata", Proc. of the 15 th RTA Conference, Aachen, Germany, 2004Querying Unranked Trees with Stepwise Tree Automata J. Niehren, L. Planque, J.-M. Talbot, S. Tison : "N-ary Queries by Tree Automata ", 10th International Symposium on Database Programming Languages (DBPL), 2005N-ary Queries by Tree Automata

6 Modèle logique de données Structure de document XML = Arbre

7 Les nœuds dun arbre XML Sont chacun associés à un label (nom de lélément ou de lattribut) Ont un nombre quelconque (mais borné) de fils Possèdent chacun un identifiant unique Sont totalement ordonnés : –Ordre du document Peuvent être associés à un type (déclaré par un schéma, induit par un ensemble de chemins, ou alors découvert à partir dun ensemble de documents)

8 Identifiants de nœuds : exemple

9 Identifiants de nœuds : exemple

10 Identifiants de nœuds Les « positions » reflétant lordre préfixe sont utiles pour la modélisation des données et des opérations. MAIS elles sont sensibles aux mises à jour : les informations stockées en fonction des positions (par exemple des index) doivent être recalculées.

11 Exemple : document (Cahors)(2002)(25.00) data yearnamepriceyearname (Sancerre)(2000)(21.00) data (Sancerre)(2000)(Grilled Fish) data (30.00) data price wine drinks menu 02 restaurant root... combinations mealsdesserts combination wineNamewineYearmealNameprice

12 Exemple : keyTree (Cahors)(2002)(0201) (Sancerre)(2000)(0200) key target context (1)(3) … (0) (K1)(K1)

13 Exemple : modification Insertion of a new subtree rooted wine as first child of first node drinks: (Bordeaux)(1990)(30.00) data yearnameprice wine (Cahors)(2002)(25.00) data yearnamepriceyearname (Sancerre)(2000)(21.00) data price wine drinks

14 Exemple : mise-à-jour keyTree (Cahors)(2002)(0202) (Sancerre)(2000)(0201) key target context (1)(3) … keyTree (0) (K1)(K1) (Bordeaux)(0200) target (0) key (1990)

15 Identifiants persistants 2 ou 3 nombres par identifiant Maintien des informations structurelles Le nombre dinsertions et de suppressions possibles avant quune renumérotation globale soit calculée reste encore limité (à une trentaine dinsertions au même endroit, pour linstant). Une référence : A. Gabillon, M. Fansi : A Persistent Labelling Scheme for XML and Tree Databases. IEEE conf. on Signal and Image Technology and Internet based Systems. November 2005.

16 Ordre total, relation hiérarchique N1

17 Exercice Construire larbre du document contenant des recettes Conventions –Nœud racine (1 fils : 1 élément) –Valeurs (données) : éléments texte ou attributs –Attributs / éléments

18 Exercice Que pourrait-on avoir comme schema (DTD) ? Quel serait lautomate darbre correspondant ?

19 Précision Modèles daccès des API modèle logique de données –DOM => arbre ; chaque nœud est un objet qui a des méthodes pour accéder à ses fils, son père, ses attributs, ses frères, etc. Document entier potentiellement en mémoire –SAX => séquence dévénements ; chaque balise rencontrée est un événement. Lecture séquentielle du document Mais permet de parcourir lARBRE que représente le document (usage de piles)

20 Opérateurs Appliqués à des arbres ou des forêts Ceux qui modifient retournent des arbres ou des forêts Constructions darbres … Sélections de sous-arbres –Selon une structure donnée –Selon des valeurs données Selon une localisation (dans larbre) donnée.

21 XPath

22 XPath est un langage pour : –Désignation (Adressing) : utilisé en ce sens par XLink/XPointer et XSLT –Sélection par correspondance de motifs (Pattern matching) : utilisé en ce sens par XSLT et XQuery Il est déclaratif –Expressions –Résultat = séquence d'items (nœuds ou valeurs)

23 Modèle de données Xpath 2.0 Un nœud peut être de lune des « sortes » suivantes : La racine (root), un élément, un attribut, un texte, un commentaire, un namespace, une instruction Les nœuds texte et commentaire nont pas de label On appelle dom(t) lensemble des nœuds de larbre t

24 La syntaxe //Recette/Ustensiles/Ustensile/Item – Caquelon et réchaud Contextes : –éléments de label « Recette » à partir de la racine (//) –pour chaque élément Recette trouvé : ses éléments fils de label « Ustensiles » –pour chaque élément Ustensiles trouvé : ses éléments fils de label « Ustensile » –pour chaque élément Ustensile trouvé : ses éléments fils de label « Item »

25 Expressions de chemin Essentiellement, une SEQUENCE de « pas », séparés par des / (ou des //) child::Recette / descendant::Ingredient[position()=3] Chaque pas définit un groupe de nœuds, calculé dans le contexte du pas précédent Un pas a la forme complète suivante : axe :: test_de_nœud [ prédicat ] Par défaut (pas de précision) laxe est " child "

26 Les axes ForwardAxis ::= ("child" "::") | ("descendant" "::") | ("attribute" "::") | ("self" "::") | ("descendant-or-self" "::") | ("following-sibling" "::") | ("following" "::") | ("namespace" "::") ForwardAxis ReverseAxis ReverseAxis ::= ("parent" "::") | ("ancestor" "::") | ("preceding-sibling" "::") | ("preceding" "::") | ("ancestor-or-self" "::")

27 Les axes Se représentent par des relations binaires –Exp. self := { | x dom} Sexpriment tous* avec 2 relations primitives –firstchild (exp.,, …) –nextsibling (exp., …) –Notations : r, r -1, r1.r2, r* [ * Sauf : " attribute " et " namespace " –laxe attribute sélectionne les fils attributs –laxe namespace sélectionne les fils namespace ]

28 Exercice Décrire les axes suivants à laide des 2 relations primitives : –child –descendant –following sibling –parent

29 child := firstchild.nextsibling* descendant := firstchild.(firstchild nextsibling)* descendant-or-self := descendant self following-sibling := nextsibling.nextsibling* parent := (nextsibling -1 )*.firstchild -1 ancestor := (firstchild -1 nextsibling -1 )*.firstchild -1 ancestor-or-self := ancestor self preceding-sibling := (nextsibling -1 )*.nextsibling -1 following := ancestor-or-self.nextsibling.nextsibling*.descendant-or-self preceding := ancestor-or-self.nextsibling -1.(nextsibling -1 )*.descendant-or- self

30 Les tests de nœud Filtrent la séquence des nœuds sélectionnés par laxe, selon : –La sorte de nœud, : element, comment, node… –Le label, l Expressions de la forme : – () : node() => dom, text() => nœuds texte (retourne les textes) /Recette/Ustensiles/Ustensile/Item/text() => {caquelon, réchaud} – (l) : element(Item) => les nœuds qui sont des éléments et qui ont pour label Item

31 Les tests de nœud Type principal –Le test de nœud l est un raccourci pour (l) où est le type principal : c'est le type élément, sauf pour les axes " attribute " et " namespace " –Recette => raccourci pour child::Recette => raccourci pour child::element(Recette)

32 Les prédicats Filtrent la séquence N des nœuds sélectionnés par laxe et le test de nœud Pour chaque nœud n de la séquence N, l'expression (booléenne) est évaluée en fonction de : –n, le nœud contexte, –la taille de N, la taille de contexte, –le rang de n dans N, selon lordre du document, la position de contexte Les variables et les fonctions sont évaluées en fonction du contexte

33 Les prédicats Ingredient[attribute::quant>1][fn:position()=1] –le premier élément Ingredient qui a un attribut quant supérieur à 1 Ingredient[attribute::quant=1 and attribute::name!="kirsh"] //Ustensiles[Commentaire] –les éléments de label Ustensiles qui ont un élément fils de label Commentaire //Instructions/Etape[fn:position() = fn:last()-1] –l'avant dernier élément de label Etape fils d'un élément de label Instructions Peuvent être imbriqués

34 Les prédicats //Recettes/Ustensiles/Ustensile[Commentaire]/Item –les nœuds de labels Item qui sont fils d'un nœud de label Ustensile ayant un fils de label Commentaire Les expressions contenant des prédicats s'interprètent en 2 temps : –d'abord considérer l'expression SANS les prédicats => séquence de nœuds (ou de valeurs), ET séquence de chemins qui y mènent –ensuite ne retenir dans ces ensembles que les chemins qui satisfont les prédicats

35 Autres expressions de XPath 2.0… expressions arithmétiques expressions de comparaison expressions logiques (and, or, not) expression conditionnelles (if…) expression constructrices : for… in… return très nombreuses fonctions :

36 Exercices Quels sont les ustensiles de la première recette ? Quelles sont les étapes des recettes dont le nom contient « fondue » ? Quelles sont les recettes contenant du fromage ?

37 Modèle dexécution XML processing and specially query languages are founded upon tree automata, tree transducers, and logics on trees. Selecting Tree Automata Stepwise Tree Automata [K-pebble Tree Transducer]

38 Intérêts des modèles Pourquoi des modèles théoriques (logiques, grammaires, automates) ? – pour évaluer, comparer les pouvoirs d'expression des langages de requête – pour mettre au point des outils d'exécution efficaces

39 Calcul daxes => automate à états finis (Q,,, q 0, F) //Recette/Ustensiles/Ustensile/Item Parcours dans l'ordre du document (streaming) –> Pile d'états Premières approches : FSA e4e4 Item e3e3 Ustensile e2e2 Ustensiles e1e1 Recette e0e0 !Recette

40 Exemple e0e0 e0e0 e1e1 e4e4 Item e3e3 Ustensile e2e2 Ustensiles e1e1 Recette e0e0 !Recette Recette Root n 0 n 1 Recettes n 2

41 Exemple e0e0 e1e1 e4e4 Item e3e3 Ustensile e2e2 Ustensiles e1e1 Recette e0e0 !Recette Recette Root n 0 n3n3 n 1 Recettes

42 Exemple e0e0 e1e1 e2e2 e4e4 Item e3e3 Ustensile e2e2 Ustensiles e1e1 Recette e0e0 !Recette Recettes Root n 0 n 1 Ustensiles n 9 …

43 Exemple e0e0 e1e1 e2e2 Ustensile e3e3 e4e4 Final ajouter n 11 au résultat e4e4 Item e3e3 Ustensile e2e2 Ustensiles e1e1 Recette e0e0 !Recette Recettes Ustensiles n 10 Item n 11 Root n 0 n 1 n 9 …

44 Automate d'arbre Approche précédente = implémentation séquentielle d'un automate d'arbre top down déterministe (Q,,, q 0, F) Q = {q 0, q 1, q 2, q 3, q 4, q f } = {labels de l'arbre} F = {q f } = {Root q 0 ; X Recette : X, q 0 q 0 ; Recette, q 0 q 1 ; Ustensiles, q 1 q 2 ; Ustensile, q 2 q 3 ; Item, q 3 q f ; // à sélectionner (X, q) {(Recette, q 0 ), (Ustensiles, q 1 ), (Ustensile, q 2 ), (Item, q 3 )} : X, e q 4 }

45 Illustration Root q 0

46 Illustration X Recette : X, q 0 q 0

47 Recette, q 0 q 1

48 Exemple Ustensiles, q 1 q 2 (X, q) {(Recette, q 0 ), (Ustensiles, q 1 ), (Ustensile, q 2 ), (Item, q 3 )} : X, e q 4

49 Exemple

50 Limitation premières approches Expressivité des requêtes –Limitées aux calculs daxes En augmentant le pouvoir d'expression, les performances chutent –Chaque nœud est visité un nombre exponentiel de fois (/ taille de la requête) dans le pire des cas Expressivité des automates d'arbres (bottom-up, déterministes ou non) => ensemble des langages réguliers d'arbres (= MSO Logic).

51 Bémol Barbara Fila et Siva Anantharaman (LIFO) proposent des FSA capables de calculer des requêtes positives en Core XPath : –Transforment les requêtes vers une forme particulière : cf. exemple (17 à 19) –Un automate par axe –Intersection : cf. exemple (25 à 29) Complexité comparable aux STA

52 Selecting Tree Automata (STA) Automate d'arbre bottom-up non déterministe, plus un ensemble S d'états de sélection A = (Q,,, F, S) : ((Q { }) x (Q { }) x ) 2 Q ( dénote l'absence de fils)

53 Selecting Tree Automata (STA) Cet automate est défini pour des arbres binaires La requête représentée par le STA A associe un arbre T à l'ensemble des nœuds appartenant au résultat : A(T) = {n dom(T) | r(n) S pour toute exécution valide r de A sur T}

54 Arité des arbres Arité = le nombre maximum de fils pour chaque noeud La théorie des automates d'arbres s'est développée sur des arbres d'arité fixe (ranked trees) Un document XML est un arbre d'arité quelconque (unranked tree) Deux voies : –Étendre les définitions à ce cas de figure (exemple : l'automate de validation présenté au cours précédent) –Transformer les arbres d'arité quelconque en arbres binaires

55 Une transformation en arbre binaire premier fils => fils gauche ; frère droit => fils droit n1 n2n5n3 n4 n1 n2 n5 n4 n3

56 Calcul dune requête en 2 phases L'exécution de l'automate non déterministe associe à chaque nœud un ensemble d'états Il peut y avoir dans cet ensemble un état qui ne permet pas d'associer un état final à la racine Solution : 2 phases déterministes –bottom-up : calcule les états potentiels de chaque nœud –top-down : sélectionne parmi ces états ceux qui correspondent à une exécution réussie (ie une exécution qui associe un état final à la racine)

57 Complexité Consommation mémoire minimale (le premier automate écrit sur disque) Une fois construits les 2 automates qui correspondent à la requête (construction linéaire sur la taille de la requête), l'évaluation de la requête est linéaire en fonction de la taille du document (avec une constante petite).

58 Expressivité –Tous les axes de Xpath –"branchements" complexes avec des combinaisons booléennes dans les conditions –Tests numériques, par exemple : sélectionner les recettes qui ont moins de 3 étapes et un nombre impair d'ingrédients… –En fait, toute requête de sélection de nœuds exprimable dans la logique du second-ordre monadique (MS : seulement des relations unaires) = toute requête calculable avec une quantité bornée de mémoire

59 Construction des 2 automates L'ensemble d'états associés par un STA à un nœud peut être représenté par un (petit) programme logique P, exprimé dans une forme restreinte (monadique) de Datalog un de ces prédicats = le "prédicat requête" Résultat de la requête = ensemble des nœuds qui vérifient le prédicat requête

60 Programme logique représentant une requête L'arbre (binaire) est décrit par des prédicats, par exemple : –Root(x) : le nœud racine vérifie ce prédicat –HasFirstChild(x) : le nœud x vérifie ce prédicat s'il a un fils gauche Leaf(x) : le nœud x vérifie ce prédicat s'il na pas de fils gauche –HasSecondChild(x) : le nœud x vérifie ce prédicat s'il a un fils droit ; LastSibling(x) : le nœud x vérifie ce prédicat sil na pas de fils droit –Label[l](x) : le nœud x vérifie ce prédicat s'il a pour label l –FirstChild(x,y) : les nœuds x et y vérifient ce prédicat si y est le fils gauche de x –SecondChild(x,y) : les nœuds x et y vérifient ce prédicat si y est le fils droit de x ; NextSibling(x, y) les nœuds x et y vérifient ce prédicat si y est le frère droit de x

61 Programme logique représentant une requête Forme des règles représentant une requête : –P(x) U(x) –P(x) P 0 (x 0 ) B(x 0,x) –P(x 0 ) P 0 (x) B(x 0,x) –P(x) P 1 (x) P 2 (x) P, P i : têtes de règles unaires (monadiques) U, B : prédicats qui décrivent l'arbre (U pour unaires, B pour Binaires) -U : le complément de lensemble des nœuds qui vérifient U (prédicat unaire)

62 Exemple : nœuds dont le sous-arbre contient un nombre pair de feuilles ayant le label a Associer linformation (Even ou Odd) aux feuilles : –Even(x) Leaf(x) -Label[a](x) –Odd(x) Leaf(x) Label[a](x) Accumuler l'information (SFR = Sibling From Rigth) à partir du dernier frère droit : –SFREven(x) LastSibling(x) Even(x) –SFROdd(x) LastSibling(x) Odd(x) En la passant de frère en frère : –SFREven(x) FSEven(x) Even(x) –SFROdd(x) FSEven(x) Odd(x) –SFREven(x) FSOdd(x) Even(x) –SFROdd(x) FSOdd(x) Odd(x)

63 Exemple : nœuds dont le sous-arbre contient un nombre pair de feuilles ayant le label a Déterminer linformation à chaque frère : –FSEven(x 0 ) SFREven(x) SecondChild(x 0,x) –FSOdd(x 0 ) SFROdd(x) SecondChild(x 0,x) Remonter l'information au père –Even(x 0 ) SFREven(x) FirstChild(x 0,x) –Odd(x 0 ) SFROdd(x) FirstChild(x 0,x) Prédicat requête –Even(x)

64 Exemple darbre r acb a aa r a c b a a a

65 Exécution possible r a c b a a a Leaf Label[a] Odd

66 Exécution possible r a c b a a a LastSibling Odd SFROdd Odd

67 Exécution possible r a c b a a a Odd, SFROdd SFROdd(x) SecondChild(self,x) FSOdd Leaf Label[a] Odd SFREven

68 Exécution possible r a c b a a a Odd, SFROdd Even LastSibling SFREven SFREven(x) FirstChild(self,x) Even Odd, FSOdd, SFREven

69 Exécution possible r a c b a a a Odd, SFROdd SFROdd(x) FirstChild(self,x) Odd Odd, FSOdd, SFREven Even, SFREven SFREven(x) SecondChild(self,x) FSEven FSEven Odd SFROdd

70 Exécution possible r a c b a a a Odd, SFROdd Odd, FSOdd, SFREven Even, SFREven FSEven, Odd, SFROdd Leaf Label[a] Odd SFROdd(x) SecondChild(self,x) FSOdd FSOdd Odd SFREven

71 Exécution possible r a c b a a a Odd, SFROdd Odd, FSOdd, SFREven Even, SFREven FSEven, Odd, SFROdd Odd, FSOdd, SFREven SFREven(x) FirstChild(self,x) Even

72 Exemple : nœuds dont le sous-arbre contient un nombre pair de feuilles ayant le label a r a c b a a a Even r acb a aa

73 Exécution par 2 automates darbres Dans [K03] : algorithmes de construction des 2 automates à partir du programme logique représentant la requête Correspondance entre expression XPath et programme logique : description détaillée dans un autre article

74 Contraintes d'intégrité Clés primaires, clés étrangères, DF… Exécution : combiner automate darbre et FSA => WebDB2003 WebDB2003 Représentation par grammaire dattributs : idem automate darbre qui associe un vecteur détats à chaque nœud ; indépendance vis-à-vis du schéma => JIRC2005JIRC2005

75 Nos perspectives : les mises à jour Les documents valides pour un schéma restent-ils valides pour ce schéma ? – validation incrémentale Les documents continuent-ils à respecter leurs contraintes d'intégrité ? – vérification incrémentale Quels changements proposer pour rétablir la validité ? – correction dune mise à jour – mise à jour en cascade

76 Autres automates darbres

77 Automates darbres stepwise Autre représentation binaire d'un arbre quelconque Induit une correspondance systématique entre les résultats établis pour les arbres binaires (propriétés, théorèmes, algorithmes) et les résultats pour les arbres quelconques En particulier, relie requêtes sur arbres binaires et requêtes sur arbres quelconques

78 Correspondance arbre XML arbre binaire Chaque nœud de l'arbre XML devient une feuille de l'arbre binaire Chaque arc de l'arbre XML devient un de l'arbre binaire n1 n2n4n3 n1 n2

79 r acb a aa r a c b a

80 Isomorphisme : définitions arbre d'arité quelconque t ::= a(t 1, …, t n ) opération d'extension : u t' = a(t 1, …, t n u t' = a(t 1, …, t n, t') r ab a c aa r acb a aa =

81 Isomorphisme : définitions arbre binaire t ::= a | t t 2 opération de construction : t r t 2 = t t 2 correspondance c tree : tree u tree r c tree (t u t 2 ) = c tree (t 1 r c tree (t 2 ) c tree (a) = a

82 Stepwise Tree Automata Stepwise sur = Binary TA traditionnel A = F, ) Q ensemble fini labels de F ensemble fini d'états finals ensemble fini de règles de transitions : –a q –q q 2 q

83 Stepwise Tree Automata évaluation ( dénote soit u soit r) –eval (a) = {q | a q } –eval (t t 2 ) = {q | q 1 eval (t 1 ), q 2 eval (t 2 ), q q 2 q } pour tout t tree u : eval u (t) = eval r (c tree (t)) L u (A) = c tree (L r (A))

84 Exemple : arbres d'arité quelconque qui ont au moins 1 feuille ayant pour label a A = F, ) Q = {0, 1, = {a, F = {1, 2} = {a 1, a 0, b 0, 0, 2, 2, 2}

85 Seule évaluation valide a ba b b a a a

86 Exécution de lautomate stepwise a ba b b a a a Bottom-up run : 0, a 1, a 0, b 0

87 Exécution de lautomate stepwise a ba b b a a a Bottom-up run : 0, ,2 0 0, 2

88 Exécution de lautomate stepwise a ba b b a a a Bottom-up run : 0, ,2 0 0, 2

89 Exécution de lautomate stepwise a ba b b a a a Bottom-up run : 0, ,2 0,1 0,2 0, 2

90 Requête avec automate Stepwise requête = (A, S) A : un automate stepwise S : lensemble des états de sélection La requête sélectionne les nœuds de T qui ont un état dans S pour au moins une exécution valide Exemple : (A,{1}) = feuilles ayant pour label a

91 Autre automate darbre darité quelconque (déduit des stepwises) Q,, I, Q f, v, h I est un ensemble détats associés aux feuilles v est la relation de transition verticale h est la relation de transition horizontale

92 Automate darbre darité quelconque (modèle déduit des stepwises) Run r : dom(t) Q –Si t(p)=a et p a un successeur horizontal p alors (r(p), a, r(p)) doit appartenir à h –Si t(p)=a et p na pas de successeur horizontal et a pour père p alors (r(p), a, r(p)) doit appartenir à v –Les feuilles sont étiquetées par des états de I (transitions initiales) –t est accepté si sa racine est étiquetée par au moins un état de Q f.

93 Exercice : Considérer la DTD exposée au cours précédent (et traduite en automate darbre ayant des expressions régulières – Hedge Automata –) Construire lautomate darbre correspondant à la même DTD, mais formalisé selon les définitions des deux diapos précédentes

94 Généralisation Les Selecting Tree Automata représentent des requêtes unaires Leur exécution permet de sélectionner une séquence de nœuds (ok pour XPath) Il est courant davoir à retrouver des n-uplets dinformation, par exemple : –Des produits avec leur prix (product/name, product/price) => séquence de couples de nœuds –Le nom des ingrédients avec leur quantité et leur unité => séquence de triplets de noeuds

95 Automates darbres pour requêtes n-aires Associe à chaque nœud un n-uplet détats Lensemble de sélection est un ensemble de n- uplets détats Le principe reste le même : –Les exécutions valides associent à chaque nœud un vecteur détats –Le résultat de la requête est la séquence des n-uplets de nœuds dont le vecteur détats appartient à lensemble de sélection

96 Encore dautres modèles Since XML documents have a tree structure (usually defined by DTDs) XML queries can be modeled as mappings from trees to trees (tree transductions). Tree walking automata, caterpillar automata, k-pebble tree transducers

97 Tree walking automata machine à états finis, qui parcourt l'arbre comme un FSA avec un texte –FSA à 2 sens : symboles limites en début et en fin de texte –automate d'arbre : symboles limites aux frontières changement d'état et déplacement en fonction de : –l'état courant –le label du nœud courant –la position du nœud courant

98 Tree walking automata Définition : C = (Q,,q 0, q F, P) –P : règles de la forme (q, ) (q', d) où, q,q' Q, d {,,,, stay} –Soit T un arbre (n et n' des nœuds de l'arbre) : il y a une transition possible d'une configuration [n, q] vers [n', q'] ssi il y a dans P une règle (q, ) (q', d) tq T(n) = et m(n, d) = n' C accepte l'arbre s'il atteint un état final C est déterministe s'il n'y a dans P qu'une seule règle par couple (q, )

99 Exemple, reconnaître les arbres qui ont le chemin : //a[//b][//c] Q = {q a, q b, q c, q root, q F } q 0 = q b D'abord chercher un b : –, d {,,,, stay} : (q b, ) (q b, d) –(q b, b) (q a, stay) Ensuite le a correspondant (au-dessus du b) : – : (q a, ) (q a, ) –(q a, a) (q c, )

100 Exemple : //a[//b][//c] Puis le c correspondant (en-dessous du a) : –, d {, } : (q c, ) (q c, d) –(q c, c) (q root, ) Enfin remonter à la racine : – : (q root, ) (q root, ) –(q root, ) (q F, stay)

101 Exemple : //a[//b][//c] [, q b ] [0, q b ] (q b, ) (q b, d) (q b, a) (q b, ) (q b, b) (q a, stay) [0, q a ] (q a, ) (q a, b) (q a, ) [, q a ] (q a, a) (q c, ) [0, q c ] (q c, b) (q c, ) [1, q c ] (q c, a) (q c, ) [10, q c ] (q c, b) (q c, ) [11, q c ] (q c, c) (q root, ) a ba c b [1, q root ] (q root, a) (q root, ) [, q root ] (q root, a) (q root, ) [, q root ] (q root, ) (q F, stay)

102 Problèmes Théoriques : questions ouvertes –Expressivité : lien entre TWA et langages réguliers d'arbre ? –Lien entre TWA et TWA déterministes ? –…–… Pratiques –les tests d'existence (emptyness), de contenance (containment) et d'équivalence sont EXPTIME-complet

103 Pushdown Caterpilar Automata Proches des TWA Voir article : A. Brüggeman Klein, D. Wood : Balanced context free grammars, hedge grammars and pushdown caterpillar automata, Extreme Markup Languages 2004

104 prise en compte des valeurs Un TWA + un nombre fini de registres L'automate peut –stocker des valeurs dans un registre –comparer la valeur d'un attribut avec celle d'un registre Permet de vérifier les propriétés définies avec les valeurs (l'attribut nom de valeur "La fondue")

105 Type Checking Un programme P transforme un arbre T en un autre arbre T' Deux types (ou schémas) : et ' Vérifier que quelque soit T, si T a pour type alors P(T) a pour type ' Les transducteurs d'arbres "k-pebble" ont été proposés pour modéliser P afin de rendre possible cette vérification

106 Type inference Un programme P transforme un arbre T en un autre arbre T' Calculer le type de P(T) Quand c'est possible, c'est une solution pour le type checking En général impossible (l'ensemble P(T) n'est pas un langage d'arbre régulier)

107 Principes des k-pebble TT parcours de l'arbre comme le parcours d'un FSA sur un texte : –de nœud en nœud (vers le haut ou vers le bas) –l'automate exécute une transition en fonction de : l'état dans lequel il est le label du nœud courant le nombre de "pebble" (marques) associé au nœud courant –les pebble sont ajoutés ou retirés des nœuds k est le nombre maximum de pebble dans l'arbre à un instant donné : paramètre du transducteur construit un résultat (comme tout transducteur)

108 Principes des k-pebble TT les pebble sont numérotés et seul le pebble de plus grand numéro peut être bougé –for x in nodes(t) do for y in nodes(t) do … on commence par placer un pebble à la racine et on se déplace avec lui dans l'arbre à tout moment on peut –soit laisser le pebble où l'on est et repartir de la racine avec un autre pebble –soit enlever le pebble courant, et reprendre alors là où se trouve le pebble directement précédent

109 Principes des k-pebble TT Le résultat est déterminé par des transitions de sorties : –l'automate ne change pas de nœud –un nœud est créé, avec ses fils (2) –deux nouveaux calculs sont initiés, un par branche –si le nœud créé est une feuille le calcul sur cette branche s'arrête

110 Exemple : copie d'arbre (binaire) 1 pebble, 3 états (q 0, q 1, q 2 ) dans l'état q 0 : –créé un nœud de même label que celui du nœud courant, et ses 2 fils –les transducteurs des fils sont initialisés à q 1 pour le gauche et q 2 pour le droit dans l'état q 1 : –déplace le pebble vers le fils gauche et passe dans l'état q 0 dans l'état q 2 : –déplace le pebble vers le fils droit et passe dans l'état q 0

111 Exemple : copie d'arbre (binaire) a a ba c b , a, q 0, a, q 1, a, q 2

112 Exemple : copie d'arbre (binaire) a a ba c b , a, q 1, a, q 2 0, b, q 0 1, a, q 0

113 Exemple : copie d'arbre (binaire) a a ba c b , b, q 0 1, a, q 0 ba 1, a, q 1 1, a, q 2

114 Exemple : copie d'arbre (binaire) a a ba c b ba 1, a, q 1 1, a, q 2 10, b, q 0 11, c, q 0

115 Exemple : copie d'arbre (binaire) a a ba c b , b, q 0 11, c, q 0 ba c b

116 Transducteurs k-pebble Les transducteurs d'arbre k-pebble peuvent servir au calcul d'un certain nombre de requêtes mais : –pas de jointure (ne peuvent pas tester x = y) –pas d'exécution efficace (multiples passages par les mêmes nœuds)


Télécharger ppt "XML modèle logique de données contraintes dintégrité (opérateurs) Master 2 ème année recherche en informatique Université François-Rabelais Béatrice Bouchou."

Présentations similaires


Annonces Google