Validation incrémentale des contraintes dintégrité en XML Maria Adriana Abrão, Béatrice...

Validation incrémentale des contraintes d’intégrité en XML

Maria Adriana Abrão, Béatrice Bouchou, Mírian Halfeld-Ferrari, Dominique Laurent, Martin Musicante

JIRC’2005 – Premières Journées Informatique de la Région Centre

Plan

Vue générale de l’approche

Contraintes d’integrités: clef et clef étrangère en XML

Validation d’un document XML from scratch

Validation incrémentale avec mises à jour multiples

Résultats et conclusion

M.A. Abrão – JIRC’2005 1

Vue générale:

Validation d’un document XML(from scratch)

Contraintes d’integrité

oui / non(pour chaque contrainte)

Structure qui regroupe les valeurs clefs trouvées dans le document XML

Document XML

KeyTrees

Validationincrémentale des mises à jour

Suite de mises à jour



Document XML

KeyTrees

KeyTrees ’

Document XML+

Mises à jour


Préliminaires

Un document XML est considéré comme un arbre d’arité non bornée.

Une expression de chemin est un mécanisme pour naviguer et sélectionner des nœuds d’un document XML.

Expression

/

/toto

//recipe

/collection/category

Résultat

tout le document

l’ensemble vide, puisqu'il n'y a pas de nœud “toto“

tous les éléments “recipe" du document où qu'ils soient

tous les éléments “category” fils de “collection”

Soups

root

collection

category recipe

ingredientname author

Shrimp Soup

J.Fox name amount

...

Carrot 1 medium

recipe


Mushroom Soup

M.Smith

...

collection

...


Contraintes d’integrité en XML

Une clef primaire K est représentée par l’expression de chemin:

K = (Q, (Q’,{ P1, ... , Pm })) où: Q est le chemin du contexte (context)

Q’ est le chemin cible (target)P1, ... , Pm sont les chemins composant la clef

r

n

n’ . . .. . .

. . .

Q’

Q

P1

Q’Q’

Pm

Une clef peut être:

Absolue: le contexte c’est la racine du document XML

Relative: le contexte n’est pas la racine.



K1 = (/, (./collection,{ ./category } )) clef absolue

K2 = (/collection, (.//recipe,{ ./name, ./author } )) clef relative

K3 = (//recipe, (./ingredient,{ ./name } )) clef relativeroot

collection

category recipe

ingredientSoups name author

Shrimp Soup J.Fox name amount

ingredient

...

Carrot 1 medium

recipe


Mushroom Soup

M.Smith

...

top_recipe

author_name@number recipe_name

1 Mushroom Soup

top_recipes

M.Smith

collection

...



Soit une clef primaire K = (Q, (Q’,{P1, ... , Pm})) .

Une clef étrangère FK est représentée par :

FK = (Q0, (Q0’,{P01, ... , P0

m})) K où: Q0 = Q

r

n

n’ . . .

. . .

Q

P1

Q’Q’

Pm

n0’. . .

. . .

P01 P0

m

Q0’

Q0’



root

collection

category recipe



ingredient

...

Carrot 1 medium

recipe


Mushroom Soup

M.Smith

...

top_recipe


1 Mushroom Soup

top_recipes

M.Smith

collection

...

FK4 = (/collection, (./top_recipes/top_recipe,{ ./recipe_name, ./author_name })) K2

K2 = (/collection, (.//recipe,{ ./name, ./author } ))




oui / non

KeyTrees

Validation from scratch

Document XML

K2 = (/collection, (.//recipe,{ ./name, ./author } ))

e0collection

M2 :

e2 e3recipe

M2’:

e4 e5name

M2”:

e1

*

e6

author

(pour chaque contrainte)

M2.eo est la configuration initiale pour la clef K2.


Le processus de vérification des contraintes d’intégrité est formalisé

par une grammaire d’attributs où:

les règles de production sont définies par le schéma, et les attributs décrivent des informations sur les contraintes

d’intégrité.

À chaque règle de production sont associées des règles sémantiques,

composées d’actions et d’attributs.

E E + T { code }

règle de production règle sémantique

Grammaire d’attributs


Les règles sémantiques fournissent un mécanisme pour l’annotation

des nœuds avec des attributs, qui peuvent fonctionner de façon:

A

B C

n

m m

A BC { n(A) = f (m(B), m(C)) }

A

B C

n

m m

A BC { m(C) = f (m(B), n(A)) }

Ascendante (attributs synthétisés): Parcours ascendant de l'arbre La valeur d’un attribut synthétisé est

déterminée à partir de valeurs d'attributs des fils de ce nœud.

Descendante (attributs hérités): Parcours descendant de l'arbre La valeur d’un attribut hérité est

déterminée à partir de valeurs d'attributs du père et/ou des frères de ce nœud.



Direction descendante:

Le parcours de haut en bas est utilisé pour déterminer le rôle de chaque nœud en ce qui concerne des clefs primaires et étrangères.

Chaque nœud contient un attribut, appelé conf, pour chaque contrainte devant être verifiée.

L’attribut conf garde la configuration (M.e) qui exprime le rôle du nœud par rapport à une contrainte.



root

collection

recipe

name author

Mushroom Soup M.Smith

... top_recipe


1 Mushroom Soup

top_recipes

M.Smith

…

conf K2 = { M2 .e0 }conf FK4 = { M4 .e0 }

conf K2 = { M2 .e1 } conf FK4 = { M4 .e1 }

conf K2 = { M2’.e2 , M2’.e3 } conf FK4 = { }

conf K2 = { M2’.e2 , M2”.e5 } conf FK4 = { }

conf K2 = { M2’.e2 , M2”.e6 } conf FK4 = { }

conf K2 = { } conf FK4 = { M4’.e3 }

conf K2 = { } conf FK4 = { M4’.e4 }

conf K2 = { } conf FK4 = { M4”.e7 }

conf K2 = { } conf FK4 = { M4”.e6 }

e0collection

M2 :

e2 e3recipe

M2’:

e4 e5name

M2”:

e1

*

e6

author

...

e0

collectionM4 :

e2 e3

top_recipesM4’:

e5 e6recipe_name

M4”:

e1

e7author_name

e4

top_recipe

K2 = (/collection, (.//recipe,{ ./name, ./author}))

FK4 = (/collection, (./top_recipes/top_recipe,{ ./recipe_name, ./author_name})) K2


Direction descendante:


Direction ascendante:

Dans cette direction, les valeurs liées a chaque clef sont portées jusqu’aux nœuds contexte.

Pour chaque nœud, trois attributs peuvent être définis:

k : tuple qui contient une valeur qui compose une clef

t : ensemble qui réunit les tuples obtenus par les attributs k des nœuds fils.

c : booléen qui représente le résultat de la vérification de tous les attributs t des noeuds fils.




conf FK4 = { M4”.e7 }

root

collection

… recipe

name author


... top_recipe


1 Mushroom Soup

top_recipes

M.Smith

…

conf K2 = { M2 .e1 }

conf FK4 = { M4 .e1 }

conf K2 = { M2 .e0 }

conf FK4 = { M4 .e0 }

conf K2 = { M2’.e2 , M2’.e3 }

conf K2 = { M2’.e2 , M2”.e5 } conf K

2 = { M2’.e2 , M2”.e6 }

conf FK4 = { M4’.e3 }

conf FK4 = { M4’.e4 }

k4 = <Mushroom Soup> k4 = <M.Smith>conf FK

4 = { M4”.e6 }

c2 = <true>c4 = <true>

c2K = <true>

c4FK = <true>

t2 = {< Mushroom Soup, M.Smith>}


k2 = <Mushroom Soup> k2 = <M.Smith>t4 = {< Mushroom Soup, M.Smith>}

e0collection

M2 :

e2 e3recipe

M2’:

e4 e5name

M2”:

e1

*

e6

author

e0collectionM4 :

e2 e3

top_recipesM4’:

e5 e6recipe_name

M4”:

e1

e7author_name

e4

top_recipe

K2 = (/collection, (.//recipe,{ ./name, ./author}))

FK4 = (/collection, (./top_recipes/top_recipe,{ ./recipe_name, ./author_name})) K2

M.A. Abrão – JIRC’2005

Direction ascendante:

14

keyTree

@namekey

@posK2

0

target

key@pos @refCount

0.1 0

…context

Shrimp Soup

key

J.Fox

target

key@refCount

0.2 1 Mushroom Soup

key

M.Smith

@pos

root

collection

recipe

name author

Shrimp Soup J.Fox

...

…c2

K = <true>c4

FK = <true>

c2 = <true>c4 = <true>

t2 = {< Shrimp Soup, J.Fox >}

k2 = <Shrimp Soup> k2 = <J.Fox>

recipe

name author


...


k2 = <Mushroom Soup> k2 = <M.Smith>

category

Soups

0

0.0 0.1 0.2

0.1.0 0.1.1 0.2.0 0.2.1

Pendant que les attributs synthétisés sont calculés pour une clef primaire, son arbre keyTree correspondant est construit.

M.A. Abrão – JIRC’2005


keyTreeK2 :

15



oui / non

KeyTrees

Validation from scratch

Document XML

Structures Auxiliaires:

(i) CONF: pile pour stocker les attributs hérités.

(ii) SYNT: pile pour stocker les attributs synthétisés

CONF SYNT

(pour chaque contrainte)


Résultat de la validation d’un document XML from scratch

Soit un ensemble de clefs primaires et étrangères qui doivent être respectées par un sous-arbreT’ :

Kj (1 j m)

FKj (m+1 j n)

Le résultat de la vérification iniciale appliqué sur T’ est un tuple

< < l1 , ... , ln >, < keyTreeK1 [T’,] , ... , keyTreeKm [T’,] > >

Oú: < l1 , ..., ln > est un n-uplet de tuples de la forme < c, t, k >.

< keyTreeK1 [T’,] , ... , keyTreeKm [T’,] > est un m-uplet qui contient un keyTree pour chaque clef primaire.



Suite de mises à jour

KeyTrees



KeyTrees ’

Structures Auxiliaires:

(i) CONF: pile pour stocker les attributs hérités.

(ii) SYNT: pile pour stocker les attributs synthétisés

CONF SYNT

Validation Incrémentale

Document XML


Seulement les parties affectées par les mises à jour sont re-vérifiées.

Si la suite de mises à jour viole les contraintes d’integrités, alors la suite est rejetée, et le document n’est pas changé.

Les opérations de mise à jour sont:

Insertion Suppression Remplacement



Opérations de mise à jour

a

b c

0 1

insertion at p = 2

b c

0 1

a

d

2

e2.0

insertion at p = 1

b c

0 1

a

d

2

e2.0

b c

0 2

a

d

3

e3.0

m

p1.0

1

deletion at p = 2

b

0

a

d

2

e2.0

m

p1.0

1

b c

0 2

a

d

3

e3.0

m

p1.0

1

b

0

a

d

2

e2.0

m

p1.0

1

replace at p = 1

b

0

a

d

2

e2.0

w

q1.0

1


Validation incrémentale de K2 et FK4

K2 = (/collection, (.//recipe, { ./name, ./author } ))FK4 = (/collection, (./top_recipes/ top_recipe, { ./recipe_name, ./author_name } )) K2

Suite de mises à jour:

1. L’insertion de la nouvelle recette Broccoli soup dans la position 0.12. La suppression de la position 0.23. La suppression de la position 0.3.0

root

collection

category recipe



ingredient

...

Carrot 1 medium

recipe


Mushroom Soup

M.Smith

...

top_recipe


1 Mushroom Soup

top_recipes

M.Smith

collection

0 1

0.0 0.1 0.2 0.3

0.1.0 0.1.1 0.1.2 0.1.3

0.1.2.0 0.1.2.1

0.2.0 0.2.1 0.2.2 0.3.0

0.3.0.0 0.3.0.20.3.0.1

...

1



keyTree

@namekey

@posK2

0

target

key@refCount

0

…context

Broccoli Soup

key

D.Simon

target

key@refCount

01 0 Shrimp Soup

key

J.Fox

@pos

target

key@refCount

02 1 Mushroom Soup

key

M.Smith

@pos

2. KeyTreeK2 après l’insertion dans la position 0.1:

Insertion de la nouvelle recette dans la position 01:

recipe


Broccoli Soup D.Simon name amount

...

onion 1 medium

T ’:

1. Résultat de la vérification initiale de T’ :

< < < < >, { < Broccoli Soup, D.Simon > } , < > >, < < >, { }, < > > >, < keyTreeK2 [T’, ] > >

<c2 , t2 , k2> <c4 , t4 , k4>target

key@refCount

0 Broccoli Soup

key

D.Simon





1. L’insertion de la nouvelle recette Broccoli soup dans la position 0.12. La suppression de la position 0.23. La suppression de la position 0.3.0

root

collection

category recipe



ingredient

...

Carrot 1 medium

recipe


Mushroom Soup

M.Smith

...

top_recipe


1 Mushroom Soup

top_recipes

M.Smith

collection

0 1

0.0 0.1 0.2 0.3

0.1.0 0.1.1 0.1.2 0.1.3

0.1.2.0 0.1.2.1

0.2.0 0.2.1 0.2.2 0.3.0

0.3.0.0 0.3.0.20.3.0.1

...

2


keyTree

@namekey

@posK2

0

target

key@refCount

0

…context

Broccoli Soup

key

D.Simon

target

key@refCount

01 0 Shrimp Soup

key

J.Fox

@pos

target

key@refCount

02 1 Mushroom Soup

key

M.Smith

@pos @del

yes

Suppression de la position 02:


2. KeyTreeK2 après la suppression de la position 0.2:

1. Résultat de la vérification initiale du sous-arbre au-dessous de la position 0.2 :

< < < < >, { < Mushroom Soup, M.Smith > } , < > >, < < >, { }, < > > >, < keyTreeK2 [T’, ] > >

<c2 , t2 , k2> <c4 , t4 , k4>





1. L’insertion de la nouvelle recette Broccoli soup dans la position 0.12. La suppression de la position 0.23. La suppression de la position 0.3.0 root

collection

category recipe



ingredient

...

Carrot 1 medium

recipe


Mushroom Soup

M.Smith

...

top_recipe


1 Mushroom Soup

top_recipes

M.Smith

collection

0 1

0.0 0.1 0.2 0.3

0.1.0 0.1.1 0.1.2 0.1.3

0.1.2.0 0.1.2.1

0.2.0 0.2.1 0.2.2 0.3.0

0.3.0.0 0.3.0.20.3.0.1

...

3



1. Résultat de la vérification initiale du sous-arbre au-dessous de la position 0.3.0 :

< < < < >, { } , < > >, < < >, {< Mushroom Soup, M.Smith > }, < > > >, < keyTreeK2 [T’, ] > >

<c2 , t2 , k2> <c4 , t4 , k4>


2. KeyTreeK2 après la suppression de la position 0.3.0:

keyTree

@namekey

@posK2

0

target

key@refCount

0

…context

Broccoli Soup

key

D.Simon

target

key@refCount

01 0 Shrimp Soup

key

J.Fox

@pos

target

key@refCount

02 1 Mushroom Soup

key

M.Smith

@pos @del

yes

0



1. Résultat de la vérification initiale du sous-arbre au-dessous de la position 0.3.0 :


2. KeyTreeK2 après la suppression de la position 0.3.0:

keyTree

@namekey

@posK2

0

target

key@refCount

0

…context

Broccoli Soup

key

D.Simon

target

key@refCount

01 0 Shrimp Soup

key

J.Fox

@pos

< < < < >, { } , < > >, < < >, {< Mushroom Soup, M.Smith > }, < > > >, < keyTreeK2 [T’, ] > >

<c2 , t2 , k2> <c4 , t4 , k4>


Opérations de mise à jour

Si une opération de mise à jour est acceptée, alors les valeurs clefs rencontrées sont inserées ou supprimées des KeyTrees.

L’opération peut être temporairement acceptée, et les violations de contraintes sont annotées dans la KeyTree :

Insertion ( duplication de valeurs clefs )

Suppression ( les valeurs clefs à supprimer sont référencées par une clef étrangère )

Test de validité: vérifier si les KeyTrees résultants n’ont pas de marques de violation.


Résultats expérimentaux

Validation from scratch:

Nombre fixe de contraintes: 2 clefs primaires et 1 clef étrangère

Quatre documents XML (250.000 à 1.000.000 nœuds) .

250.000 1.000.000750.000500.000

20

40

60

80

100

120

(nombre de nœuds)

(temps en seconds)


Résultats expérimentaux

Validation from scratch:

Un document XML (500.000 nœuds)

Le nombre de clefs primaires et clefs étrangères a varié de 1 à 5.

1 432

20

40

60

80

100

120

(nombre de clefs)

(temps en seconds)

5


Complexité

La complexité de la validation incrémentale est considerée selon les opérations:

Insertion: O(n. vkval. c)

n : nombre de contraintes d’intégrité

vkval : nombre maximum des valeurs de clef dans un contexte d’un keyTree

c : nombre maximum de composants d’une clef.

Suppression: O( |tdel |. n. vkval. c)

|tdel | : taille du sous-arbre

Complexité pour la validation incrémentale avec m opérations de mise à jour:

O(m1. n. vkval. c) + O(m2. |tdel |. n. vkval. c)


Conclusions

La formalisation de la vérification de contraintes d'intégrité a été faitepar une grammaire d’attributs.

Nous pouvons considérer l'utilisation des keyTrees pour évaluerefficacement des requêtes basées sur les valeurs clefs.

Notre approche est plus complète que celle proposée par (Chen et al.):

mises à jour multiples sur n'importe quel nœud de l'arbre vérification de clefs étrangères integration de la validation du schéma et des contraintes d’integrité.

Y. Chen, S. Davidson, and Y. Zheng. Validating constraints in XML.Technical Report, University of Pennsylvania, 2002

[Chen et al.]


Validation incrémentale des contraintes dintégrité en XML Maria Adriana Abrão, Béatrice...

Documents

Transcript of Validation incrémentale des contraintes dintégrité en XML Maria Adriana Abrão, Béatrice...