xml modèle logique de données contraintes dintégrité (opérateurs) master 2 ème année...
TRANSCRIPT
XMLmodèle logique de données
contraintes d’inté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
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 d’intégrité
• Définir les opérations sur les données => requêtes et transformations
Plan
• Modèle logique de données
• XPath – syntaxe– modèles opérationnels (exécution des requêtes)
• Contraintes d’intégrité– syntaxe(s)– vérification
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, 2003
• C. Koch : "Efficient Processing of Expressive Node-Selecting Queries on XML Data in Secondary Storage: a Tree Automata-based Approach", Proc. of the 29th VLDB Conference, Berlin, Germany, 2003
• 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, 2003
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 15th RTA Conference, Aachen, Germany, 2004
• J. Niehren, L. Planque, J.-M. Talbot, S. Tison : "N-ary Queries by Tree Automata ", 10th International Symposium on Database Programming Languages (DBPL), 2005
Modèle logique de données
• Structure de document XML = Arbre<a>
<b>...</b>
<b>...</b>
<c d=...>
...
</c>
<e>...</e>
</a>
b b
d
c e
a
Les nœuds d’un arbre XML
• Sont chacun associés à un label (nom de l’élément ou de l’attribut)
• 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 d’un ensemble de documents)
<a>
<b>...</b>
<b>...</b>
<c d=...>
...
</c>
<e>...</e>
</a>
b b
d
c e
a1
2 3 4 5
6
Identifiants de nœuds : exemple
<a>
<b>...</b>
<b>...</b>
<c d=...>
...
</c>
<e>...</e>
</a>
b b
d
c e
a
0 1 2 3
2.0
Identifiants de nœuds : exemple
Identifiants de nœuds
• Les « positions » reflétant l’ordre 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.
Exemple : document
02000
020010 020020
(Cahors) (2002) (25.00)data data data
data data
yearnamepriceyearname
(Sancerre) (2000) (21.00)data datadata
(Sancerre) (2000) (Grilled Fish)data datadata
(30.00)dataprice
020000 020100 020110 020120
wine wine
02001 02002 02010 02011 02012
drinks
0200 0201
020
menu02
restaurant0
restaurant1
@address@name
010000
0100
root
...combinations
meals desserts021 022
......
03
combination030 ...
wineName wineYear mealName price0300 0301 0302 0303
03000 03010 03020 03030
Exemple : keyTree
(Cahors) (2002)(0201)
@refCount@poskey@refCount@pos
(Sancerre) (2000)(0200)
key
target target
context
(1) (3)
keykey
@pos
…
keyTree
@name
(0)
(K1)
Exemple : modification
Insertion of a new subtree rooted wine as first child of first node drinks:
(Bordeaux) (1990) (30.00)data data data
yearname price
wine
(Cahors) (2002) (25.00)data data data
yearnamepriceyearname
(Sancerre) (2000) (21.00)data datadata
price
020200 020210 020220
wine wine
02020 02021 02022
drinks
0201 0202
020
...
0200
02000
020010 020020020000
02001 02002
020100 020110 020120
02010 02011 02012
Exemple : mise-à-jour keyTree
(Cahors) (2002)(0202)
@refCount@poskey@refCount@pos
(Sancerre) (2000)(0201)
key
target target
context
(1) (3)
keykey
@pos
…
keyTree
(0)
(K1)
(Bordeaux)(0200)
@refCount@pos key
target
(0)
key
(1990)
Identifiants persistants
• 2 ou 3 nombres par identifiant
• Maintien des informations structurelles
• Le nombre d’insertions et de suppressions possibles avant qu’une renumérotation globale soit calculée reste encore limité (à une trentaine d’insertions au même endroit, pour l’instant).
• 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.
<a>
<b>...</b>
<b>...</b>
<c d=...>
...
</c>
<e>...</e>
</a>
b b
d
c e
a1
2 3 4 5
6
Ordre total, relation hiérarchique
N1<N2<N3<N4<N6<N5N1<N2<N3<N4<N6<N5
Exercice
• Construire l’arbre 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
Exercice
• Que pourrait-on avoir comme schema (DTD) ?
• Quel serait l’automate d’arbre correspondant ?
Précision
• Modèles d’accè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 documentMais permet de parcourir l’ARBRE que représente le document (usage de piles)
Opérateurs
• Appliqués à des arbres ou des forêts
• Ceux qui modifient retournent des arbres ou des forêts
• Constructions d’arbres …
• Sélections de sous-arbres– Selon une structure donnée– Selon des valeurs données
• Selon une localisation (dans l’arbre) donnée.
XPath
XPath
• 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)
Modèle de données Xpath 2.0
• Un nœud peut être de l’une 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 n’ont pas de label
• On appelle dom(t) l’ensemble des nœuds de l’arbre t
La syntaxe
• //Recette/Ustensiles/Ustensile/Item– <Item>Caquelon</Item> et <Item>réchaud</Item>
• 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 »
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) l’axe est "child"
Les axes ForwardAxis ::= ("child" "::")
| ("descendant" "::")| ("attribute" "::")| ("self" "::")| ("descendant-or-self" "::")| ("following-sibling" "::")| ("following" "::")| ("namespace" "::")
ReverseAxis ::= ("parent" "::")| ("ancestor" "::")| ("preceding-sibling" "::")| ("preceding" "::")| ("ancestor-or-self" "::")
Les axes
• Se représentent par des relations binaires
– Exp. self := {<x, x> | x dom}
• S’expriment tous* avec 2 relations primitives
– firstchild (exp. <n0, n1>, <n1, n2>, <n8, n9> …)
– nextsibling (exp. <n2, n4>, <n4, n6> …)
– Notations : r, r-1, r1.r2, r*
• [ *Sauf : " attribute" et "namespace" – l’axe attribute sélectionne les fils attributs– l’axe namespace sélectionne les fils namespace ]
Exercice
• Décrire les axes suivants à l’aide des 2 relations primitives :– child – descendant– following sibling– parent
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
Les tests de nœud
• Filtrent la séquence des nœuds sélectionnés par l’axe, 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
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)
Les prédicats
• Filtrent la séquence N des nœuds sélectionnés par l’axe 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 l’ordre du document, la position de contexte
• Les variables et les fonctions sont évaluées en fonction du contexte
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
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
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 : http://www.w3.org/TR/xpath-functions/
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 ?
Modèle d’exé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]
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
• Calcul d’axes=> automate à états finis (Q, , , q0, F)
• //Recette/Ustensiles/Ustensile/Item
• Parcours dans l'ordre du document (streaming)– > Pile d'états
Premières approches : FSA
e4
Iteme3
Ustensilee2
Ustensilese1
Recettee0
!Recette
Exemple
Root
n0 e0
e0
e1
e4Iteme3
Ustensilee2Ustensilese1
Recettee0
!Recette
Recette
Root n0
n1 Recettes
n2
Exemple
e0
e1
e4Iteme3
Ustensilee2Ustensilese1
Recettee0
!Recette
Recette
Root n0
n2
@nom n3
n1 Recettes
Exemple
e0
e1
e2
e4Iteme3
Ustensilee2Ustensilese1
Recettee0
!Recette
Recettes
Root n0
n1
Ustensiles n9
…
Exemple
e0
e1
e2
Ustensile
e3
e4 Final → ajouter n11 au résultat
e4Iteme3
Ustensilee2Ustensilese1
Recettee0
!Recette
Recettes
Ustensiles
n10
Item n11
Root n0
n1
n9 …
Automate d'arbre
• Approche précédente = implémentation séquentielle d'un automate d'arbre top down
déterministe (Q, , , q0, F)
Q = {q0, q1, q2, q3, q4, qf}
= {labels de l'arbre}
F = {qf}
= {Root q0; XRecette : X, q0 q0; Recette, q0 q1; Ustensiles, q1 q2; Ustensile, q2 q3 ; Item, q3 qf ; // à sélectionner (X, q) {(Recette, q0), (Ustensiles, q1), (Ustensile, q2), (Item, q3)} :X, e q4}
Illustration
Recette
Recettes
@nom @temps @unit
data data data
Ustensiles Ingrédients Instructions
Ustensile Ustensile
Item Commentaire
data data
Item
data
… …
q0 Root
Root q0
Illustration
Recette
Recettes
@nom @temps @unit
data data data
Ustensiles Ingrédients Instructions
Ustensile Ustensile
Item Commentaire
data data
Item
data
… …
q0 Root
q0 XRecette : X, q0 q0
Recette
@nom @temps @unit
data data data
Ustensiles Ingrédients Instructions
Ustensile Ustensile
Item Commentaire
data data
Item
data
… …
q1
Recette, q0 q1
Recettes
q0 Root
q0
Exemple
Recette
@nom @temps @unit
data data data
Ustensiles Ingrédients Instructions
Ustensile Ustensile
Item Commentaire
data data
Item
data
… …
q1
q4 q4 q4 q2 q4 q4
Recettes
q0 Root
q0
Ustensiles, q1 q2
(X, q) {(Recette, q0), (Ustensiles, q1), (Ustensile, q2), (Item, q3)} :X, e q4
Exemple
Recette
@nom @temps @unit
data data data
Ustensiles Ingrédients Instructions
Ustensile Ustensile
Item Commentaire
data data
Item
data
… …
q1
q4 q4 q4 q2 q4 q4
q4 q4 q4
q4 qf qf
q3 q3
q4 q4 q4
Recettes
q0 Root
q0
Limitation premières approches
• Expressivité des requêtes– Limitées aux calculs d’axes
• 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).
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
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 ) 2Q
( dénote l'absence de fils)
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}
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
Une transformation en arbre binaire
• premier fils => fils gauche ; frère droit => fils droit
n1
n2 n5n3
n4
n1
n2
n5n4
n3
Calcul d’une 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)
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).
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
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
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 n’a 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 s’il n’a 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
Programme logique représentant une requête
• Forme des règles représentant une requête :– P(x) U(x)– P(x) P0(x0) B(x0,x) – P(x0) P0(x) B(x0,x) – P(x) P1(x) P2(x)
• P, Pi : 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 l’ensemble des nœuds qui
vérifient U (prédicat unaire)
Exemple : nœuds dont le sous-arbre contient un nombre pair de feuilles ayant le label a
• Associer l’information (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)
Exemple : nœuds dont le sous-arbre contient un nombre pair de feuilles ayant le label a
• Déterminer l’information à chaque frère :– FSEven(x0) SFREven(x) SecondChild(x0,x) – FSOdd(x0) SFROdd(x) SecondChild(x0,x)
• Remonter l'information au père– Even(x0) SFREven(x) FirstChild(x0,x) – Odd(x0) SFROdd(x) FirstChild(x0,x)
• Prédicat requête– Even(x)
Exemple d’arbre
r
a cb
a aa
r
a
c
b
a
a
a
Exécution possible
r
a
c
b
a
a
a
Leaf Label[a] Odd
Leaf Label[a] Odd
Exécution possible
r
a
c
b
a
a
a
LastSibling Odd SFROdd
LastSibling Odd SFROdd
Odd
Odd
Exécution possible
r
a
c
b
a
a
a
Odd, SFROdd
Odd, SFROdd
SFROdd(x) SecondChild(self,x) FSOddLeaf Label[a] Odd SFREven
Exécution possible
r
a
c
b
a
a
a
Odd, SFROdd
Odd, SFROddEven LastSibling SFREven
SFREven(x) FirstChild(self,x) Even
Odd, FSOdd, SFREven
Exécution possible
r
a
c
b
a
a
a
Odd, SFROdd
Odd, SFROdd
SFROdd(x) FirstChild(self,x) Odd
Odd, FSOdd, SFREven
Even, SFREven
SFREven(x) SecondChild(self,x) FSEven
FSEven Odd SFROdd
Exécution possible
r
a
c
b
a
a
a
Odd, SFROdd
Odd, SFROdd
Odd, FSOdd, SFREven
Even, SFREven
FSEven, Odd, SFROdd
Leaf Label[a] Odd SFROdd(x) SecondChild(self,x) FSOddFSOdd Odd SFREven
Exécution possible
r
a
c
b
a
a
a
Odd, SFROdd
Odd, SFROdd
Odd, FSOdd, SFREven
Even, SFREven
FSEven, Odd, SFROdd
Odd, FSOdd, SFREven
SFREven(x) FirstChild(self,x) Even
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
Even
r
a cb
a aa
Exécution par 2 automates d’arbres
• 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
Contraintes d'intégrité
• Clés primaires, clés étrangères, DF…
• Exécution : combiner automate d’arbre et FSA => WebDB2003
• Représentation par grammaire d’attributs : idem automate d’arbre qui associe un vecteur d’états à chaque nœud ; indépendance vis-à-vis du schéma => JIRC2005
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 d’une mise à jour– mise à jour en cascade
Autres automates d’arbres
Automates d’arbres 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
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 nœud @ de l'arbre binaire
n1
n2 n4n3
n1 n2
n4
n3
@
@
@
@@@
r
a cb
a aar a cb a a
a@
@
@
@
@
@
@
@@
@
@
@
Isomorphisme : définitions
• arbre d'arité quelconque t ::= a(t1, …, tn)
• opération d'extension : t @u t' = a(t1, …, tn) @u t' = a(t1, …, tn, t')
r
a b
a
c
aa
r
a cb
a aa
@u =
Isomorphisme : définitions
• arbre binaire t ::= a | t1 @ t2
• opération de construction : t1 @r t2 = t1 @ t2
• correspondance ctree : treeu treer ctree(t1 @u t2) = ctree(t1) @r ctree(t2) ctree(a) = a
Stepwise Tree Automata
• Stepwise sur = Binary TA traditionnel sur @ A = (Q, @, F, )
• Q ensemble fini d'états
@ labels de plus @
• F ensemble fini d'états finals
ensemble fini de règles de transitions :– a q
– q1 @ q2 q
Stepwise Tree Automata
• évaluation ( dénote soit u soit r)– eval (a) = {q | a q }
– eval (t1@ t2) = {q | q1 eval (t1), q2 eval (t2),
q1 @ q2 q }
• pour tout t treeu : evalu (t) = evalr(ctree(t))
• Lu(A) = ctree(Lr(A))-1
Exemple : arbres d'arité quelconque qui ont au moins 1 feuille ayant pour label a
• A = (Q, @, F, )
• Q = {0, 1, 2}@ = {a, b, @}
• F = {1, 2} = {a 1, a 0, b 0, 0@0 0,
0@1 2, 2@0 2, 0@2 2}
Seule évaluation valide
a
b a
ba
@
@ @
b@ba
aa
0 0
0 1
0
0
0 0
01
0
2
0
2
2
2
2
2
Exécution de l’automate stepwise
a
b a
ba
@
@ @
b@ba
aa
• Bottom-up run :
0,1 0
0,1 0,1
0
0,1
0 0,1
00,1
a 1, a 0, b 0
Exécution de l’automate stepwise
a
b a
ba
@
@ @
b@ba
aa
• Bottom-up run :
0,1 0
0,1 0,1
0
0,1
0 0,1
00,1
0
0,2
0
0,2
0@0 0, 0@1 2
Exécution de l’automate stepwise
a
b a
ba
@
@ @
b@ba
aa
• Bottom-up run :
0,1 0
0,1 0,1
0
0,1
0 0,1
00,1
0
0,2
0
0,2
0,2
0,2
0@0 0, 2@0 2
Exécution de l’automate stepwise
a
b a
ba
@
@ @
b@ba
aa
• Bottom-up run :
0,1 0
0,1
0
0,1
0 0,1
0
00
0,2
0,2
0,1
0,1 0,20,2
0,2
0,2
0@0 0, 0@2 2
Requête avec automate Stepwise
• requête = (A, S)• A : un automate stepwise• S : l’ensemble 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
Autre automate d’arbre d’arité quelconque (déduit des stepwises)
• Q, , I, Qf , 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
Automate d’arbre d’arité 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 n’a 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 Qf.
Exercice :
• Considérer la DTD exposée au cours précédent (et traduite en automate d’arbre ayant des expressions régulières – Hedge Automata –)
• Construire l’automate d’arbre correspondant à la même DTD, mais formalisé selon les définitions des deux diapos précédentes
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 d’avoir à retrouver des n-uplets d’information, 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
Automates d’arbres pour requêtes n-aires
• Associe à chaque nœud un n-uplet d’états
• L’ensemble 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 à l’ensemble de sélection
Encore d’autres 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
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
Tree walking automata
• Définition : C = (Q, ,q0, qF, 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) tqT(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, )
Exemple, reconnaître les arbres qui ont le chemin : //a[//b][//c]
• Q = {qa, qb, qc, qroot, qF}• q0 = qb
• D'abord chercher un b : , d{, , , , stay} :
(qb, ) (qb, d)– (qb, b) (qa, stay)
• Ensuite le a correspondant (au-dessus du b) : : (qa, ) (qa, )– (qa, a) (qc, )
Exemple : //a[//b][//c]
• Puis le c correspondant (en-dessous du a) : , d{, } : (qc, ) (qc, d)
– (qc, c) (qroot, )
• Enfin remonter à la racine : : (qroot, ) (qroot, )
– (qroot, ) (qF, stay)
Exemple : //a[//b][//c]
[, qb]
[0, qb]
(qb, ) (qb, d)(qb, a) (qb, )
(qb, b) (qa, stay)
[0, qa] (qa, ) (qa, )(qa, b) (qa, )
[, qa] (qa, a) (qc, )
[0, qc] (qc, b) (qc, )
[1, qc] (qc, a) (qc, )
[10, qc] (qc, b) (qc, )
[11, qc] (qc, c) (qroot, )
a
b a
cb
0 1
10 11
[1, qroot] (qroot, a) (qroot, )
[, qroot] (qroot, a) (qroot, )
[, qroot] (qroot, ) (qF, stay)
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
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
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")
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
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)
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)
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
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
Exemple : copie d'arbre (binaire)
• 1 pebble, 3 états (q0, q1, q2)• dans l'état q0 :
– 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 à q1 pour le gauche et q2 pour le droit
• dans l'état q1 : – déplace le pebble vers le fils gauche et passe dans l'état q0
• dans l'état q2 : – déplace le pebble vers le fils droit et passe dans l'état q0
Exemple : copie d'arbre (binaire)
aa
b a
cb
0 1
10 11
, a, q0
, a, q1 , a, q2
Exemple : copie d'arbre (binaire)
aa
b a
cb
0 1
10 11
, a, q1 , a, q2
0, b, q0 1, a, q0
Exemple : copie d'arbre (binaire)
aa
b a
cb
0 1
10 11
0, b, q0 1, a, q0
b a
1, a, q1 1, a, q2
Exemple : copie d'arbre (binaire)
aa
b a
cb
0 1
10 11
b a
1, a, q1 1, a, q2
10, b, q0 11, c, q0
Exemple : copie d'arbre (binaire)
aa
b a
cb
0 1
10 11
10, b, q0 11, c, q0
b a
cb
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)