xml modèle logique de données contraintes dintégrité (opérateurs) master 2 ème année...

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

• 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>

...

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)

...

2 3 4 5

Identifiants de nœuds : exemple

...

0 1 2 3

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

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

menu02

restaurant0

restaurant1

@address@name

010000

...combinations

meals desserts021 022

......

combination030 ...

wineName wineYear mealName price0300 0301 0302 0303

03000 03010 03020 03030

Exemple : keyTree

(Cahors) (2002)(0201)

@refCount@poskey@refCount@pos

(Sancerre) (2000)(0200)

target target

context

(1) (3)

keykey

keyTree

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

(Cahors) (2002) (25.00)data data data

yearnamepriceyearname

(Sancerre) (2000) (21.00)data datadata

020200 020210 020220

wine wine

02020 02021 02022

drinks

0201 0202

020010 020020020000

02001 02002

020100 020110 020120

02010 02011 02012

Exemple : mise-à-jour keyTree

(Cahors) (2002)(0202)

@refCount@poskey@refCount@pos

(Sancerre) (2000)(0201)

target target

context

(1) (3)

keykey

keyTree

(Bordeaux)(0200)

@refCount@pos key

target

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

...

2 3 4 5

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 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" "::")

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

Iteme3

Ustensilee2

Ustensilese1

Recettee0

!Recette

Exemple

e4Iteme3

Ustensilee2Ustensilese1

Recettee0

!Recette

Recette

Root n0

n1 Recettes

Exemple

e4Iteme3

Recettee0

!Recette

Recette

Root n0

@nom n3

n1 Recettes

Exemple

e4Iteme3

Recettee0

!Recette

Recettes

Root n0

Ustensiles n9

Exemple

Ustensile

e4 Final → ajouter n11 au résultat

e4Iteme3

Recettee0

!Recette

Recettes

Ustensiles

Item n11

Root n0

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

… …

q0 Root

Root q0

Illustration

Recette

Recettes

@nom @temps @unit

data data data

Ustensile Ustensile

Item Commentaire

data data

… …

q0 Root

q0 XRecette : X, q0 q0

Recette

@nom @temps @unit

data data data

Ustensile Ustensile

Item Commentaire

data data

… …

Recette, q0 q1

Recettes

q0 Root

Exemple

Recette

@nom @temps @unit

data data data

Ustensile Ustensile

Item Commentaire

data data

… …

q4 q4 q4 q2 q4 q4

Recettes

q0 Root

Ustensiles, q1 q2

(X, q) {(Recette, q0), (Ustensiles, q1), (Ustensile, q2), (Item, q3)} :X, e q4

Exemple

Recette

@nom @temps @unit

data data data

Ustensile Ustensile

Item Commentaire

data data

… …

q4 q4 q4 q2 q4 q4

q4 q4 q4

q4 qf qf

q4 q4 q4

Recettes

q0 Root

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

n2 n5n3

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)

• 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

Exécution possible

Leaf Label[a] Odd

Exécution possible

LastSibling Odd SFROdd

Exécution possible

Odd, SFROdd

SFROdd(x) SecondChild(self,x) FSOddLeaf Label[a] Odd SFREven

Exécution possible

Odd, SFROdd

Odd, SFROddEven LastSibling SFREven

SFREven(x) FirstChild(self,x) Even

Odd, FSOdd, SFREven

Exécution possible

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

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

Odd, SFROdd

Odd, FSOdd, SFREven

Even, SFREven

FSEven, Odd, SFROdd

Odd, FSOdd, SFREven

SFREven(x) FirstChild(self,x) Even

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

n2 n4n3

a aar a cb 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')

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

Exécution de l’automate stepwise

• Bottom-up run :

0,1 0,1

a 1, a 0, b 0

• Bottom-up run :

0,1 0,1

0@0 0, 0@1 2

• Bottom-up run :

0,1 0,1

0@0 0, 2@0 2

• Bottom-up run :

0,1 0,20,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

– 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, )

[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)

• 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

• 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

, a, q0

, a, q1 , a, q2

0, b, q0 1, a, q0

1, a, q1 1, a, q2

10, b, q0 11, c, q0

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)

xml modèle logique de données contraintes dintégrité (opérateurs) master 2 ème année...

Documents

béatrice et francis grandguillot

par béatrice bon-michel83

béatrice boyer groupe urd

universitÉ franÇois rabelais de tours -...

3 et 4(grand) rue rabelais

universitÉ franÇois rabelais de tours thÈse

béatrice de françoise et béatrice

1 novembre 2005laboratoire dintégrité des structures et...

boutin akissi béatrice

1 le modèle relationnel chapitre 3. 2 objectifs...

lumiere - le rabelais tech rabelaissept2017.pdfmise à jour...

segpa rabelais st_maur diaporama

rabelais le quart livre

fracois rabelais - gargantua

colloque international organisé par l’université...

les métiers bancaires lycée rabelais 11/01/2010 1lycée...

rabelais 02

béatrice poirier laforce

rabelais, oeuvres vol 1

béatrice rilos ou les élections